From 72c2cc78181490e72cc6aa59817d09e424b55e51 Mon Sep 17 00:00:00 2001 From: Guenter Sandner Date: Sun, 17 May 2026 15:05:13 +0200 Subject: [PATCH 1/3] package sqlite as zip and extract at build time --- deps/extract.js | 125 + deps/sqlite-amalgamation-3530100.zip | Bin 0 -> 2938639 bytes deps/sqlite-amalgamation-3530100/shell.c | 37308 -- deps/sqlite-amalgamation-3530100/sqlite3.c | 268860 --------------- deps/sqlite-amalgamation-3530100/sqlite3.h | 14335 - deps/sqlite-amalgamation-3530100/sqlite3ext.h | 739 - deps/sqlite3.gyp | 36 +- memory-bank/activeContext.md | 4 +- memory-bank/build-system.md | 4 +- memory-bank/decisionLog.md | 17 +- memory-bank/progress.md | 6 +- memory-bank/project-overview.md | 3 +- tools/bin/bump-sqlite.sh | 38 +- 13 files changed, 197 insertions(+), 321278 deletions(-) create mode 100644 deps/extract.js create mode 100644 deps/sqlite-amalgamation-3530100.zip delete mode 100644 deps/sqlite-amalgamation-3530100/shell.c delete mode 100644 deps/sqlite-amalgamation-3530100/sqlite3.c delete mode 100644 deps/sqlite-amalgamation-3530100/sqlite3.h delete mode 100644 deps/sqlite-amalgamation-3530100/sqlite3ext.h diff --git a/deps/extract.js b/deps/extract.js new file mode 100644 index 00000000..2d659ae0 --- /dev/null +++ b/deps/extract.js @@ -0,0 +1,125 @@ +#!/usr/bin/env node +'use strict'; + +const fs = require('fs'); +const path = require('path'); +const zlib = require('zlib'); + +const LOCAL_FILE_HEADER_SIG = 0x04034b50; +const COMPRESSION_STORE = 0; +const COMPRESSION_DEFLATE = 8; + +function extractZip(zipPath, destDir) { + const data = fs.readFileSync(zipPath); + let offset = 0; + let entries = 0; + + // Detect top-level directory prefix to strip (e.g., "sqlite-amalgamation-3530100/") + let prefixToStrip = ''; + let firstEntry = true; + + while (offset < data.length) { + const sig = data.readUInt32LE(offset); + if (sig !== LOCAL_FILE_HEADER_SIG) { + break; + } + + const compressionMethod = data.readUInt16LE(offset + 8); + const compressedSize = data.readUInt32LE(offset + 18); + const fileNameLength = data.readUInt16LE(offset + 26); + const extraFieldLength = data.readUInt16LE(offset + 28); + + const fileName = data.toString('utf8', offset + 30, offset + 30 + fileNameLength); + const dataOffset = offset + 30 + fileNameLength + extraFieldLength; + const compressedData = data.subarray(dataOffset, dataOffset + compressedSize); + + // Detect top-level directory prefix from first entry + if (firstEntry && fileName.includes('/')) { + prefixToStrip = fileName.substring(0, fileName.indexOf('/') + 1); + firstEntry = false; + } + + // Strip prefix from filename + let outFileName = fileName; + if (prefixToStrip && outFileName.startsWith(prefixToStrip)) { + outFileName = outFileName.substring(prefixToStrip.length); + } + + let fileData; + if (compressionMethod === COMPRESSION_STORE) { + fileData = compressedData; + } else if (compressionMethod === COMPRESSION_DEFLATE) { + fileData = zlib.inflateRawSync(compressedData); + } else { + throw new Error(`Unsupported compression method ${compressionMethod} for file ${fileName}`); + } + + if (outFileName && !outFileName.endsWith('/')) { + const outPath = path.join(destDir, outFileName); + const dir = path.dirname(outPath); + if (!fs.existsSync(dir)) { + fs.mkdirSync(dir, { recursive: true }); + } + fs.writeFileSync(outPath, fileData); + entries++; + } + + offset = dataOffset + compressedSize; + } + + if (entries === 0) { + throw new Error('No files extracted — zip may be corrupted or empty'); + } + + return entries; +} + +function main() { + const archivePath = process.argv[2]; + const destDir = process.argv[3]; + + if (!archivePath || !destDir) { + console.error('Usage: extract.js '); + process.exit(1); + } + + // Resolve archive path relative to script directory if not absolute + const zipFile = path.isAbsolute(archivePath) + ? archivePath + : path.join(__dirname, archivePath); + + // Compute extraction directory: destDir + archive basename without .zip + const archiveName = path.basename(archivePath, '.zip'); + const extractDir = path.join(destDir, archiveName); + const stampFile = path.join(extractDir, '.extract-stamp'); + + if (fs.existsSync(stampFile)) { + console.log(`[extract] Already extracted: ${extractDir}`); + process.exit(0); + } + + if (!fs.existsSync(zipFile)) { + console.error(`[extract] ERROR: Zip file not found: ${zipFile}`); + process.exit(1); + } + + if (fs.existsSync(extractDir)) { + console.log(`[extract] Removing stale extraction directory: ${extractDir}`); + fs.rmSync(extractDir, { recursive: true, force: true }); + } + + console.log(`[extract] Extracting ${path.basename(zipFile)}...`); + fs.mkdirSync(extractDir, { recursive: true }); + + try { + const entries = extractZip(zipFile, extractDir); + fs.writeFileSync(stampFile, `Extracted from ${path.basename(zipFile)}\n`); + console.log(`[extract] Extraction complete: ${entries} file(s) extracted to ${extractDir}`); + } catch (err) { + console.error(`[extract] ERROR: ${err.message}`); + fs.rmSync(extractDir, { recursive: true, force: true }); + process.exit(1); + } +} + +main(); diff --git a/deps/sqlite-amalgamation-3530100.zip b/deps/sqlite-amalgamation-3530100.zip new file mode 100644 index 0000000000000000000000000000000000000000..1da68a20d9ab2a3bf73195feb7c3ff5aba71c55f GIT binary patch literal 2938639 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

UtHDRs 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�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

aG~DJ9b_KuU*lVAqR$QF0-L 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%0DsG8AOx1DIFUKTTo#$1 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 z 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

`&gL$K&_MiZBdF68p7J$_N9V~<9Y2A51@zMKbA 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 sLyKNcMOI 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

9O<`%lZfJUcW|~@D{T) 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Σ&nveMIYnVW2z+pKb^z%6}_fu;%!z6Eb;kdZ__yC?rMv zj+(PEaZ}ZIEF>l_YiMo!$_unidB6&c1syGBMXXYzy7qEbO_P=eYiE!_N7rYleu_-n zcBwYC$~&V*+AmpClm*AREmjx|MWc^?n>tF3eV|{%@@E-oFSB=fn?~AVIS;R{rfS-+}plee1e@YNv+riZS{1)&8S4$aqr!*}0a zK%DsHhV zORa{&{$7dC_N!N79SQ|s2R=;Xo!GV9L%x&Cd`emFe4$8OzP_)qYM#Y-@5{3FYB_3# zR^X(?KDFQBr%E{UsP~lDCS(?knfxxFGX0BvSZDojTM$pI9Kq2>tbf3e4XXH%HF1Lh;5pD27r?B)}$b zIPpyL{1P0n(w<%@Z5yFOfrHA-J_>|4-?YUa={jea*w56re=H9KTW%auiI;`}OXh(G zt+7vnVRxsOEad3{uWDzI>EmuZSb-{c7o=7~;0f#n?efmut`*<85e=lX`+HWB(De`! zhnnP>){2pG5TwALR}&`(6OJAQ_CP0CnuCl)fPO*1?miATNR?K$&RUK}N1`v=YJd>P zi6(?VD2LkKAc$_9uK2^|Z9I56lCU4ddPk-?>|$_A^7IUImr%SNd~-@V+9#*U;e7_e zK47f4>*UG_`0g#^{I-DbqG%j2{XQ%nX`Pr)PZ|e&^B7mf2D;bhPBG7^H=aO^gOFHs zM|T)=^V+Sdk0q&F1YU)IR#U)OtGnSst+4-_*NSz=PbHUf zfjgJly9vg1f_d?hYVaH!fBXoEUEoW7@1)G*{lkM(EHg~#^Z6KKuuy3u%m+ezfYp+y zGgdzqs=pJ%rE)H;{sDS0jqf3tZhoMuM-Nvl6a`Fj#t?$dQ3-R83KSr4)`*D*(F!9v z+-ER9Uet3+4^~xHUW(X~ZcTCo(kDG|4tZwry3*t<4N%%&U9ru~oxV@Sq{J|WO6{`c zTqf%GA!X+IRF$Kogd8y`NM{9@Z6^=8ZMH+k~cwkgxb2v;8hQQ+EN<=OTLu@9l zW7f^qaLzBx_t7n+-5Jl24GbZt#*=SdPi|nVT&UIHTYx&$=Td}_B2(667%JKNakc

|-d{(`B?g2dy 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�k9ba4lS1Kb`al5^o&glpn#`Y@)esmqYA&83B^ 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 z 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

BG%_U>D>Jd1J`Z7;f$Yhl(73}|iW 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 z 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 z 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

SOc*W-1>@r`G-dL6{^Qj;}a z)>QA?-PQ+4ug3y&9${e5(QJw~+6YJDrxN+RjUBbuvYOLqZFstrCdPWgqV2Iu2uMuW z&r)KOl$7yKt&F@`ADcm#%0N<3R?LTB=yA;bW<8$RVpoENC8lW}_0Bk*)$W_2H=^OG z0GL2J^%x=De`j`&F!3k5{k^xxKMJohmDYKMFimw=-c|>P<`uksV*c8Gzqjc%3m6e6 z2>mxa<7Rm(8qxh5CXD$H4e_x^E4SD@f+0~lQlt)f<*HqExw~7x?e*Sq&h%U5`+R;{ zF5vSQH;qZVG3nGJE22+2S{yfIZhrq@o-x~9iPV3*`oZZGq0OLLT>BrqQ?c! z(!X1Sbm+fKybppo<266ZkPcTyb-`QYOXN)l})Hr@peIaQWSoa`bvqZ zM6gug9O-nUl~S>}0+$g-E6gl1-Vr1zUDOogWjG0MDWgzDt2DBfD>G?p^&NOheC~8V zzr@vp(q0B%v7G+2bAak-Q?`H!=R9I%C7HmaDC?<(>FAD6I-GT-YOOnqTr<>Ed2KE- z3@qU6FV&DHZBF{axhP~p-oH6IK0Mjne|OM3-g&cQKKu>aC-3jFuMuOL({&J(9I>=t z8?DA(J-W`OA6?{_19FRVSFjBQo8XCCWPp1CfBhAsI#Wvrkf!roaI1l{fpnM6EmYR& z{JaU#JP>sT&|ZfBM!!Ef8?-x5h8s^i!?VYy&prq>WM-XK>v^-)G5fc&^0T=uB;YtTk8e@)FL4GI5bJm^kP=}^ zE72K&>$4HfI?d14hvfLMw|BJD-#cCu`=so5AuH!4?E+hND*>yo_l>u}rf6~9=tG$u zyBN3~7K{>ZtCCUP|NQ%;{lWY>fBLvS=@du1oLD#on8d&gzJzzMmSB*?U$>`$sA2Ct z(VnB+LW0Vh`Ps{Y2+}TyAnsD@=#%6*XD#41!Bt!oF^X~uzl>jRz&#EXHq_NUekGr_ z^g;hB7s=@|h6K9JeuFCz6yCp5!1-Cqumfx-GoxT1F2+l^Uq3AQf|rFOZ)qbytoJxGmsE_~ zFdk7dsyx$XKsE|x)KhBTojaXJ9;T{Bvs16}zNDqA*QO6^(^st@nyvLGFCLoz)awP| z&FnQb*O#mYSpDwa`r6rQgK*{>Q!T}r8eSUvCDjqwSGC_f4$zxr+cltUo|w{@&_$I9 zd>6(dRT_uTz0A+P)e}JU@f#z}vSGt8hI|5^haR%RJ4BGE)fp_GqTWX~Bhgu$j`9XY zE-e^(9TpG5Q_en#T?HH#Pr<%vHzK4|;?{6m0PSR`tVd+S2I7@SWg$&_ObM%gv~t~G*rVVhu$zkW;dwvo^Yr|`4y__RUl zzG|b_=MJjxZd2Sr(Pf_4kS-*dnj`IkR3w6tOV^#rHXUPjCPAvF7V8!s#7iGygvIXd z-E{l#v%T>@gLLMfOD8|!_8!+QR615|`|s-%G3j58br=E>{yqI5vnRbe&S*P)?m##~ z_)b`;0sPzsMW4sjy)F60ckhLr_W$mo|3BG7cJ~ki`M2yIW@281qPZ&5k4dz--`njU zZT6Xq5#9s;@qTZ2=coSeZ}6udo47*y4F`LgGmOoAj9^06sfSZbP$pXfav-=z0R_Md z{6{nND|X_^XCSFkCMM|b$CR|L*8R_q(&W$wigV*QW}BeJ){#V-#~3u0P2luUCRRY0 zy-J6O)|!$I*%r8_o`7qH3yC%(O(|v6_yLG0vl+sB@pkn)hpsOGkMv8zU;r@y-g2^g zD8Fim=cZ(>zN(`l!5ay5N9oMW5ndvHBMp@699P8ODI1He;3ze@``mXImRY>dre?*n zOAzf8iWz<;{&|JVjK2N`kw^Shhog^_oKA1QkO6fhET|z=JATv!b_`;aYkB%P$JcZI+=65&>ZG*qy@G}9_VSgh;#lf!{E!W<#mVU!?J16XT#^krvfFd_yM%uj;_A7u+)+0jzIL$B;jHx{1@nD0sTg*kRg z#==9u9a(diO@eo>Qi2s!V3YFO?^d1HD9&Lwz}%c53~V60^M0krz>1s@@p)!tzZYFs zMzMFWQ|%y7tnlsm=-nQa%W_)har~tHq`lE>cUqmN4AHoFTG2X78l~$gn9?B`6)JLW zo65~cn-3qlm`I}GR;w(yup%m?NPT#^MBp7IzRbgY;zuuRbiRMuGXLFp{5{S`c_p$@ z^8}zYRh$E^X$Bx;cM^grdVy}Gl%F>jWejf1=^W6E$+9yifK;Yc*n!f!|1JA&x%G83 zx751MvROPjsaRdj1uP2?wN)7x@TlS9E#v`y?KifqMLL zvNJx*FzR9c3|;_(i{415Tr`ujy0!|s#?|juZ3b2>xIa#Uf zQf!=U0(MjsdBsdW@rgxXu@p1nQU@VY-j|m$AKQi?Jn@j9!04%MRFsaR{+rFMolSTq zUBIKN0fK~i)v-a?JS$LpYmL{G5;+Eo0s79LqDB^yk$nc)50aNPCNL|2oN}H=(S!H_m3`2A5M2u_4Qxz2%eVCy)DrN^UN*g?UVjH2K6wBrqJa3$ zz232=$<5wT|KzB@2ib;x28FX}+xcv$;0|vD^f;%@lP6<-szCS>>^pA|q_QB`=R1s` zH=30V0H>W#-~pv3N;u?AyhG4SV}iPc@jEz@wYpXU@VMXgjyHewHcu-ovbP@=Y8Q+A zva`Fj**n~lq8;fS1EpX*9l6_)8HM&l^3QpU9wT`4lt&BOS_JeN8H;e5Q(p*!Gb88#??QXn=-;csjIB zgKy1oIz`k(kg-&kBRE{Tmyp_L{K-R-MwD*={z1;{IW9UXKZH~?PqmeFo!{5j*FX4m zyt3MXaWKk2KQ~GtI7#K@u|MVA`u+dfHp-hIg>11AA@YkLK~rbpzG0ej?LHAETnYxG`N05@CKWP-7!G8^>gE@cje;>dlM7BQ8`mFq}xGjXP zK1(g2{DUUc>fgj5H^OS0YdCIx{;*2jmNljXO{l_;t*~yhKakx*7`=UY6t5=vU{$XGWC|jf z)KBC;uxQ6Mc&TyXEz2ZG@j-*vWyrhJ(9LN%iPDORQUfrmTghusWP1hkwzg)s6iQHB2C3Kht5YCPGiH1VhH{C8W z4dfZ&V)t>nC?LWcIt*kI=Zb?QT$JX3RDYPuNCU!H`B65Y7n6Z_Fx{>lb^TwQbRG^J zjMauTgQ)>P-w|xqrT~BI*pK~cABH^NG!e;|x(V84bXxqsjOUdRNl zCYOsAgnB;Q^=>x+QW`T@#VyFaz zO_ZDO6&(abhCpq2F62o(B?*$UyCKXoY*qrVHg^VCM9pQwPb3e6!eJ`P1is>UJM1lR zMgk_lUEah8wcF|*DeIX_yU3qr(i@%9S?-3Hlb!J2o9zz`xnt-qa6R)@gVuuxT1R1d zYSdk0T&?CSlf*$zzzoFDfTi>x5IRng0EaRoUa-`P3 zgzb2gs3j}Q`C^jYQW)PvK=|yy2CD`lyraa{wG_}G&G~+hQ6}O$T(*HwAPIJk`AC-G;^c%j}D6^83aI zx5RD_zx0?4-@4w8r`j#gzk~}ggvF?42Nlh4sFFumnRO}l@HNcA9$@P8i!yG**-*1KY9x?hSd zdaNCy)y4$p7Vib^EiRLLds$ z>gecC?qq?5I%h_nqmrz!eCw*GjJr8)XpQ}-Q>WF#s~&e+aO?XGlrTAZHOchd>spq> z`?i?bwsL}$i?_(j1eNZo)n629swD8v+H3A+P_5MJ+F~h+?G~lXBN48K{+4i;Urqoz zg0nyXhCQn2(lZ_8LX~u$6|f?!Jb1Qc&vzH}(^kLaeZy-D6RzX~9W29M?}~((R-7>V z+S6YatF~QX@AKeZt<9eq@x|*YeIydieKA_0ohtO^31%N=b&1)h#3nq|XJq{`-=%pT zH6w3jZkcmz&zsrG`EEFOEFhBP18@3E=Du>?mzeY0r@T1bX0Ellt$}?E=6e&N6MXP9 zNL`XUCvD#{2=0(*^O1z6Km{{+#`N$I-wV@thl^ru79mou{K2#9n)|!Tuxk_Oou$ z0urZOCD?&St2FUVmY7|o9ID0r437#TY@mG;J8N^K`zC^@M_qa&Sbn*eW+o<2@Y^5&NTh+hP~)DAaE4jBaQe;%F>ri zb9_MfIA7x|Q>jB=n3kiWCb;;{vG&WAV1vWzoowy*kM@q~a>AhOqm|`@NTEEi2P0Q3 z6JyWC3*ZTO(oje$94~lBs%ZX208p*EzMzTQ$hkzt4Tg`=NyIQcIhS;>n7PP70T50` zTS9yR&XIsAzmkdQRoG{4Z*5PxHWb)o-Nv)Rwpb!yMFq{73JW6bUYf2rf%rG#bCV74Yg=&bJ{{(R`9F(*6o?3_wFIMk)zCu;ZU{90p#r-gfB@EY z`fbxE`3bz-23U}BYhm6a#b(0nRV~R})wY?dl>Rf=5oP(Oc%R-597jP}He7A-vT`wo zbYuAxJgi3P=@c?vO1#W;jxchCRZ-Dx-_$4i?*7e>pFMs49RAz>zQn&7^$WK;Ih#?t ziQ8=6;@ez`4(QQXkR0jO6{OsuC+W~zLw^Yc3*ALF4FP}ZEKPE@3)`fY+$Yf7Ad%a__w_$v!N%Fe@M zN>A(1DSt)pRH#%Q^T0U+=s7FXlH3?cEsrMV<%hO(@~SnT6T`I!vtrbV5qeBR z|A{Sr9m>P5;;>}*;Mg;yYUkwwhc(?e{YXTy3I!ZFc6oI$lFo5C=528zs5uU?T zQk5gcX+$)E1SEU*&YnJaWvEVocDJ+J-#<9s+21?a+UdPL@`HqQuYvNnez3DVzCW4m z#h3UrzhlgzN`UeF$f z`N`3ZXd6SX6L4|Ah(~8liodRnKb=Cl^E#!8!RVjpBDsNGHB8UV4ONUqK`vy<(D#(; z)QtE+3tW-g@ShI+X9NE882nUc{sL&m}3&dS{ylbVvr z40(g!U_Q%80Q8K=W#{*JPskoB(O=Mk#s8_i}jijKg&Ivqnq;tV|1 zqvz|b!BQYnp?0MD@27WElp`I{NfhZ2&xn?sTF&R^PO9U4d0F98|1B}91A6~Xt3w1PZD1V(GTWK{q66o(F^nM-&aAG zI6bdELWT5kvZRDOYbqI;1{t1?SK8o`Tp@F9f1CH%i ziILU8z{3vcZnPMh9Dhv4A|$hWhzGbiPQPtp4OUgm@iOy{){f1bF?PSEjpz@CQN*KF zl0c*Corqu4cZT*Iln2(Rv@;HEmgAjea2R2D8u=JuoQzmxYBSa$k~gKgm1>G=nAN~Y zY#RDQ7>*>RdIkLy$y(1brPdi-Ol$Ye=nVU4Jov{y9uyL3$dv+v1yW5XY?%IBW>*mQ zV!HqPA0HZ#P>P&a<{#j8Kd!hmi0o%Wlxw=y$J*odD_Tm`Un+YU)Oy(d(Cxxtm8&@7(9Fx40Sp{r&!Nzf^KbqJM&JrZVd}-d*4xGxk(O;&16|hD^B>?cr=- z&*v#(L!t@|Bkpq&dBBru>^l;o68DHPKj6B}=TlS_7}4TXfDfA3S(cM&G5{WeY+vAL zMc*@KEFf)yrza-fB`ZC=Oi5PJ0t1iAT>jDlXaJ}rm#4`PY8df8kbXEvvsIQ6Syn>{ zMG&Y!_YWPiKx#8<@dA)nuL4f#)GR~{^h(nFntrH^U`5xzItlIMeXQ_kNbo!fHv+rN zY9~#I<4@uto8KIu6RmbU3rU%_?KUWix8M=M9$02qPqUE^`{7GaxO#sbZdyIkBvs+p z_*~vm#U3a(zB*lCQDur$#0NvPtY!s{_dy9&D{cZAMSW>KdU-}bn_95StEVI{Am0C` zo+xZ=h}!;772;b-3iwh1500+txN4)!Z+}iK)3-~@%Nrv}$=ErUN09kXQ{s2ctOFf^ zqbd*F^@35$UIRe#-|cXGyI)uhx>E=GR+>f!Fi;WIm$CRM4?fTQd`ys&Q}4K&H&X87 zz*s-22Kz>xdEWZY?hMck73)gT@JF5}l$I$1p2N5>0_EY8#1^s=q z2*EeiZml=3FxKqmb?c_xIx|0J^Fi&_jrn~@<-kX_CQa09H_?6bbsGww=}56xt(#V> zrDM8qDjzd)%6!Tr|F_I5#LrHap5r4?H@o2}>})vpa+zkUje+V-}6J?WCqY{>z3 zaihGgHXwJGx7GLBYIjI0d`n~0Ex*OPbgZl++kQu$5&72lOLV2(S+XyGrQhZE&f=ec zh?GsSUXcAExDX7FpyO4XMK|ND;C4W|d&$*e!!%+KdO8XY00UMdlJ}f9TPz6Yh zvu4v6-Tth_)x?B;wa-oXtG*~@;jNEfC4#+~!@B{44;=`~82++Jzvi>E<}>>w!@Vv7 zS{v;mrZggcN_BeRSaa> zkk$B}qnGg~@_o3L}hmvHRE(CrtD?Eu)N;F&4&a(^{6R0a%v%HjR)Dp8x_u#c*%MhUHqEn=^{NOcP z!Vm9(!l=Z+H~p0<;sQ*IeOoVy^^pv4KwuxXj_OMshE8%f0E*Dv;DE;&Tj7fA|#;4Ja=Xr zh`C-}wI(9|vK4SIy7q1}?f`+ZlHslFhZ1e|-@JcY#!Ru*9}G`5|NahyKSVE7v^0Vn zu8F9CJ;o2{j}oC{iEOMgIk&_{MRuYp2ikTfWXk*pgE2k0M@=~E*9zq(k#YE<1uk+_ zgTX)Q)RmQsip$;c%)GHGuVTPU%m7={NEPW>I*83O;R&OBJ2x}JL}$+%Lu>hz6}> z18#I@b1>%)RZWh99e__1qAzhcy5`U@Kq)5vFi_QjT1jtlrwfVj%d(-su~@4SG0*d< zFn_}Z!&$3MNH!FGpmlv1)X^ux#$($rhIJ=50-Bv0sWw>XggCTyai5wUJc*k0d%Ywn zjynpjuLU~@)h@SW0M`da5@$pznkQoXx_Opj!ZFOX3aMn%&xzzlD!iS9-Zy+eNjfAb zJ{^3;yJ-0&NM2&+sSYUSHIm_J8GlS}dE))u>O9|QK7IWB`D2w$d9YB61EB)Ngj+NL z|88|JyfzfyJ`N!fdmgrLP+9QOROJA2^39^^hsh*tn@3H?J|eNn7{x(lP<0lr9Uzg- zXV8DzjQk!e+*RPR59d0gSD`Ac$5dAOK;v6u4Lyvq8s>X04M)4!Zw4#oT+dQ#Uyosw zWfQdWy!31B!Yzxh$qy_Dqcb|e23csc4~`JH^prKfYZ{=8ONj-awi7;{^=~HT9KE!~ z_vo>MolM|6lAd*#;2kVu1s1n)8;ip=yIs`OU`5)IsH}FiQiw<_XzNy;knEY|!s&~6 zNejG73-~AaM$oIPa8s%m0T2Q}mfWUH<&}^a3NG(%{kvD@{<_eRSU?PIuxds8gAaRq zM?3w!KKtLD5YecN@m6Te`UZe43Q?Y9DR;8dEDg`HVeTlKgT^cYDjXp1I#Oj>K) z_76!XWRtI(uU=VHMXz%uD*vbX*qh24OG0=k6b*|LiK( z=R5Ht+e<&(>#98on;oD$E++)3i4JQHJ4~8YuLkXT#x+U|94IcC$$o9Om3nsI^n&jj zES^6$`cXJJUys+_kEG%M`OC+)Vc?gti6Wv z#kf=Z&3*T4vt2J@Nt(0xb_xj|K=s9!=gf%#r=&I}h27X?CdM#LM+HK;(CIxL56u%C zb#N2Fe?)TE*^8*%h&t#L_pA}MpEjZm^Vj-%fQpWKiT%+~j~@Pp&BeA^_p$avS(vzGr{D6;7v#sBfj${4t5N4v8K5W10;?y9$LVND`Q*kUsEz(4$nhpM;Y2EJ0 zSG4k#x%1r~S$}-E^A3O#cI6k~f`{~nOLlIfk-;Aa+;L!gwr<+!hA>LbW|0w;FB|5g z4t_L68Bjjkz|TMl2lF~4-IaC|n3&+|&PmLbu8fsNvvM;-cuW;@z=q54Dq7gdCqm=?K9 zhOrj!GNN=)&BDqB?kf;t!_!v!Vp@wob3|54rFGdE57Vo3h*=)|a2<~pPAq(~XnNcX zSCd*<9{7(W#WIQFb4et?-J%GbQ^?YP2M|plxuZrkH3|TPz$$69owK%cGZ{|a0zY@9p#}{QL_$-5{!qs7VrCAdh-4`Us^|y@I|=3Tt#|X;AGX~? z&H7r6k>ThHc*uX*jpZ(C+!UW}bhf*u{To&8&f?I~mh{eILgm<-Hu_mSK^COZm2`?co< zvAZysm#W|#q+YBp^uv5gnq)o#{e3V17o7 zF?8H#7$@X?_9fW=GDDsJc{7Az9p5jeno~a#TC&A2i_O6@}Sj6JD~ri&brt zn5J<#OjjWmU~F3h1v>cmgFOYk8OEk6$w$b^KdeX5d&BuZADQQ^;8(EAA8wsZ_XH-kxOMq88&0s;h;p_+dn3E z0T*imt`Q`nx{GOnd+S(57!{=n6)cPeQI}~Rv}<&u9MLPN)KS-qTm0)Dx_?B)2@s`%t7;=@Gt4 zj}ku#5x*1N%T)6mpTbom`l#w+O~r!L?rRsB5X!RZsi~i%QB|mg=Wn-644G$F(|ko) z*4`##069+_=U`)*Vjb){humXU%084EST$exX0J`nXEZSAfZ#zfK4x{bd;)-xS|)~y zoMJ3naZVQU(GEgaO|$tqWft3`fG_7Tg1DB!xUhmDWIS6|{?d|`vcVa$0 z*?zyb38-9ZKdjEjAII7Cc-2SJo6j=HAv-|CC#yANh$=8qatdm2ft!z~$sju)n+L$q zQ5gej-Zi-G4Ks9N97p|M4|aPyd*A^lzyAGw|M0iS{Jw|qhZ0?P`w#>Zt_k@p7MhCz=yf>gozMKZ$hKurF?Nuy`l{Sz~!H!P59Ovxs18wbOiA-;O_ z&v^pE1V+=0ud)#)D32$Tk(pU&qRENwog~9p7s*Y0DUe`sbPh)`9VoO<>V8R(6fWks zI}MK@%S|(53oeB|F_D)mVJwvW>&ioiyL~Z1F|wkdT%T+_Z8zIb+fQ0WDA(*Voxw&# z4+VxMKK&$+H0#mMjANI`qxC9IM;J1jp6Q)+wEuo@tN-hwU1T>THzHf5B#jAEvsqU# zi-v&eqDI{s%Mcm=I-6Q&Odj)-=ifi;G+V9K_Z@-}q>80+#AOT__eM!$3d-%*GWcGo z@QoohJ|E)U`TMibz1xS@!27*aIfPWw&1{%hB)^CQK9~OA|B^anR@qR$)8`#Aw>-iB zaUCl0)UVT$YMuYacD`u&&2!XZ{1Z^v-9=-ms*&fd71s%f0|Z>>&lis-7cs$N7+NIB ze{m$CymJGcOp_~&XzcPPqZ0R9H{VO-hiu`pG^Ems)zkgaZND@!>tl=pB~%elDUf2q zorUeOqon!rbwQ+uPw#bYr#*3A4F&%33~W3EHtu4nhk%G#6zYR4dx~hQD70I}35?j; zk^R%{T)=7-M#Vj@w4ZTn@?IBoi_1M;(Mz<7`D2q9pS@F z1xSZ(4SdpNI>tsINO6yyCdjW`$h{aq7Y>Jdphsg-R4d?p<$i*ju?#VHcfYrF(*O0i zZ|20xb3GL|3^&6li-&kynC>PZ_7H%-=~99oOB7Whw+csO1Ua4ziM|=iU&0UYLN4f6FW-*aId+hMoFG) zVPcmi39iu}Ez#vb?UEmT>hLZsZ4_Kx_^}(P`i&kH5 z$Xr^D)Hm-lG5`EoSLxmuQ9ELGa-DhcGB#gYbdimQ_BCvQT~HF6Uz!DlWZqYR>r5tAs!gk>O#N_+t4fHpiv;CO)0#7a!y1UNXOoQ^@W#zr3V3zV+cuUE}5L zM^1r`hyb?cV5~hjJ(Fp|DfzHLQ2q!nU2fS^xyZH9S) zP6@H>YI-&b4DwVtyGqPg=KPD=(;+=?Wf-iL&&&g#H^Z%yCBps1Y&OYXJbILj*RRu$ zsafkZUeBiIkKnIINan;=I*CW;=7i2JF1hy4oa&uir7z*WnX7411 z(+{3Kk8YklHH;@CFKYzeKwL`mrnyW%$Mm=akikpfUh@gPb#0Rc&i@fQheP}r%K(qe z9Kb_Cx*$7qZDM|D=r3f;(X$}@7))JIrTH2+a!Coatr~e{DuUrze45wtdi0upn_51= zbj)@}y)xtkozn^(k?X#&n z1WV854hANa&n6u;3-Sq;9`nbmZu7AbaGpGW{Bh6i{JAM6Uo>6u${oS|HMQ!?l{~r(Z;4xK)M#7O zaXy4;i*FGjlY{S@cQ)fZIGUs~h@+>Eo2Tha)^C}$LhPZ^ecuqCXgap?Emx{yX(o1u z%9PaHGSyuf*ygSbFQGmS1v)?`tlwI11(SW4%?*D^T$Yl7R(8Nr#fFo{=LtD;&9YfM z(qX4Z@3n6i->P(n)=sC{$7Ea=7_;#(o(?%U+84OSm)MS+pp#?M%Myl6O@k*{SX#iCanUtB#wi9{T>Z_Sx z1-`zF*EyQ_FL~f3&<6LwwWJK3=60iN=>APPpuTOS;AG2WO#>?8Gw1@ALb=Ny>s_a; za?+}&jfPd2yI@o$>X4PfIAjZS@3;l--i=Tf<0h~5O*e|w&fxQ>M8ojQ&feDkFQB0h z`N$5WZpo9ovy%U%oWwj6CKNS^cY+uwqtj#%n`_Xr);gv&i7w0yXudPg2+EAki84_! zFv}#73WzJ|%suvdyT9~)JE~3U3t5&0>Ot1^+6F|^-_53DW%t~1@faD8`DlL1r=E}6 zE!$IX^zs8;dOX!pTH*|eAhkpQuM7u@o0)po+uiLS9RtaykMDFSn^vSOIeoX*-t8T} zwe8k#KcKc^J3NWH;YG*0xy<>t=NhQ4{4F9YqdL1$t0H-mJM~dffY?sQxN$2_e(`88 zc|KeImF>3ozlwLWzn|@9RExe)HME)rPyW@0%D?QksxvO^bHN%5#`Ohl@p{;Sv7G%- zs#a{Y<)|#$GXVuUF`9t7Pi1@P<&Ce-|J#;Vlm#V%n49V;$uUzU$K1M15x({L@0Z0% z({H3&agJ_Xm+2#^O+&IzQ!mT}-aub5w=yg49rhKoz4!qAH_T~?3u$3iL!YHG-Rs9B znErX*D7k6R= zfgFZb4wCc`%v4D{_rhQkEtR2=G*R!kF}>oxlpD*o`Ui*o&E9c;YsJDOly#QoP&=Cp z0gN26!_6c8jd_v(0bXim`T=o^M7kVyBd8x{ApB($^qI>E8+R}peQH3SWyqMqs*9Xf zz%11?5#;r3J|$uZ3^#^gBrJpOC*+w#y;~!1XzM41yoC!>0vV#im|g<3y+2J3wh^d3WirWQkU^fDgP|G@|rrPu$V$_^O;(Z@!Yvhy-Of{XK#8Q z!R3j6)p=H5+OOXv`KYX6&*Jrx0b}?(6(7)!Aoz($o=qULoK>uYU^^$y>utzO^ z9YhE`;+$h>QX#VC~Me5i6g2-YMrZOD+7SpPi=C>iHsY8En} zS&ye_PCZF6UoPB3+l;;*wBOKmi&0}GZiMKrY4%97O+;yEsr7~l%YjjzkmHA^;s(wQ ztwqqtDWoq%-8LwonaVNLID<$ZD39oOHb)6KNaWEKn>nKgW=Id=+elR|E2f&zZ`v zT6JKLwR`TP*DdupWXeAePZOj*`J_qLOJwII&jw4<%9=w*(C zu%Xuf_294({czNWE9`jx@CS_LBWFEWZ!TcJue1Gd6G$_nubd9@kbev0H<7xLq1GW! z4a(K%qa|eMC3p#Z_tY^YXp78n4YsWXSxO)t@DrIK(VyayP&Z>N*wgsjOr~Y+ zwperysM=xEob3eR^XyE~P~5{Xh>^U`=A)q!;ml4<$?nJxUf1R|uxm=J3XcH{`h#{& zgFVhQpG}8Q*<5yGNs0;b3i^{ng6{#g#vo5A9&D(WO+WFQ2#J^?r-|tjBv`tLbL<$! z|6o#km{UV;l*z4U2oD(muz}y60VFe^Q$P?azV)-qWOgB`V1h?FYD*;ZdF~LC)Ib6H~8#fbA&nG4^wBOXjhXB#%sQ8FRy3XZ~j&j$2iGBfW) z7vco*x`1$@QMDc+R`+CVY2@Y-11Rk?wE4!c=I;d?KPx`0ty~9vjOR0IGD{b zz{k81vgst7@_B-!_I6Bq9*K2w?)Tb{AlWqVNt=%{Ldphv2t$F>^flX7_JQThhWOyf z*Xu+i7*-dC70j228ayxLctC+>My7WjlK>i`X}Jeyz#oh#t2v%Jamxzz%c8-syD58C z_`NWleY?5&GAzqcm$+|Cy@rj$Tn4Clc~}wU_zB&B8`$sO-JTAHgnKz4LElUBPENXv zMgyDR7~B)PNU`}EGE`mO^dKy_D>7W+8&mogs4pkW1xO|Q?r{y5sQF!=l#c#ZCIdf#xfjWW2f#C^+2^rmtSITUjYwP=i`aJdwA-Q{+rH@y=`WljZ+c2% zjlXJ&xR*g>0;6icclWv#(+J8c{6cdHDDH<`5Fg1$cHj9-#g>Dej>Q53$gZ*JB2&kw z4qigwX9`Kz;^~aE*z_JuE(1t4?g>Dmxka?G@iiVPvf793dbB2I5+KwHP-#HyUJ)t{ zBeGyl&HD80u!VoW^vb$4zdgf6fZ*>b#e9@bx~{C?(h5EzWuu%XGEDfo;dQHWpkE3L zR2Z-}w=0s~+s$?BcYiiML}6&WZZj&|VO^y2vU>FL>|=T6D4C&iws(Ald+)#Nzbo}w z(R^W#o%jZLQuGVEAOG3)N>xa z!(**PCjTZvLX|*p+f}ckZV4W4K0$TAk>F7}0;XexEhB?n$J4Qen){z2A%LP9=vC^f zLwQVVtf>Zxj??*=pJ=yx)j;c7cR2p}=w&r#o1r&NApf_pVgRVd{5OcUUfjTS@`Obd zou8r%g=yR#n0wZ$2s275gmQYxMz7;53*1v((qJ3aYi92K@pk*E^p3W}66fk@sbl3G z=BAZBM6&alo5x&v-+BaIcUe#4(-4;H0m+&UKJ3ylsJe9}F?+F0qoj8a+XW!An$OPb zYh~9+iGKw>!EjsPqH&%i^*EwuSHo=7=_N#n0phCJ5Y1txu5=#bg1b^-w*7qcx{Doi zQZ7S1`Hb6rVdbJPMfUDWnMH*Iuu?XqQ0ntBp56PwC%>CY9~vRGg3>Jb-t!tQ6W6UI z=S6507t^jz=@r{@-6*je6*>4!*;GH+E8 zM^Wz<+GTK8inPya!DoUSE1t~7@yo0Dye-Bq2aLwkWB|)h7Y>MKq;scE)Wc(69tcjX z$m@3{1pe)Z|1Mf_>wpA-<77Ri#E28a)J+G+3CFNFyV`kbMj11v6y%dajWNXxB6dhK z9V@7p_!MLe(1K3j8OR0CN7<RKnh@+E6`o5 z-yfOo!mqs%Sv*z@i?IT!XsUh(^3dRaspc-seVU6b z3!Q1chCR!I7QxZzfZ6Aizf$hPz2}N=Z{CrZ5bs zQz@b)8ZON#W_$vgwuIAtjy~zb>LQ{kc-JsZp~TsL9v z_o%OcEco~iG0F*^aCnVH88fK{bm7$^hg74og=Ot3&`oY@hK zV4KQ#4QI>uGJGOC0yB21MWi154yGN_tMXrlZ1T@}Y6cCj^E1xis~4cgNMdM|glVal ztP;3?l2vMG&P3|=j@Y`YI#7#q5+dI2?!T$iYL<-z(QVD`UV3|ADrRxf*4KuAYv5^G z!$Z|zwYD_WU?I({K>1aI7X;MQ_coFu1{8kUe4S0Y-Q%AeKA%?xioDO0Uw6%H)v$sB zjK9YeZq_I8y^opha6_;=piK2j8<{Zd<~{h}$2dQj!fu{@s__)`4^DQ*Bm#2lx3Fez zX>Ojs5SiSdE|f6o<$)LZL1Eg}sE=O4Rw%I7|G9ry<6`7xRN$zE>#qnnFO#=ot>TQ{ zT30?;X4>YLN$xxrN;%tzF96XRb?+!2McD+4}FG z`d>h1-|)I+$aEHyK{RgbY>6B0)rJlKBZjFn63`cN)alYGo{`uzyFQVF;&70#yn5); z2XL70!C^i+KHS-R>upmlkCYrVtY3E2qUf{g9XBH6JE6%TG_Pu=2{%|iiFlANv z#$KjayI9OluPbZMk7Cl@+YTd$xOFyByG-^`=a1XpcQ!ihjv@D~{ryuzUIQ$d&1xRWkfiZK!=A#qpTga2 zuIN!ZM%6ezZJVRZBH||VSo6O8(K6Sg@?=9AyeoG}%?C+3s{LAbf0zdC-)E!Dydi$A zE7_{drIvkNC0`c(!SdlKJ-rMZx0E&ja5tx;Pn6)ZI#!3e_3iLEOQWlEGtGmG&^A;W z4lRrb&w(Gt`y#TM{Kdf*%SGd>Tn1kXO>Xb*_l{MA94c2^yQxd)nTtZJt=SLj#YOaW zXT{Ek!D%F`?-IzyZ^S`!jKmCr{U?20a6RU)}vZ${qe@* z&hy8QpS7R2Habt*-#>f${hImSd|Ov+w9r7uqu&Y1caVB}{qf_@Q^VmOx1K$F_WbFF z;nyMY>O5-|+;21n+Vsfb156?CaDAJlDAqkPX6PL4M{;r#d+r-&(=-C=wB=rjQvV$j8l)Qw9b;D*oKaFpAXy4! z1-FTKm_pmYf#rAfamErQ_k{W8I6I7oC5-=Otp>vHBO_U^w@PjdL;pD2O3urxVy#C& zK;Ili{@89>UkzZDzEtY?WpXn?KG(G9?uiI`zcx)3OqN=R6g0%z-!?M^oKbvN@Sv|+ zmcf+>L1lc;0^qdnhNXp73J_QfR^z@vHsBr0t71bXOz-Av1UA~{H?^zMAm3Xyb8#

Cf5U!g;6LqPTU@mlY>h_c4(a^ocL?@=iMHB)TkWd0 z+JAXBUKP7javPQI*~VSBF09ly*}g5eeJ5$HUj3|`r2noLWh-z{yjo&h#G}zAGqlQ= zzVelAzBmVfJgjqO6mbwufqySc#;D|K#IpZ(e!P?nT71H*C-5tfyncw9?dU~x^P2v6 z*tXya-c!e4$%FpkW`FN^XSZKBOZaVmtZzil4jIZs2>cifG3F0&TmP+b5P-RZppvJT z=_sDAlh*)hps=>%__cPO+yp{eUe2U(348!NyVLPGk-;Can?V$~&KD+4nKz-Bn+}{G zDTHJNZL_5iqp%^@64fo0xrNVT&>GlXMd1X_kEmKJNE7jrG{ z6-HyG>o-P<*u$-3SRL#&2z)m4>YY_fo71tX?#7VT6n(q%;l8N2N#YrT_gykEKYVv!hH2#J{|b(znZu;X~yt^u!O+956O(s z9}Id-EwkNUQHqCu#4y2je7wA6S5gSg5p<}c>j!H!GtBxU;AL)YZoR4kXzL_Jmo|q^ ztr|yVv2aqeg5JifwL29}0bGgP!2&_W4)dGOpF`F$Q@#l)hE!W;fU8cZ+?10or{IY~ z`Wn-ZEwk4cz#F*)cpfH0k1Lp(%%>!?pEKbUGOr*HJ2T6r1_!rNPa^o>o&#-0?Kl6< z2dc`S#G8mGt-2!j*eB;oqV!pmCKOfj29YK4<{H<&RVNH{ya@6BroCp4LrnB&E2raN zUm1ZZg9BxQRr2C>NpLKX4JC<(?h|jzJ*gbq08~J$zc9@Q#j%0WyL3ouE*Oh}yp3Gz zv}^lJC7Fv#GO1;`L5u6ds_q^Ncjqq$W%4f^xs-^wpqcUeuxa)L0G{RvagZ7ri zEXs+UTDyrkPF5mb3lBc^<=2I~IP&x8xb0Zl1pm~+HcSh@>>U5NvlqQR+<$)%)%Fj! z%){r+ZxPr-T;*fR&jcJG|72c>H_)F;;N*A@p_j^F#zL>|0T&lK7^jwJ<`S4pvgwSH zhq;uH%&dkMa75}gxBRCMcGElwkNU?ay|-@<`)_;4{UgpfxvnO5FO%ihxgXj2GPU_p zZJzpdj`roKXonio>1&~f2@Rr}#L(|zdm%on;n&gk5{eTlhFXe~~lFinw2 z6X&-OO2>W%i?G{@v{0fJERKw?)iBQi5~D#w+3GxQww^UN+Tl?&BJA8eVx2VW{C6SV z36=K5c=AM|2y(bAK1wG}71jr)sWq&KC9`zw!Hkf;Km?lHoC+m2a0~(zrJL8VfWb#7 zB-l5UGDLW|c|KkPCgt(P+?(0ye2ht1%^BOT?TxbYy}Bn;URaynfGdz7W#4UZP)DTwN#LPA9#pJ`X1Zldi?tb zIuvDaPp+K$)#5U%Z$T+L2V`c9F0D#7M{q@mE`hzlX)x_mo;auu=u8^8G?_KXos!oqUH2h*fy%fe+5n-7K1GMLY+9&+FYT|0>Su>~ws8-iYo` z8?InoId;}+^VhGRbn2MR_YAx~;op}!4$U8?d5G}+snn#X5{(ciCeJIzc4XuW3Y_Jk z#SNKy3d)Niu=`Z?Eq>i?66O2%qZl0~T5Z*}Bl9>i^6(_8ah5HRypYcVC@<~1y5ZD> zQ-FtLEO>Y+IZ@G#_X#-!wn@tfS;+Cai5Wo8$~I@wX&>}c1eFJ3f_ zfR8J!jo}ftx@#BHbir_9!yB*5`zs9eG~pW--P`c=>8r(wKXj^q0+y0z1MqQpUUDbo zosEJkd2-J?L5nyOCo($PAXA4#hjeyhf*3Y`)TOggGinQu!tWQ75fmXP z`MS#;)9LTt8GZyU;5QGkT>Vjpy`I?4M#&4}-=VNV^}2cWNg;a4n33W`0kd#1(l@Vl zX&xCCZhD2K2(K8F@I7hJxrsJs-R)_08mTMl_`OZW2o~?u>~tNwdsv$>U67X)y(EPs zoK1IfwemMJ7w(kshs`Rie)nBotD{k;Mvqm)iXMFTK!thKabE-3`6*MDO*u^_qj+G} z`IJKG#)ccMIDh79TQd!Y0F4R;*U2V8nR{X5+c>aBw7$MhNP6_~yZjs{)BTCN;VM2E zLCjD*!I%m2Cqin~;t3=WMpDSFvA#BZUQW#LW@k0qUQD=Th611m@n6^u1O#C9A8d77 z8$P!#&43LHw&guDH#Hbqy$(jv5_>A8q@mGc8#Ym~hrfX2%RlafNitReyn0oqR-Be8 zW*P21gH3@J!FS;0!=Q8p%Tq?s5S9SA_ZXG3mZPA-mh|M9lYj{uEAvjVew%F- zCles~J@O2>QG4S>q!hUFCIX{roEMe065)!{5hP!E61W8#@&|O}z(OSgiiG~P@J#^v zf?x?SA+#6@fX*6aqr~FtVR2Cwz_+17PXMpigbZu|@H1)RV=C2|ASG@#H(iS0MNOl} z0LAE(Zdau8NHf>V8xZ(_1ux_KNPGQ$r~U&QR$st?h(F?@F7Mo9r+uOK%_HicWBN60 zrpz6}{{r112v8hR2TWV&&A`9EHr>WA9b%2xn1#RRfHP5Re1Hk zTW_DOR>hP@Hk}R)+B$TG&a4vW*W-5$>-Z@im`^NkZUlyOM{*H_3XQoWamz$UFuvrr z?K_dI`8L0)OpOugezgqj6x2^HVosjhY8s7k&&`_fUlCwMmr zo1uIYwj85dDIm>)u+20Y@E@1d;+yRXyC*z94)@9i&DN@%4CUWV)4g*(2BiwBzn~tS z_1}Od8f0;L%1>aaQxO)e0)kr+6fALAULRc@EcvT1ON%|pDMN(xp4t@r{w}LoLC1-$PB6e;`>5A zCz#Vuj*ZX@xr~XpFU`gB38&oA0T9t!=qn5-L&|A^yf+e0F)Uok%h1f@CkG*dxiVi7 zn4G-W?3xGy+=WfSI0g z(Ul&B;gbo=!O7PC`!~CNcG3P9@88*M)~)?oe`)@|YsA2p=Ks6qvzIEYY&t8m zbI9YXC%WVp&Ze=V{0{@S2eF5n$JjJR(>!{nId_DA0)bjxEDtMk@6EJ9QoJ4*q(zxW z$tf|5V#?nLxyk_Le>{N4pAeU_9bMLgvOu^PHqNS)GXgZF-w5*Kid8-qpmEDLK*tV# zw*)R9jjii!x;rBn&OU@Oy6gyM8|}_Mpwbu=Vl;8ngY+t!Ik5NiZBQ8iN2Z+Pz)*P0 z6v%mKT0z89a_(l?B;thafjShbS=gNk65%(_qZRc^8Nb$e>~KcRP9LiiulFZ>-Jq}Q ziVuy^319IsGZf%lq)mYHJ|TVNaLb(iQ`9%pJtQvdAfy^ zKr@$CFE|8U1Tq4#%DTXa4>9JQ$T6uED3wTmQN>Uy6YQa^Wc3frs~;-$4fbliRq^nj zd1_gh9R}X{e+7RJ;-=&^+#2AnC3Hx?i6M%Xu225i*3iPUVCCNNq{QB{Ib%dlO<8Ew9;hMj26n1 zO74>oJ94yu^r%KSfp?LS(X@WeY`@J>0y5SFU(nXT3q(w}z_<^l)A5jS(9G|rJ2_(c ziaDx^|8N%;DL{o(HNP>>n;B*d>Mj*g%v!ZJiXB^NJ}^5i`GJkpR-kH|);o%cLD=7w z{vb8|yTYKPJF}uzm9od~^SI)3Z%vTsd=7`-74`tN;LJg7l`_l{avT5Cdtu+jWgcKS0AT%zqx*v>F&{ z=o2;{cI<~8_aSt_6n_}it~$-Dc73gu-Zay;_XsNwwxi{|x~Xe6W%s@hidlG?FM62! zkGcXsD&`R6Ma728PZRbgICj*3N_SU6tpZPaF*OQS<0v%qh#30pBsz;P(-FP{o%atF zepDH$=;GV(T~HDThly_y(XBi}ZrjuafaQ91h$9a31pMV;Dr!fYKlb1CtgkuS;s5Js ze~dW}My4?hKe0_9rqY zHyfnrK7-ao>PCToN;kh<%;ndll=3W$Tc=>4d#M_Mgn?_5Bf|WCGXq?^wF&-%FDK8^=5SZ~%Q`0q>qgyOw&#ujJ-WA;iQp*}og zYeZBe2_o9{%Hd~zIm?#uI}7<}9u-4Z8Nb_xo0p178)hB@-0yL6EeOp#Qd4FT{P->C z=3yV|94?kJT5ejp(V<3@XIx{TzA@DJ7@bsCG8AsE*s4d&j%>7&fr0 z9xRKYQkrmvTOQ9xBh%_*Tc8~c}A7wXHZ2%RO{Ajl=7h=3HHUm%e>*v_ksXa2obc30xY z-%Vo3f#D8;hJjg#jsGtgLZ=KJpRnkIn*uKYl~z6A`*Lp-a-~;Y2WOLE0-;p3o5rWc z=X$|qbK_2Res)MWYCozqiCpx*Eq9f;L`S>!vNiXM@M9Y=2zF!tA zm}2EF;Bm?k5#p`P?jnM?I@zMW7rXslGH;7!16_sT#yUr*RwKWg9WgO|IAh1((t^rG zWkH+dS?x!LBT6qqF`NAwPsvBZj5-_6sQ>`V4|Azo0B{~hy@MSI>CNYKX;LWHWj4fK z(-KbUnFenVNDcr_(4Kob#hMf^R$ljScd^RML>e>XMjkI_xrT zBaNLU+-Jo9}@sf242K2HH2@ai@4|?h7`Bx1j)!jmQ$P# zESZO_4vbQ4LW)m9cT|3`1DKlkX2R?Lb{6TH`rpkWWsg>~Nb?T7>$`&=3zToE@V5B* zEH8X!X7Z({vcXIoE)fUG?zZ7G^URzWI${77zetez{g3)n&iJ+Byx?B>rXwb#h=b@f zthIdIGL#~&O6B2$=IhV$PJ$ua@%4ku*HjDjLojfydVv|JFXr@Gc(q#-I@-V%8qs|q z3Tj6D>^@Ev{A=ciUShOZC65xN;NmhWNnq+fx}5BKR^!r!ZBGYXWZ6^k%UWE#LENj` zy7}$~|2WT=tY?<4``zEoFSuAg=p}k#&HT3!G4CoOV&`Uw4x8EJN-(kN6-Rs0!5!*N z4^Fe&7^FjAeulJn+>{a8N6C1jRr_3bdN8(`eMbE5MeiNIchoWUOu4lod6STRtONEj zN~P%xWQEaisvP$asxqmhDvzd^G5qASW@CM<7F|+}b9wvdAAC1_@!dZktTsM2!W)ZE z!ACDSuCt@twgjHzx)?@#VFlqhukF0F%=N*&LCgZ@lVyFZ z4c~z!B&(%siW=awN~Z}ii5N^fn7WpHlPKEpG9C&BR$z1S7g7$ zo`S3h?GhQF4RM1_G+~jqi=Fyd9d`R;nwwSnBIloQ@D+i4?~CI_V!BZyq1+BD*}? z>+Nc!Ki0OJ19C4=m%rbGil90nZw&YgYt}HdH_1=N*%G`N{dubl2#K;B2!8!EK;NtpOFFDHU>X!k5Xw7pyYVXg4u*M z=Jh*dOo71u5$0kz+JC>d)&CVcDr;BEA+jL33A;(D(fCW)AM}mwTxmkl-TmIyN&na5 zzIn!C4xK1EvJLrQJ`JxO_^xjRefz`Hxv+L;QSAl2+}wY6u(R9WKLElfTRXkCN7&ew zn-j9!Fk}cJe}KJr*swkJzJsr5j=0~qkUCFhji{WI`N~o%Pkvd_eTfO7y+!+PJ_huj zk=tDU-g963+1?;O(e7_N3{4MQnr38wdmCU|B$HF2QC^Mg z>@0^R2pbK)ZuuMO>n()-f%DCR{z1@IxL_-LL`Jh|dg+~6BtmrHJ9lK=X%2DC2 zBYnR=7i?qFWH;=cq6|>w>%i()Ra?!Z(#_ibR0~(=`MIY zOV=J?PImvO+3iJNE;wpb;N)6u`sQQ5_H`a^PA#>WZDt;Ss(D}Z9AvQ(ngGeFCAEKc zyCxnFGyl@JiJ$4aV$Z|cr=#pti_yCF8}nVoxS`Xj&)#^>4GsFT*mmLNz~+;N*K_`` zz@Q4X3BvUxg@a>j(}(G>k|A*AQFh)4dfr0SH0OY-7`Ne`g1^R~8VoTAFMXW1+sop>~C zZST9XaWm?NH*fZY@|V@u8KiUeHo2a2`LcSqAO=aET~UQ5j?A>@$qy%KjAkwvLyPb^ra|ak-#hGXLD2_P6LxwCHuA+C*Hw z6S)!XDZ!67@l(GG>I>Jh`jDSQ>XSta;J4oS54TQ-1)>ld`kei{S})h}IM?mMYZQ@V ze3ep!n^j}uxbA5e_lD=9-U!0k3Y&FjZ*PC|{r>wS`*!Q^ZsV3|7pKknsyo$L>!$NR zs9)%5f&1xy)_fs~4(;=s_J6)#OGXa>JX{DdJGPeP={|k z_|Wua?`Y?E2a=AON`5n-9i?VeX7c4)DxtISHFW+4w%*%%wP#-GMRK?IqOzWQdlp&4 z`@Ns`_J7&4`rl)*LMZw0<2bwa^mt7ro8p%h){a|~T0@O@P8dwmQBjP=bi4Gi${8)! zj9=TAOYTw|Q}GrAaLU}Cty4+w5>k1 zX%8!Ehq{kD)V|C@)eY1>b006P9S^clV+J`B-KPu39p?qbJ=AueF0MU`%WAt%Z>`-a z%$oXi;kb*#hPKtG3)?OZ8)~ah7uGHg8;^OsTy4|Gi{h-QPjBmaNp1D%Z9Olktv(HE z---Lh#gXw=yl9jW4{8@j##?cz+QpIaRxGcrIIo)9e@*-$>LJ~m1pDf5<94XQ=UwDP5U)92+aHloZIy0;G;-@D~v=W`Qy+~1TY2B z1!A8h=nFq+x%0@q$}Jr)-$f)MZ^U9<@MWAEt4lcWFRd$4k>$tsj+LW$_R zR%ZwSk*Nz!1hBcTguw;QcIyc16HUzjAcTERj%&&X6tSG5qO8)!rqg&;&J{g1JD zh7!(%gS-h+l1flG^k{t$t=;kGQGwnYvk%9V>Fn%d^68E=ACX7siufYVXBXKtf~V{# zPA|ddZ}Mr1DJ0PC5ObA)Mm_>79i<3Eg)OHwiK9_+4ncvCIs+z*(+9>8fSv(LnF1So z7k`RAW%Fp5Mdw*Y=px_)nOvo#^`Hy{7{JzoL?L5F$O?M0l9bDTi(h-CC@_N_v+_;`o| zN(}do%%TDb&J_jU+Wb(Q6KIx5!dF<%=x>z265yNh6zz;>>ldpMja4**?jQDd-tL|J z)c>vY`{To%w{QE0;yY}3M>3sqmXe)IRAkMPX!|Gh=xtX1@ValiQRST02(mJnArZ*^ zbq3K4SFo}#z*)()l}cNW_L9}yB^kiq+ydaHW!Kkd$4AH4h_#>r! zv_l(xT91A-FB;gg3?CX#Akz#v=EgJAsmUzojd6)tUdTmT^^!sG&e9u+3RAtIuAt=( zsT0NMEKWx*hntMZ)uYQs!xM6fAxedlSkyZQ>j0D_sTn5eIfZ-%1g@}-97yV5?q%HV zVAMglKt!76`IV}AjNoiOG2CIe9`#*uwQQKjG#SjfBb@EgoIzkvdZmI1QGGH;Ys#ag zR*=wwhNu++O+pB5%xVVHWE-(*yY!?KS{^2< zW^1xNFWZ(4x>{1aM1HT5j9Q+7w+?Gw|#AB%vOK5f7~x!$gQtj$nvQvSx5`W=q4wZU=>GWm_P{0P|uKR z4fg@2MkabXVNb)OQZkL}YOG(m56XA#UG{+*pQ2K_7ix5@t@}TX=1woIwfoAdrSg!Qjkn=_}r!x%ljilI0Du(fo2OIoK#^ z8PT99Yg44gnT`a{kt14$5S_${8125b2{nP=pzO5;|4upmo8e5HJqr?8eZf_GNe0*jE zF_aF?e49COu~OqarL^N_W6-9ceZ!I%^93|mHm0qGh+pz9EL#`0*S$URrJ)Fav~PGv4d9$ z=e0KLqq3vJy5U^cj1)C9Z~1dd%Cw_0ic$AnMr@JedC2~*a$8EjQFvo1X~J#N3OR4x zLY$A2fqBydBsru&of8ALqjZ=MAV+zEwwg5yh_S!5{{kLNl838@?K4 zYf2BK<0buDku+zrhy*@NSyp6tg#F!}&-DI4{)pl$-|D$<2#o zfL(-6;vd+_^2b#;!k(zwu`*6JZyhAEzbC6>e&b^n4@xO*;T4PhXh!r0-KeI08{#b) zaG@@4>P?PO-^|8W;QB+SYw_6oH!*B@x9B2vxHxm(ewMfCr1hJJec&5t<%ni&0C+!* z1PbEdaOYj`@VCfZEsY2eL%0$XG{yE!o#^M@?)&~xjT`_r*4tQ+%8Dr?s@>FIh{)Q3 z|6qiYKor#rr60DXe0!PF9Vv}i;8YrZEh)MoMNLnIFhIoB)oS#rv}?Zn3)4&mh=+Kx zxMTG(a_SKzgEmiNNcwESgUrqGesAaR?~!w>>DG4{5PA#BX=-$GK%#!hBcrg@RnI4| z_wY7WZ!Ofh#Qe&dkJEq7Z8}u%S)m50lAD_A6wdJ3d_?}yTFbdEiVj6V;3X`g`UQDw5o@3 zndYcFUFFnr04+g=4YSr6-at7i)C?cm-+#x&2#=>x+Kx;I5TW|b*Td81>q}%~+c6p) z0c?!9-FgY;4kjfK32PUb-wvE50Lw#?2tSRE^MxNsf{H~1O%DWMOgsl~7S5nICdYcS39ysWrKI%KL+q-o+EgV%42thlZXN+%LSGD-v}BMf5_aEIX7yJdNc_cb%dx zRZ*!XL-j13F;T&OHebVEFGD(eWtXAi1W1da)L^uhT5PEO-ukfqnW+LTKw3AH+@(-p zDeN83$+$4((3Fk_Trczlf|Z6NgGiVpCs>fNoKy2yrxTpG`}cVYy8?GE-{0dY`SVYi zok9^hCMrJ<12>^R1sq=|!_+(>sIJ)^#Ph)e3$xa&AZU}h@hyKUc|{-t#LdWui?s3? zMDPRKW+{%4qs%do)z$V|QbXegNKogu;xMC>+(a^MsVo-NoMQ$UhInWVD^d}$d=hik zX%r%`BP2@HELVdq7_OJ}y3R?2_PqI2{jhg8iw0pk7QzZsZQ(lVoYBXm8S$q4;3rBM z^U0!yDYUT!bH=>D`Ysu>NEqx+QxMRVbZ+l7(=4YCq`T44iXxHvM7o=%m!N)wc@I|~ zFJxPl?p;SOmVOMA!6;^>EqB-Jg6g`LE*haTsqNcKw57Ht0%gsN2IyQ5HI~w`5VP-oyU0!sfL!ml+%rs0ZGxOUouuZ*84CWlj z)6hPp>C&np15i7Gl9OMs&68ZuNVsBJ^s10|E^sC>1SB`sFcm%wJQcJfWS<87@Foe2 z)pgK4?65hQ<7B!X*#Ig=Dm68_K7u7NY22HfG)Gm|c)Fi&B-%qDW{ILXm(}(f&mjG_bMauxW11+2Kr{Amzzu|?;MI$5m zhp%&gMKmH&JcM8u+p^6ux{qd0r5Gw z0Kp@EGUc?4L^coTJ+kTqw}^Bt2J2;YFzz9VzF>~jtxIl2AE%mA+{>plAJ21gJ$PfD za_C8p!kL991zVuc79dd(FO&1irY!)U)$aSZE6k#gHcYp*rBN@VXKv~@J9~zUg%!h_ zoVFkc_9ILJXld2$!s&J3y#brI*h{(jb(?S={($rF2cL&Og7Z+`EycwCpm#?@+OBs) zjAJ1pS9t|D{G)^$!cV{j;pa;Q!-Q7;;JdqC#XfoW2gT?cb#2qeaXUi^LxL2456dbU z;+~aiQmlO}W|}ZV6K1G?m!Gp3G&%92p8pbI&fLM#ns9B z1~m=Y0jdC2X#lHY$&C;cm)|F2VyIY-M!qUzWXBlMi#cyz(zDa#g&kxQtYNjz_H1ao zWV+UirRa=RsZECRrwQ6z_2S^%71yWW%BI=@N`rW;bjf4N3PM?7LKkq)ZjzQ#S~IWG zH8zHe3t3@gPDQ;hhVAH2c)p=YEi%88J=Hm$M@yP@mo)uG))GnF#`+6^VoH0wt)?Ze zMB;+7s+{}Crdy!qyH+ksP4~_EB^UcPEV{qn(lt#i=-M*Gj?v#&IeVb5y%XfccarmU zv(PxpCKlft!cBlujlzQJ@C;wwS#Pi60bJcOzZDZeeca8mk8{2*t5voIMXlBBrCXQhUI&gDNNuaC)beCq3S&A$z=a)}mKscw~W)2~*cWeqIBuKjWyaG?2B3l``^^`K29 z(99xNC}|b~H465u+!356=UZl;{9g2iLl8RA?m&R?Nry@ z^a(uqqO~h0Jibk4@EPCN^_Q9k7Upm&xewgPHs@0o4dI?2!w{P0UN7{-l*_@XiWA*s zAkQl@`zrMYH2BUi(%twp8R;$=GJni3CmaxWrnd#LZhAo|GCwEN^z2jbG@IhW)~-md zsoi7gCCw!yhvl97_oI6?ZM8Y`10J#X_D^|Tm6zg^<7|QnTuZ)7^LOUyk^V9@J*!7Q zMEm^{>{avvex==^b=0`&;2wjBKjk7xcRsyxoeMDEZBuf`KMU4?TKQK1yj^~&%ArKyHhdesUt z(ZR+uoMwO0G5amrKRDU`xO4V@aPKG4uipjAf-n#aC-;<)`Zc(M6o zW-k~^>pC^pBKkeZCa?p=cuumOq%(1V1wF1!31bf2z|+`P?en8eGY0nrzT=^4eW*Wd zKePe}ZwHr6*sXN8vIlBfxqidu5-Z^p-Z?7ldp!M%AJZaJ}K}g|WLxDjtWT;Z0`{m~IWHWI|M1^p>7^M;zFWS-@^rFBn|W z$itPnv20&#@T&Cx*>HlTVSj3I%lKe{*d_wH9y|eZEKuz2AEWoCGm!av(>yrGxbZ}< zgCbXho(Lr8n~p)L!z3Pt`I-wO*vn>p@Px{RPHTxVC}MB3Sq7xst>u0FUq(Fp(eM!{ zqQ_0KvcN_S*=Faqs_uw{B@d10VV*udI}Oj6XU(Yalvsve!(!Pc#-zQvWqxHLWO_;4 zIvWFUtXZgw!x@-NL&(_Zws6?c^^#9Ax3(XeBx1Khu(3|&b6>;1cfoo#$S&Nz#14#`=s z!F>=(fm}-Zt}}iyFr{1j6V*^rVkVfJbV;9xP>QGmbfhpC*>j%t$<^(&d>x<0)`4;O zH>uBV0M7=_zm;y6I8ySs#Xf(HR2?3a;Kv=QmtmW%sp&@LMfmH7w{(hp363fFcyV7! zehOwv&l+W2tHM&R#rY~MDbsSV3teKjk*HweDiG}Y<$Vhf`vnDF_sS0ny$mUw520Lg z>o``Z0I9XOq%d zL350%xCKdjEH>9Lxsm!uv#B=s;00!H&5ACV3tpbcq|Im9MoCryiNz9%mJYnjyNp<1 zcMD(UcT)vb>Vc}1K;}E=-^NMp(RBR6b5R@@LYinx<2#5hsVKRL2g)-IcrNKK_%+2h ztGSQzgtLW;hD3*++Q?NQWbZUDj_bleKJ zj;Gt;e!h!I4e2xh?ig3=jW#8AxI}S;J#hLKMdXmQail+0{2*+nErQ}GlZOSSz7>P( zA=zNfChXr#rV37IBRR*>4F!rgyvOPgxDO!p~Q5OBqEj+xXwsaV&~!OkY@Ip zeWOejQiQ^i{mw)Au)eVJ-audO#HT7b5NQg54mivX$W8^kaKTZg z`L6lfv*8^?4SO|Cl$yABc1w>g_0~H>&g7O`xOc9LcPaOs{ZVu%OySf@h=w1i5i04|+Ip42{-Bj?B5l@v#U{zn_M`ZCK=r2Nu8`|4^krR_un6Lo~ zapBz6zz7TsA?0~0d9WCI{N&$k=Ky_?n&iw>?RA9rk}aUzjY40e0~;V>?U)nT48y3| zrjb%*5-fo-;d3#t8v;|Aqr>5RDlTyQCk+_K*16$n9sGzMGHGj_1VLEnuAnpWCz5Gn zhK=*+>h)rPxVrKq@$O^s0oOB{58^Rly3EfnM9%O{nJ!Mg0{6<>Pfi&n9#R;%ry!0j z_7&+?paOeEDZPsdi(w27@s9eR;MG*+hxBz`O;tWpU+2|S<%slEUQJalQvZ{@nmX32 zsZ-|FbYyloYB$U#{i;Azyo-*egIx##SeuyN%4;15wtsUv09FeWpK=kFJ31Ap6r)1R zU7fs&JAt>;0Q3!l_^Mg_vSF{sLA_BrM$lxK0mM3R;&rJjlt;`tMS;28T;OHCPzxQQ z!W9yCNRU|IH4eyE=mX-rK$Uig%;T4^LwyCk+Q`-^O5}=4k=~Kq@?mY2^s~VAsoLR* zB^eB=Dhs@YH_VUy!+tav5vXW}+l^p$kphUwo4k*6^@r-Se2o}K&d0{5jKr`XVDEuG z!M`Q`Qks~VJAvGXn!o<~Ypt%PMEpxiM&>&&C|{H%9l_v{rS-k=j`;J>Nb8qLNgG7n zhDB`>kODi<9wyjQupz;Yp&UHAl< zCJ^Kz8Z?s3RNxEbzJeH4af^zgSI+9ver>w@3ePqF+1uOF1v-8K^QU>&D{3s?hoLUG zp(aBR5M@j@RH3vPl$iPCAJT{M*3;(S{atfT4~h#xs2 z+n`Sn(b7Els9R??MFyHW%T;4rUBD%2Yn$rk-kG}%NijEv8(G#*Y-0cQ0F zczrvM3a7fzp}3|Q8{hLH1SnAPJ;EYHsl%i`d&YkbVyOyYqNy)`?e1)ms>8lr|LMvd zU_lv|Dct{igC?LM%gMFm4$}IS@z6~Peh;dZe|ijNrwBn*VoLXMcqu+)Xv!zk%X~$w z=uptV?GS8h3ecu(*fqZZ<{g|3dV;X z^1tjH|G5ADI6B<_WoOIQ+Zk)k?-^z*gb&te%GcNcNn~nqU>mb^89+O}|BB+Ol*Ra4||Jq){%n0|AjOd;M~jrE<%&DlUD~>?Ph!!`4IQ7>q1!6wd zJ`sgL7k78@d(t7uJ5ia0xT7#GsE~&}paI&b3Kr2Zt`S2Tvx%p!gF7#!fzrbqZbgce zwF4(sD5Kw2!JDFab1&e;aen(41`VD?#+DnWOl541?T*Vzh)sVwRR(5yKe|=MF=IL_ zx6r6)k>zgb|M|A`uQot)52-7m%?(>AG zEzS6|$RlOJ*|=xleZ}|;@iyI`9%Pdp(+Jwhr2?Oa3fqC;lgFsYF+CGV3seQs(=U%| zZ1=(EJ8Ekom>3~qjU*-hz(u&b*x2!_nbP=7wht?y!Ub=>2Hh=uDYurS_EWpo z%Byw~&_#|h1k@@xgjEvr(8|Ri(OkM#H*9WhmMK{e&I6ezXhsU8R~X+6_BlX^%mADI zlu*LP2_;;!y)AYOEn1(-Yl;!ebzbLyGW`8x48dPUPzGEOQ*xAz&vD0OVcM){c=|56 zEYW#$kC@3Q#ic3Uu>D<|P-rGFL18xh9b~QtT{rxLX%-=e$O&)^kM;5;Xqg$3$6B!B z(}B;ZJ-+7^bsW$uTuocP_3IoZ0O4HG8~pCp4pC>uemRDPkTM~kg^PeO=q5aWzke`K zj==>gCN_IVo4u{R4^<8uOC!t>b|FH(%u~!v2_XU; z2=lTNja$RPutT4@vzyS;I#Hf$z`;L7$Wee*&6syH@Xi_8S&QX@22#J zb$iNZrz0rvl677mIVmV{1@qpmQS#51(MR(?^(EXhwU2e#jE>b`>uwj%UpkqofFe}Mc><~E_3b2K3{G~09`p@v4iaC;Ou zp$NrnHjh2OGvVg;R@FUo0ptSeP0F0}c{~O84&OFGC>%w1ygf*>Fv2vSnRV*4=@KNB zBKk9soNMI|BReQ>mNMveMEwmi?og5rQ~R`}c7Uv+a^LxOdrWXS<7uX!A$TENreiN- zQY83beA(-OWkuRiDNFO{+z%w#pavku2Zfoft9Zol+^cL(-ag!a7ripa`t_=p;*fRU zl4wP)F&cH*E)gaOBVceK@L7TUsAimF5siQlHBBlbEnkU80LOmc&g`~K?}!Zq#$RXE zC3K)rwyE~wBQ{gB4%YW2wJ`P59MHT@sEMU~h)q1eWsg3l6L)-HNRp6`;W=?k(j5zlfZWNb8(`_$-`-DoI zI);r{qfaaeb4o4{E4O{%Rq-oOK9eNRNV3dmJ{iU;OS6hQv6)d=N{cD7&O9eEoP_&= zFzcpK$wgR$U|8jRJs;aloRuvwDF$wDw(AzOjx3Lknx*9>K=X4h!sn-(7vpm@FL{a^ zNjBj$CS_Vlz?2H0bu4BUW-^^7VR8@WhEd2}YA#M|7A1(OWBME*8o#MtiN_=K0}VG)r>~*j_}wQ4)2`~pPwGZoxIN$Mg$32 ztr=2-a|Hy=zpvMqxhec8zGuLu0TD*tTU9+GP~lB^2!L5M4@*x?S>w*#5Ye5v6)pdx-dZ zYQYX#h$U@Db zYY1;!@0wsAv=s+9Q$_;Ro{(<}-^t)kv#w&xOy~BJYd2h=MakGS62G3kA|6nqIB6>N zl25;427@5=C1+4)ga@T=(9hfA_muqsV)xdgeemse8JTehalUEO2P07oRS=`oC)4)j zPFG_F`sECZwwo>kcoM>&+7O zI82MY^0nbfOT1kUDMr(e&Epvr-K!UWvk!nU6~qpv$yJ)oa~FYw>P*ZD>IdP_cB~|{ zMliEnZ$;Y^TNubEAh^V(wbPFFoqMXsr|J4-Prx8X69GZOWT@#do=3K5{`*wwCs;D1oZwJ-qFH?2Iwxka(gD1AoFkQ&;N)JnW$P3*UhJAp z5uldAs>fQFt6Krr_nr7+Eg<0MRcbE}b8b<(D@vg1r!yA~ePveja!l(TvE#EemRmCj zTP4gqUFOPK$mY)mDkQ8y1(uO6RcCGyLX^U?kf3m3ZX4JW_JqUi5HC<39cFnTg^?g@ z`tT#VHf7O0_MlW-m1Jxe?*S3>v?zvLry8-S~Xz_j8zV+g(#%J&xCCNPa9%0e= zJeaCuXM)SYR4il`E?5@nkyx5!FCdrZoRNS6hny3J=d!}FFn($_5VhfP2Dp3Z`x5&O z4>vbAt3EJ^M^lqx`Oqrg#3KS-JH|%998v-SLhkgvG}kquGWbyv)_v8J-T%2Gx04FgDK11iYcvx|Jiqd_>9_V;JyD*R5&lF}2?`O1` zi=Lc2vGaCs|F9qM4-a;iWAd==a)2S1{=$RHg&W|eXL=DL<4yz{DhgWG%fQ0d|X)eZ(fiNU?B$oo47E`s{OnE-~j^aKW;Gyn?!@S!^MPJqx(WIaKYqU+XNPKKLRWJ)_D^1V>*D-UP_&oD!U@=MkbBMp5O`f28VfQSAq5)DI8GAu!^&~s_WGQErNP; z72H%8=o8FK`CrTF0JIASu~YP2HUhNHA3DaH$T*QN~FS zE+}7uGP$UOQ#qTryrl5iM`@w^rW0mGBKfe&sEBAJF-wW0iPQ3(LG?ChC8c4iQYG{Jwm z0xcl3gdcC}CX0ZfMnJ=3=S@P8VfNLfNp*9(6SL`zL$ZI8jNszkYZq__US4 z{bJVX<*!?jkhy@$aSw(8GP{*sFS1-1Am}Wj*%0$!Dwhj#FHA8K#ji0;D-#* zx!RkFTV-LzQ}|exL|#&G*ImY+nlX6buCk}JXBu{OHJQE4obUDv5qHhZpb>L0f=5QQ zy1ysZS)QL&m!QSd8A;RBG7bnKc1VT-M8kxYPhJFrnZfJWo1>ZwbSNNxJwCN~VZf1ld;Gv9N$R0r@6nM~@kO;lFIgPYTm<^(chGW2f zZ}Sm|owFIdF-64pG@w3UrJ1ZmP=mnS7v~%yefF^g=OIuw0!9h%k95p=>i`Rg-0c?3 zU_ABu1oIDG`JT40T9#oRbPqgpHe*9^n1mnm!^rpKTA1Phe!c|UHMlu!y0+#U~S!;@lW)^d@#08RM8Ij;t0pt@jO2RC*C;mPy*a$Wp3&~$a%fkT-P|s9%;EoT@wLC%27i) zeeE3|?3U7AL>)6N4xtAlCS0y=^hjD1#}bz~1xRc@SHLDD(;|_Z9e|NAI^o83h$sq4ZSdAoFO=#x7ePwrKd-c=V}y z4%`h~$~wX+@T{uEXnohkO-a!Tj4n(KPNo3=fN6`-*GBtSx_K!T@}M*vCk&{m@Gc|I zGSK|cdFyDY%&l^1cud9IlsJ1WF*#o$>dF*VsoIyEqea;j{Rj_L5j`GsAPK%pL1U&0 z1*t-rRe4kVW%=or|0+pWYWzUU_hR|r66M@KE$|*ML2Z*7_=AUil7?zGe7nWZp)@M^FmlS5KYk--a7X~i8+#$m@f4_FYd4d^>a zVWbUWC9Jf68Zoon{k0nG%=0I0KZ^vA==JxL()t zsz6HWY*YoaB1o227A2&|$*Q^GNA0A} z3R?i~UcK7Iz8&toecL}o7;$dLv^a_0^xy96i2$qp7YBk%3R;kCG+dv2suX2c$DpirR3pDLC336AANGisG{=n2lnvt~2f?Hj^(P#E7E~wuv-pbse2(;{!vS z$N!W#EMfolt

L%VyQlVhV=d&E!zRv9M`h*oZ8gCZs~2H%DT26IN*DZr%moB6kgS zuQH9pK1FcwZHAa9qJ>Rn1HQLiSf|8q7AKjDsE`3CuDduBYjCQ`7nr<$nw865aeR@{rV3bND-0UZ@ifj?`X(JC6Og3YE;0w515l?ruK-Q8q-ZVtM6PMm%MWK}~3+gLir z;y~pDulb@65Vs65MUC(-=AmAyCi+(9kG9tlY|H#}ao5v0C zjN0vQ9!H10ouhsYl0dBL8L!S?Rh_*`&&arZ!Oe{9$%Kgip3I8P-13*)F1#bPyvM{c z-oeM&N4V1=Zmk>rD_S-8>uMv~h`zj}(|{p-Bl_I1GAL}{FkBY`-LURBxh|~>pI6jn zkMXITZMJ|OzYOAOTqlQ3X&s+P+v{}G;ORLOKmiv zs=A7)dPt*#-|hZ*B+_J;Ux$!dB+p9d*sNcarM!?}%q&wjNKv#Can(^NIJ8%!BU4(6 zTk|XxEzyNiTl>fUqU)R(;47w+fZU&<+f1u|mnyWeOr?5Be=6$O&CwFyJD17jPHCdt zuGyxStjKLPe*%Zw8&Mrsp4VF48p_T47?D#ThF{+*VsY_OJ5dc+)%;)`$m0aBB(pu* z(asSB`qS@{y9xf~0(+{!o^?Xh5e`;(S8APG)3B7S-R=A0t9HiM?Tv5PEA(Rf`d)d} zbix{zHx}%{ahS43Et?XfJ^4K@dYJ$#=SBAPgf?r`weL@-o(4j~Q~6Cu9{5J=pmchd zom{0*v_MI!`$x%a>ufahyB{Dr74MGdp_3Ii)cQc>KP%>w6R|RrBb0{}7t=D`L;J^MswYf0dTwHK6IDMb@!^*nGW8>5H>c zocnO|U}^)ww}s-`OQWiP1q$94p*V$BfzV1N$*&>k$jJjJNC**l3}Y!w2X(Ee1a-jw z%Sb9=CGRfteQ9s=*TS#qb-Tcac+3SHNZBYEZ?tNk*?-4AaLSYh+UYrrDR2ql;xuodYRV^G9E7t;m>2!mGY8-99T3eD(Bv);S$Txz$o%;_#sC8Wc8rR7v!62&{)+m1oz4aqA`PhEJ}}ED(cpz!eA(s>CsT^&@}XPM(%U0&VWh9ko&Z}}dWw){Cue4^PdGG` ziw~2tcs{Bg7bynx^vXemSyasSrFWlLo>R_)R5A1A!je_Smjz8@->s1<`oWDOdg12M z1R2{3YCF&Fe?aJI2-P@X#@nhn{PQCu6@+J8HAAx%a8Kf?lBw4F9W zT6eIWE`@~%_%lh4<}PwuR<0Zw2g3i4g)%I_>0@_$K=Z_gHFGM2*H(l`m1?}nz z2gFJAcEQJ;JR89GoFngwnpVou!AR;s{C|!85knvQI%KK4%0AL1<%q6$0aD<6!qS`g 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

G)oLyu$mw$Axpc5Hc-Q(&*~sMbft@UD8(Y7Tf> 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

WP>$QIjyy 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᣽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 z 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�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

{GgQD+i;Kui(bNINyWKxs|Az7M*$Ge#8 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

E-UI-QEl|E4&!E3@$3S{&-r;S4hdNte*s-1Hd2 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�Efd5-J%z z$SLG*C(#%(atE~vyJPYk+T<4#>Ub>2#nl*`On4j7%uBvo`H=^ zB3VZ-+<=xZB;+5OBpi1>N!+PV{WPXWchRdPp^r%YgOpxx2_oKlC8S1qAA)~xlD~lH zFH83CT*##ey`C3?T=5P-U|t{+qIK?NF)BDixlQ(mxtC~JKTw9G@Q`4f5l)cK)xJ*y zK+cYJHgMz@q{{h3k~#StTLw~EVdSRMrEEy?i8IWi8~fLsiByk@LamBgW@kIlYagc` zMzr!q$fmniEqfj&jBxE*x=iHHLFkb>JOC$hT&!|Y2h@f&;pj9a9eN$(SPkaSnyvJR zax*5<+|Yg;#3|XFwVb+YRf}gsMQMKwp1=jqd7or?q%4BSq<(i zJk^RAD&RGwyJ#08?Q)YaqI}x;+V6CD4<{(41(3`=w6xY3h=6E>jr7DSVcXZ;xj0cX)NGcDbT9&sJ=vlE9U<#=r3DU=`!Tn%xq; zj?sQW-YV2)V?iY>Zo#+*!DL+9(!ayi2MudbuChz@Dt)txT21)$OTE!~t-p8f#R1L8e!|-okJics0^=M7el(`|Qzd zmP$I*_pq!`0cEd?(e0va*Awx~2XGC)e4FQ56&}sNzd9YFN9W5Xla0(@i=E};P?!ch zw$yoV_Rx;D!D-o1KtVWcwrWdxZIZVy^nW)AvDXxL7$#B-U(0PJ70p{`i){czF1EIoZ z@~Nt#QPs{M%;bM~z5hSv^%A34CW41IZ1QD)+Lqv7;p_($r#qoJyBqM1O-?2hOW-G< zwt{(#IlSexUBOygKF9%5zUG)^#G*lC!5P{Jh)@xl96%!3a0L};Hp^Ll=-jj9h-y7UFdJroQYT!bxH>_*r!$ zZm>64bZwkb^_foSclOP&yJ`WnPn;X67N^A_(W~{$Oo;Wlb0XQQI|bke<<1$MRX>%d z+52zm533G!;~hv=%tf|N(xGUean(>I#IenQ6!0-@3`U6E717@s^FofLsu;C%{+y5K z?H;J3=aY_aZ`-mqc6}#*bC7u6ZO&H$Lz5A*K0U9yHq*)`&v;m7|5|vB8uPqNS(!5} zfEPybKnf63p0fP%OQG40NbGczb+I*>u5O7@WN)zKkH z#tHd^TFZu~PGG31kE1269Edt~Hh5aax$Y<%XF=glUJUBJ_{%Tq)6xawtiH&;_nt3L zz2l3x%eOn$^!tHt4QW0TFUXNsBw_LLO~gs2d|I$g;{e#i=q9Lr((gyza+IMRq0c_m zZa39I+7*;TM9Y)PJoyz%;)inQh9pcCiK$pZgh%mr{8{-ufl>W2Zw{k`gC-xQ`{id4 zNhrEUl0HDPHpgG9)5ZSDDa_TLJLl0QSVYdwuIK>B=q(2|5KR)O1KM=!KOx+w}u%L2|7Eivja`K!c^|15~igksf z+?U938!ZSq@9l@SAW!EZ=tc?)B>^?p=iYnXlDiUA%$0g0EP%2i8l?qL8`K ztrJvbK?!$-1EN%=V96@1H%s{y7aR(d=DwP0V46q}fGhb=9Z1zb>8h#$QUTn`G{SrH-!IrIQwQ}t^TH#PR*#Y zEG|b-e%Ppbsi$AU?>dPlQWWI-)yJz(-G=A~5fRi)^d%D5${21B#DYCtyuxmF(CUd> zRKKRQUtua=xA4jJG|89u8hcEAj2=2^FLp)ky85~#K3Qxrg{JgsW%0DfP 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

VTN4zGpE%K_DT3G9Q$ zys)q|X_dzttO66z!dx-bRoA+{uLu4C&J*)poAq5HQ_QYdHY`EINQ$DqFiV9Wd`Tdb zokY=R%)4gwGc^qeA|>PEwWo7&GnL9^YjQ4|%@vij%68AmTuYP+~2Cr$gs2~{?pDkP&e{varOC@l~tMIWHEA)m>iCn%- zdVH_g`sCnc#?~mCY`kLMm3=aH-o<-9X|tfohC@`D*=+a0iZw!|IqEki0!Zg_!mGD` zt7ubyuovwo%vAOgBhZ)KNVX)ZybI1Gh$0J@+sMWQzCUC)lfd+JOFtnQ;rERj{9Wm! zEmh&82_+wH|H+i{sB)7Xy$cMSZ_1VseW8LVJU{Gyh|BjfPdhyhU7<(Mj z^Mey5!H>TjLG!#M>sXLdLr!tqeczf(rukuqdyJR_4KFK=(8wo z@CMLpn-+F$f#!iO1g%Wshp>>Eh-qnaDa^wWfcvo5?0!KR%^IouLxvue(cf51Scd$~ zgGORB?^@Au3m4Zl`L5V5?iazyZ#OSMMw{}W4j2*c7@}5Ti~=Uvs7I@@79rD9M_u18ikg6yiJ7n=gFM*+_z{hkqKlH(egQOQ zCSBww2s?)_u%21GuIj-?YUmXJi>A^z&G){m0t-g|mb3D&{HeZhj4_yzzJLA$e;M8w zyiI8EqL2y9b~Pp2zy}?&<3r%LDyyk;*x=`8d2H}wfsb_>+fX(%_lAF}9I;*~<-38Y z+b|K#bRJJefXc;Kn3n+(U$}LR6~DSY{{dEUBJeCg%_m^B`m!E4{_B{30# z>KJfJOi#Rb9dxn!5<0}5a^=?nbL&>?!=WPllJ`j~5V)tkP+r2UTZS704wLb2kGV8j zW|6eeVxpwjhSV6?51XzGjHYd107L`@A&a+(IRX483mFW@d_wXEq{YCgA;iBS!UqD< z9kPd;2|#qDKF=wD`gzNvzR4zUdU?k`d~2tJt<&R5f(1^6CQnkG zQ#W6PS#kA2l*FS7fuX^cE)1BKrTOIDD~5B&-#=pKpxsAp+#kM0TOYqg5R&zKEj-9O zAG7dW;qhb73|Ei5_#bvyuvDl$D!yu^JuMf%=V`%cvya#`loUR8%e2xrc5mm+jb;yr zr-UyLp8{gncleuA3M4E>)+Lf1z~cqp%Hpo9Eyeag2r~AG6{b!ZyZ;ZQ7M$6~Qw)^n ze6SKn9w)Eq2q_^UdTm@R4y0~KFz6MyAKV}s4dS3_*?uQt#KJ2dL5x`J^V5it?Mqo= zya{~)O#*qjfB$Du7Zj=eSn7h8z6o*3!HsAO*Q}ki9@oQq`da0$DY_EWf2OODKJ}?a ztqUALZrgG1jPh4jOPOG%TYi zD3#Y%c!kNPN^$b;k_}S7u=b5$`tU0Aw>w*Ds8pjRD|!xoR_h^Qf6;b=bxU&ahQ+g= zAktY^%3aNc7)46_mb;}^L6Tf`_ms*6j9MlkQH>$9@)N~5!jDQ#qDcVXfpeA#D)*jb@AI1KFMQ=J`Gg9?PF3xgU3s|Kb$paRx~o?xsi?mE0wv4C7NsxxMZ5~` z;q^Gf^NXo0C)P8;HPjzxXsxb$mfC>Sn9NrFSL*%r_olaKTNZ3evL#_d!f&2sK*Fmv zS0)vpg$dz5YeiG`+fwWU7~d4Db2f012NAV&TI?$Um^925tU+!7ZOz2&zsPo{zWzN( zO2bjCLK*YlXFoGc7Fe2lUtHwR_hvyyCr0u+)2Ginh#|pZ)bGVK7mIEgtC}Xdwqj_l zw_hd>_y$)mziq35&M#7k9BZ~yrkw{geAC$iJ|Sr~D zHvRL`JxPDc-9^|LtJKYEF&)h(=M{F{6VRv2@n{MOtT>(^JJqvkHNeDM@X1}C0lti{ z>3K043`SQ3^)b-!DKy>J>W_or%=|qrC(~-wG!FQmaKB+DV zhS&6Q{z-kjEa%r7=lX*)LJ2XSQGkv8thydYPeID8{iJs1D(e2StcUg!Ko~DyRrbT# z=uI^QcrWwmd{{&1=C=LxEm|9*&qn9v8GLjP+`h#vKHnXw7;tpF-vxm!`kZO~@#)E* zyDPTkAv%n^Sll{lMc=IaiF+&P(PB#+vd~Yao2Fin8*wMng*dN&-2K^|(bGo)p zbo5>PsUDsW=KZSpb~@|BGQ55WXETiKTe&8ue}A@r61Q`W0C{I>Thh_l-rV}Ccv`+I zzT9HsMku8D>@`4S*VFSsSzk^OF^x)+qt_Uc*Xe*!c_zqlN0b`QVK0k8^{N~|(rA6| z4j@9t;3JzZiXjW8j>%m6!j9bq>u+&%eTXzbk1XJX` zn7|>%mi#68tEX}M>1%NBLulIIUC*gnZz0XJ1dIU=opv`OJ_vnqI{fGS;kQ2UCCM;j zAFC}FK$9EAbC2CrhldpS9Dxh~TZ4|E4W{RwRoo5NDpTw0)T;BjJA;m;@tLE1{(kbk zV-@wFE+_AN>;O6WkvNfN@!&Z6`V$`n`P&fOD&G$qud$Rko{r5Gn4Y_xR`*uj)hk4Q zuWhkzy0XRI^OMt~r^W8`za2a|*ggJx@%Z`S-l@CnPIxtbt|tJEAk_yi$Abz0D=-Ri zit9LX6fqc;2q+O&0l_HbX$GV~*alH{5PERq8iKSQbE8hzNuBN(^=S#=1i}h3?&4#| z!?4OWW!cop2M=;B1Q9^}o_+4w>q$99Ecxiq2Vo*;&X^Bo_Xxlu04SmzI{#w;6gfZ$!X?3W?L^FSGI2CxCPj+u+8RD$ zd)mdP0kC6Ix^o8cmW-H!F9y-a`91uH-;251gjYkt9|0@ygQjoJ9w=1K{lA^=AEM9) z+Z7**>*v#I0&&?L*q82oVhfx|5x_Em-pBH&FNDZIF&s;DO}Rbc2vA=z>XjgWcv=eq zN>?S|h`g$&vr3f`yxv2T$LVNR4o)y!8p(zn9Ao#nV`eg2z#b785qtt}8@OtSqXTG6 z50OO}OaLSb4i}}4s2hHb84Otr{l+8T^kra?=Tf0}ftcYDsgvPoxIT2(-wduHu;_(( zK=WY^kP}CRE_+O_JfGIdut|s(1gN0yR}&;Frvy1Y8XgM$sA>DVA-im^a1SRmV*t$i z4O!+WKYQxPzJd;hTBh)0(Wy3G@m1}03_HR~Y zA!(=|Kc=Ooz0rI)%MtqGt%-X2S0YKDFEYCNU1*YVjtW1wlpL~T>CuVQ{Qh4gz9Ndq zWQpy!Ikb0j)Wt=8Uc&;p>CLCU-0V;tTIzxD6#FiznvhK?@?qa=RG(>}_S9j7Stg)@hjLG&+@I zd@kWizs)PBQh+&u4Mw(KV5GkzdA3aoYe)N)a`LNwRbKSXraj5yy*05#>Wn5+)HIAx z0?uWlc*ZkD$TaN1O$syC&;kX<9#{dtdnVWbTGPV;gkuJ zq`p@Bl{?gf9d{L0s|df#9}qY3ypxcLwY-EFjnpS~g&kKlM#L}d77o`cmptB)QJ6E} za==~ff$8xvqIej(>ml=aAroeeR9tY8Hn1EiGtg7 z4UR4@_?UxC=JarsCoclg6LP0~t%lvm-#O_qE@aXEhaF=%7ssQkx}UkVCh&QSe0qJ# z#xiazf08sX_f|S@Q*$pi7!6-3%+*xmy2hhP)PTCfpL=o_^n!BTbAlVgJc=^mS5Twj z&sp;(PR%3o;=$>+myN&klUvYj<+wVpoeT=7q3%wU8{6%ZI~o;=NZO!S6dM~G#p7cq zDqqZ|G~h2k?jP@mKc7N*-r_&T#nJJj{o~^Mzte*IPH zBh;6dRUcH+!MhDJDgUBA)=XScM~C}8+iUceM?Y<3)U;U30BR~x z)nq%Jq7UV|FM(;(%2I=ZZ^`tHG(Whfp32%HMIo{c8|fA-$B zt&Jo}6#mYysAi6B2@8zyrQPN-4+goLGZ;L8`!XIcr;rM$wvf~+$$)$P-`|W|W@J`Y zN!Xs*-S=5`#|>4PQF)1sjC+s+u#yycx8}%eykM<1H-^F9p5F9CRceU$$oy^AkrF2~ z?bMG`mRL(CgM`EkGz{)k@Z+*(^Z}owMQ53TuP+jX5a4jwkxRt znV5h>K9HNPmk7KtXAsS+F)i&?3MI#Z0F5V}*p0o2;L{Gc+wtZ{w`5HqV-7t!Kzbsd zfgOXWSwt#Z!Ps8_;2mtari7>%+Uw(#1+6c0B7TrPQ!72f!YKH)#9)52%yG?tL=hqG%uKyK8YtAGFav6qvW>H zH$sJg9S$6=tXLi@@@|U4jJX)S_Js|81X^qeXlx#a1VlKohsWM@15EFC)%rg>$d zAr*@*lBQ2Me2&EMn4E}SQ&BOIA_x{#OBV=@%u!1$DKJ;j7ld-L|B(fiP`qb&bs7>#V<4xgF!^Azl$92tlF zPB$NSr&m02GY7jgGD*pRrPjumY+CTC#CK@}TI3@^utzyM4A{3ePA&nxgL;9vz>TD^ zyyf8s+s0%7_jAgLMV ztUf`dif?3akUo3&Sg>AXyr0rlE-pKU`}~-#K!*E%?$`u8kA`{(%hAivZwV0`5OSpL z-zLjI`?=3>(07tuilD9s^bsXktCPiN6%U+V!zQ5|p0*-sz-wWUbx*P&mHWHr=FIf_ zQ!{L2*gy$#-TYq-?o16XpWwnj!oVn8jV8CqK{PNqjrj*9r(i!3Rl!1HUM;uPitiCy z3YV8TBwBgPItsW%8jRiB$2%=SeDk~Ec*Z>{nFq%a=0+Jthef7LyO6$AWGe36V!|S< zCUsyn4fTRztCMbE{5h~mW)kEO^ep-8MD8BJzSs>^iKtLphSS%GyGrCbi=GoW&P8{e zpSc4K=ii)K@O%P_f>#Q76dMv_Sa_>!qirT}sPYyQT2xZRBkqXm&fX@%E`;|ZiI&Pj z8uJejd`l;`Ag|6H8{V&01Q4|`s=jVg5V61H@|byT@P5@?9$$ECcz`{4HJ8SYvNYRr zpisgvOR2VK&7BgzHU4Gfa1Pq1$zBXbiO9`G-z=w9P2}dFZ#7p>C8;~P4EQ(X+&~w_ z3J4jEIn(*1K+RA(u*5t1F<`<_>NLAEJcA9l@O1k}CC0S@Rhoe9d*t}QCaZEU^UR#4 z-pABn&;_fRd2E(&OspUej(n(%$4GWOmd-#F?f%s%iUvkzi_xKs<0jd9V(M5+V$AE8*e^*3JQkJHbcQ9#X=mL ziAd$2nZ@aW%?P5PN!}H=-=4C5AhGbz(O&Q78y})epf0|>f5Ee$p=><26+P~9^Tk&5 zq~z!nxqv3VOMlik+ zAc{Vr-tB4#xu8gN37ime( z7O6n+680-EWb4c#XJh1wfG-`5hXzBgN@~?9Bm@62V67rDCtX$-iUR<^BfXJYa?vuY zMQ?d=NPan6St9gFmvzBaVpEb8mC$!+kVDNR`aU3Oe0$94h42-*q}iSZdrQy&HOF8L zCA3CHb=v>`Odi-j9=zxELjD{tYzvJxEr3SN-*L32 z1L;3#G~W|KSbhC}sRl>xM&dlN^n2!CkE2iY6z)a(t!c6Qf3SyhAEyGL$ir?PsH-_|ie5AxTeXL{?+e~ygA&}|-tpB#9F9Fw zuD$iD+{mMG4=wB2H>0leiSIlvLoQ*Dovh25ohwUP$+7PA4gLn#aR1s5>caw`1cpdN2+n&Q595@~Zu!p?{TQoQ1o4SBQ5|ba z7(t$3z^qh9X)Iaat7bz*P%d$y5-Pu<0-H*$Y$GvA`Yl>PI>RNhRIZ1>Z46%6-Pwdn zfQYZw1C?C}fS|nRWdVhNm6l8U*@6|r{GYJ-f-9WHgL5_d5un~uvmc%Fo1=jkTwoA- zcvQuPX4X=pk|**{Q+>cI$?eTpN!Qg|A(>H`V07X3^qxc*vV;c z=ua~A(eGrcTL_b15?bZG>Z!T-qiV#_J8wv}okSTwI*Ib{J=c<|U zuRG3)1GxKLAY`}dLhyQvkbwQ=59qybuXf2a;FyiMZkGSL>&3c==Syhe*LT(1kLy9bA z2zU=M(elp#fm>BW$5a8TqHz0ly`Z*!9;F;LGRh*td$CSj}(8T?g6nLbO zfdi)aW4mmuzubpQ}doWVIjNWZ0H9fHC7YF55636OQV#;teG zuc^Z@myW{U6GM?~fjtpV6+R*Mpy<(xDEy>MRR3?6~>b#0Cu$e#A zdh|{xFTiM=0r@EUtb%mD^=#B8jD;vlxQUaCsS)VS@o~e}U%k%zeLHvges+_hpPKcT zN3FcuMytAa-&zQC0aa7fgw2r+*lfK1L5IR;0~Et~S7~r=6&ZoXEA$`A@=+TYsf=Ud6f*%l@R zlMDWI_i*R!>(0T+#-p>XWZ7I5)_ehm@{IP5ba|-8Tk!mN63pOqHT1d|?fiY0}!v*aI6<>qDzwI3TW*0!m z%GeQ0>|*el^a6a2CU)BN$*O4s8u_Os1ectds|H-fVPXH64&Cjd<30SFfb4V8X*MGB zO#UJZt?G!JSR?wuFruBcp?85HM8Mkv!K1Zyf)C({55+&c54 zio(^hVH$^HAD&8fRE8*u*6_$u-Y}P#1`U2^tOSOYcx0%BN8pP525m@YL$i;DHe4#+ zC={(|EXxT?cP^D7OL*oLvQr*Su2AVa6)za|Y($wyE-5-_F&mt|Jzi{DZ!%AjAKE}p zgkH!X#g~Ab1i~vvTCok0XN+P&L);H22LJ}8$V45rUPTWExfdK(D``V9E-+V^0+$iy zRdCoU@y)(Xohoe8fou6Uh>d==!Y@chA*Zks2a_RV9*tx99_@hn zEtTUEgQ8s$nz5sB+0A7-EifH|9s!Rutmw1?g`CiG&Ctpz+FVeJ0_Uf1iQqGSyivmERMu^#%;8~9gqlLVO-XM;DJ2*V} z?R9ee_RX8aqZ3OqcEWtzPT|d0pStvRII}CzW)2ggdp)(x9Na&}C1n%;!)E`ofknj> zS{KP8@er62U{R$SXFhG3_b1D6iP>SboJNnpJ|GAW3C07GfH zhrVN`DXlpS%w5E|^iFK%>1px4q~acD>`7&gydmSryaV3}c}0=oAV+dsbfsMxvUcSq zcx8@8lI2&hgjiROh8E9uPa%m|9LQ;?6o;q|iRfZKwW};06tOEpK1dqryk0#XYnCAvCq2QV|BZ ze)NiFhL(JO&&9Rc3_LeqUNpcKTLCz4N){cJOD$e~;$8|MAGFnp3BiSY?^!X)CsWYu z$%oDvD;F(S$C(+2;}4o~nL@C+~1&vi+ zz+($gQ)l1B`KeP19ORj~CqKw#jET~S9z0N_=E24zuW2n(V0!(6E+B^p77q)5p~}mw za{xvtRLZ3%AjVAe7nH7v-N3_DvN5#tPP{=QI6Q*0*qmzx6pz!gjOb`O9t{f)O)ZzI zXt^y3hdhC6%8<=09di~cihTVY7!qKtC17efS@cJ{7=R*`oTu<(#N+_k=&=L79ZHPM zMs4Na=(Njv0B>Drqom3RPn{QY((fX0Wes2G|Pfeqo-bT|#Q>h?yL+Zsu6;$5$~ zihF5kVjNO2O`7dO5FvDQ+1(KKP=utK$#WUKPS`8ojN&7lico^HtgjFyS(T9TRMNYo z;gnhcXc?_^L%7X^MG0W3G~i8SWnd742N;EdzU=CbQP)cVC1lV__YZ5&m<^Fl&&eyck<>Evz=iTx|Ij=$y+g9#LAHNLO-Z zGV(c|qv%iDJU0!Jwhpr|b*B>;`FU)fu9^Qmt?e!+xAgPWJbTtk+SOl=Z77p~7Jj|H zJA7TXAolgP8GQSD>>jISATD_beJVD-CPw*zZpXRvX!Swg-1pAM!p6in$%7*0$ZjDXH!4uf z6H44VLf9J~a!OM|Du+h9$pQ&`@t=XUNn|5bgjmvSZV3XV0`E$91{#mi1&J9#Eg#!u zf{VA{V_XcGM5&?-18M=&?&ZY?vlme63>YT@X7&d5&c(ejd9h;^p*{#c`-pse*6)J^ zfv35cUR+SPIWB|Znu&iCt`F2fR#xaK86mV$stjp&VpiM5Qk+FYi67=fQoj&6#sguj zoXLTP)nJ=Vz=t3(2vAJV`nL>q1YH)%kK$HV%!=xZP2Wldfq~M9SJ`3HqM2$4L%6sHnb(T%8Gl-&Ub41wV=1PPI zW%Y`j2bp|0=NfG3W3G_ChwQYxq92l#Z=e;Y?ENP3*Jns=2vEqsQC@7^udHaQl}|CJ zpgNzoW<(z{WS$- zE));3VCT)-q|eNf?#b!1)-q}vA4GaMuSC4@Hzdn_gAT0U)d^Dda}My*|t91EEZ_C#t~-X)Q^&^ zbxZfW_tQ_?;|unk$KU*UEwOK=j>3=t7O&+}%=bTRBOwvW>zG=id-^%#Wcah}ZF@b8m3{`7&~5@)95@GwpA604Sq6 z)HC66FqVs$ILNNa%&QEMlc*OsCM`wJS}b(x2O0PlC3b6Zju_C@rGp__$+j(RumDgb z`k{V`jG{4m5?IvyKP#w%B@O?3$p827{!c%=P+s^IE}AE8dhTG6U<`k!q-Jra5XjtSDZve-#kbSl?ASB?osE* zz2lRk?Gvt{TScQ&C|1nB_;fk_`rH7InRA0C6mF9SF)v=UrtcfU^v;fjYB(>1#OKq2 z*;0BO4Tlcy7$#PzXmFkIiZGKO-by6%g2csRnP*Ojf0GvzOUO#&_na!eboA!(ns@wq zh~Dy+ElrVimWs#Ua+%9Txs#h$w)()FtBpxx&tkE@7~h+IO!Gcv2|f2BoxcLrFsk=o zfNj8){kstEE9Ni*=WrGh>+KLv73(HyStdE(>c{NtU(9Z=E_}x2k?Yvp4G#e2#)D*W zXYoOTdOy4rOpE+{f&U9#PVs*DNs;)q)%Fv^>)a-fAur+rxyG5JW2EgdI_UP({Hj3T z(s6!qIk7=h#c(?AX2_GTpjH@_^PE#MMXnhI@*MOe*4r+DoOhsMP$`Jv>$k%x7}+j{ zL-K(INk03S_g8{8=Q(L5PoF8zE$n_G9nh+CH=m3Io*5*+v2)Yeg((ayn4JAd1s`(@g$kHpDFbVKFYmEUUrlG*^~0CDZQJ*J3I7k z2-*cUd*Lr4F4{+pn`Y8zKtz87A_a!$@ZeD*zrS03-)uJB5ff?CP&3d^o5pllIWV-r ztF&|YbLVLL$Ij_V=lG8PR)~ap0`GP)KWYu5zwFcg=<^6iSchIYJ?l448#fkOnq4bc&M3qSegYuAzl{|a0d?v@1pl%0Ef#M#2$>t`Zg58yK?KO0LlyfF4M_q5U3SigsOOFM#w?#`(>c6jleHk14JlhV^^(a1GyVFs8yq3r%p^jh0$uo_)ZKHJb@VvrpdonhH0`To< zV#ZQT?Aa=e7h2yrPVJ|3++#aGSvVTco<4p2Y`Jaz@5%BH&CN~o_gY(rwP9<_s*-jm zRA&*ErTq*iPS^mDFyerYvXm|+YY!HXw!WtQEQP$C7a0`l$|N}{7`wX7vSz~2P}WWy z@BO1=R{Q&B&mDr_dl2S~Tow`$4b?JZ_~+@* zC)+PAWqIU;ASC9egDw`A;HxkwL}Lj)HVE@m0wlRU(XmEa+e(G3HpHmX@swqIs@g$W zdjZ77loEUNoXJ(30mOFRrOB@_tuL*vP{}uY35$wq^-dAPuhQGov+R^1t-Gaj>u}SQ zDb(}?rq;A9acVIzH_c$(w{<|(Rd&_A8a0{;=Xz$FJX?4R@#QL{2xU3)SY^mH3uP1E z`VLW~R_7A8DG92OZP+``FwxgEo}%4KiZvrW!fiQdZfvd^E^yWGfIME)pxH9ya1H() zG?}o!PRHgj>B7>I>lh;222^{G9T}nesTp8iU^XTgR^F!xSym=dm-^d-x5u5`(>L2k z+ppbv>!-*B)5-9-;0S=VIE1yvudU=a4W%W&{^kHi%;`V&hi7SD{aP}l)8Xv{g?7K9 zRt2MP6QE&mW(@TiC9XO;rh|dw!k!)CXx9x&DWRhT`cgpVWsA&1_(_nZcbIatj4tjz+POy5Sj!PUhhl5d~giVkr!HrEYm zG}QeQrm*F869x4E3pLU2G$hMBy%$v#*_9gTBLtY=q=HdWd|89#v7t}yfn5Q80UZAW z^%XmZ`^TM=#(_BzEFgn`vD9cBJX~u&V&3LkDp8U>IN}i0K?k?zZfZ*7ZkEdb(|Lxe zUwTMiF_++&Z}eF93V2?hR15bdj@a;d^=lOUtxi!j51yI5tLXp;5ZHe~Q3<#Z)5UI& z^0o3ideMd#WlOW5)j<88y+IH6Dtm~*3`0ClPC7>ir@#LCD**-1A=KVRJU7+@0BleR zB7v>$cM$2NdW-$kMhPnms?*vA)g^th;F9)Xmhi0LKtxx$irnEy*fl5IFl^~SCp?;o zHav)4337j!_B5n>jLLqBw!!vvGQ7$RGix((89HNxSD%%(JSNNLpy3@ZW4~lLLP6PP zBp^7P=^o=SvDsvJfq?*!xzQ#Sm{${)r2rU6XaQ5Px91Cj?~1#(d(BzX<-u^vP<) zy#(t#m{VkTH*LiS=2E-@-H?)jppa;VDUp~@CKWaW)w7hNi`8%vrDa>oj@qL!Wt0f#-Z58EKQHVWj6QY7$yRuWjZC6SLB!*0)z!Y zpad@*>Yl7zxSY({2x7$rj&<1BNE9IJLZ}Pyg)>KH`_sJc^lR%iYC2g z0h40yD3%+NrQTT;+1?e=hVvjIxmTRz(un!UpdY_RRV33Q*bj!%JL6l2Y=67)&j$k- z_AzYAInr`MsVl=iEH*uWATw9ZNaSe;$6aB-u*FA$Jxi5L)Hlt&T+thyppg57d>Y(o z`aD@m&)yCQ^LnLzqpe-}qg_)|I8D(#I0u#{Fq;9I+JcQs^GrS_EoGp17& z0JjGs{2!cvwuFwB?OncJ)^+d2^39@(Z1&Fklg-W5W*l6&)*(2%$|1y6AGa#!X842K``%C+Acm|Fk_DOZFY3g~H} zUOHSJ7TV~d_*6pxw}COa$*({oj#_5Cq{SX(u5Ab&bF|4a!%-A_kjm=^lI~km;&EQ& z#p_t_M^0Ira&k(ov`zZi$E>eFfg4H9FsAZ4HjJOr;_^6l;H*bx!Md>_N5kcVW&Z2Z z^!2dw$gl#lZY9+6`W{lMw~_XW*xBErmk9WumGI!v@r& zYAYU42VOzxx7_YJ^Ilcq7@9iV$Roa?dRsy zqe5}TyOM=BUXLregOM8IADJK002ZS(_eOUftJ+wXBNDPrw`>KGfC9LKjE0>R5II>f zraB8h&0a;p1~D;(oMz}abCyvAE2@eVFSwGFYy>-RkB-dcD>lGj(obp|pB{J2lg@5u zzhflnh9KGov;6(V;CBN_RAfX>^QSG zNi3F{l|w2@5GsNyW))$ntiUp>Y|0!pQ@*%jN>DCEt#r7vyBX>%8hl4Ji4N`?{zvOx zY!GCb5voG~0HYCx2FPmjj7)Eq!deS0e<7Vr#`)QFGV?1260&Xnm%J6SR}ZvP6@X?Q zEV#299w;dyME|W>S%O0MR}B6AGx_P&mD#_Qm6fJ*fF+02e70(S;oBJlzG(!(4ATO| z@~{<#C;gJ*dz8k3g3*}^PW$8|z$I~6!^ahzqw%K<(EYl;P=5O-3-lwambbqgLufJ? zd*awaAkfD#A4r8QdT9QbK3=OPtJKOc<%S9Q8HAEa3A ztvTe{6s~4})AVkM_!8YTBi%hbN?T{GZgU2*K_fIRc4P2x^U@i^;YO9iL7c?Fw0f1p z@ft-y!8ThMRU^@jVypY(czE4_Eg6}=TLW-6Nd9R~c>|7UqXAEw%UkC0Lw*EJHa5fe zNDrFqqVUg!_)vftz_*$$>em8b57jsRxj=3Vzl?LPFV)MCHlF1d%OH}V!xj3FvDX|I z8c~;Fh|O=NlgDcfgYa_A#_83M88p+UBj8pKkJpHCZsc!ZzR?aASIZ&KO0lMf$?y9ajAswDs4>S8C5x~6^x1R z-Uq>{s3ocgBXTPTmx8~W0Yd`0naCN0RMx14Ac0J`pK~>AA4 z<2(Eyo&jh&-8Pi?7Q^lhdecz_-!j_cYOI630grA+iU^TSHUo2Y12YBX1!nVUK#H3p z?T;=~Lu0c^ccob^$n6y`xuOvXq9`OT;7)ZvaM(R%9;5R#RpH=xKN@7aU8ZmeFq%^# zkMwaT5P0=G=Be0rV8C3p|OBSV3;kxuOGGIFtS_eT@%UjUe1|hL+EA(kW zmlD)>MXKE3XtB66CiC|do20PB#1Selgv*WqSE^1VR?~gAbG#$OkrGRg@4&E&#_L{I zbTdl2O3w4-7E=Qd;{8q!4)=C{l@t^VkQ`d9Ex>sYR6#o4**@@w_MEsGa44sFH2@Po z4!h}DlVfFqL^$A(!bUbs?cXP+w8EJO150itA27!PQOqy0vzW>s2<;@v(jsT~Afy!C zev0J}Y}!}cSO9}*6iX2#-aP-d_onmu&B<>(&mhD>H$6BsSJ#`jC$c1K)lC8FPus^o zNz*5FP*DTByM3~aO`q35HG6V+&^hTGy@sZ32-x5VCG?qj)T1zXDM3l6m#dI0R9{2T z>~I7LLSy(>Hu{!;NNX6dfusr3nT871Jx$j)JkQCpIDL zQL861HFPBWUDhw|xV&G-098Vul%1vmO_OE;9YFIGSd zE6$ML9ffohiAXwB`~b|+E3z7~umUF817JT~Aw!iNlN}}L+b!^KUuF9nXL@!4O#u)B zKAfceSr`KS`q|)Q2uzjvr4cTcT_|W^|A204)d0^pokT9;f+upI!~t%sNb+n(oC#Gj z!{xHxW0Yz}>NdEli?#D0y3P`fAZ3i}B?}3YN}D=1VjiKSOF9A5Bd$P$l|*S+O+WkW zyfzx0K}yqtU$wPHdE3Le?PFn;5Du?kky&>vq^lNyyP_dMg%<5d00y@GKyRC~Ho5I3 zH`X!c%C;`S7qt{n=G4iR#eL zAm0LIkEt4!ZGK{|S@nTdBK>$3-}0KF8wr~>U(};4wJM*)k^Q}VH+qFv(;atLCh;80(_iT+A3_ z^2V501?3t@eQ&F>4Y6D;RRf{~xLjk*cGfk?y&@=Z1KD~pI9C!1Tp$AmV3FHO40glZ zOMo_$rvDkFUW5FPY36^>t_iZKFl@6k%<8!78Dj>Ki~@6li)YJz7vkT|N#JR0v+g@o zNzHlR?a5ttjT(CMi}u*-SLueFt1!)2YOR==Hh{qf1$3%V%BOO-wwJJg2`@PbW^MxJpUM1M9QYUpt$XD+{v~r;R&gu zs35Hi$S(VxKu-jOjwcWSdYOI%Nhuv%kZ=T<#IZaN4AzaTo1&8y`tS)5ibr*Y81sRl zK6y_?TU0LA(UAOVDi-X=3@?d-y;~MjC~tR>6^m@Yn+4wV-{vk2AMZ)0JTO-p|DIws z@_M23xDuQ-04k>(#7VJ+33Zq9=4Ru;W0(VulmaPGz|NZCo;2Tq)*kl&QY^~7ENdI~ z0p(Z40@9dzQ}p}zn2#sZv@c__CKiq*9NH3>$=lsm&>gicWNGDWJK%h0hBtG}xed~< zaU7B*Czoz-YTgWsW zk)njiwH;uM!ydKD6vL)~HGKXq=%*awK3rw^qQ38u5$a0AtLp$BYNXz|OD}Us568K= zqM}DMr*|{7L1CCo1QY{mDPFe5-^}vIJBAk<+vt#}G)0U#1ZodQ(>~nq`i=pf%5m(Z ze}%A)&4FP-A2HiuEh}}$#(WWPaW@+4sH#Pvh&{w{?~3OV&Rt!hGtC_?(*K+N{5!23 zAJJ3CW-6#~=pcU{=hoq+2?TVSK3+?fKGyk!5Qu#vdqLa$=d|xyPoGB{$G%2Xyjpa8 zGnLMfL7Gkf7`jI3*`=+sX4TBo77QE`Y@IcmaR`8VvEKd%Ul~Eh2TampGJrKn{v=)x zJb&OpvT4Mh<~wNd@ZtL!FAeUKpEsx<_`*D2O`3n!c3}@A0KdFk4?Wf=dAM0x#QQSd z_dKO_>GOF``0hKO7v?^P3X#9r&!dHZ<4J@lRo_?jXJS8==~`CSg_yA!+t}YcXAF9$ z;(0Md2DSd>FrSwYN(*)#r;#ES29g$KS_|q~FT#*T9y_xXUC(*mSA>e{r96~Z(>_#) zhbVfH9IM@A;ik1=d^5rU+@ff$7Cr&(ms2`<)-{(XB(IoahczYBijJ>XlIS)NUXoxQtdhh3l#fjzgK7u(VC|U%=Cs`^aR8L zc_$VUpQv4aTM0=VdIgMj<*i>YF!6}9>enn;-7+P5nb_v&d85V<3%qQ98(t_h=HwIJSM8;S70Q4SBZ_i3ytM&{*`M%fABg-HWZ+

0JSy~;4eRQjym*w^RG#Ti{mkCc-8Nf1dHDXzEVrtEs8Zcs`VV6 zQryz{0mz_gw1(W|D1+=gx>Hc%4U-C0)8O6laJ1d;2La9%5u#M-1rVqv>a?uZVschJ z2p+jo3AzP9DJP6&oe}IK>q!TIjM!zcFtjq*IyDY=XXSVlY7F4aiCg19Y>-L5J+6rw z=hnxQtLPLHeB;Jdn7?8eS@w;vV8uIPUg)#;nMhG=qdoQKQfk=XS(|Yjh2)f{WIx*e zcro)N4X<|~LtJ!NWP+N#3u05e!vWToHLu%DyuDxD%#VX0`vL~+J47C zEPOkj<=?7iq)f$C3I#}vWq*kVA;60R0I2_nw!{Pn?ziepy6(5iFTSB9(*B>-;{zc+ zEBzhG$%|T1Pojw@a$@-#Yg>aLjk(FA0>Rw^GDjXK&RK$J;ZiOj4jTqVxQ2roa~RF? zx+ME1u% zs-+*H;AW}YR^2r?M^ROVfXhSJ9yqXwQ0sbDcUvY+S1yN`WWLk}m&6oxGF4(@7`SYYvbt1yCRK;V~D8z8Y;J6eWah-%ia~%#c+Mv?n+rQ^T zmcF-zNn{UMcBlu3xdDckav3}uCzP#k$Fgr!PRfPwIX1PT@~m~RTj0!rST#l_F?8~OP|I#j#=N7&LjFoUJ<7%b|gQA zWnH2+gb%)j26No8C)i7|MU!PMZ799)#=jKVkfriumcm7nP^<78^gR9vdbbp;$IPkI z2s|dhO}?%pPsi&iQ=HY+;D_JOJgDPSWRrFcX@(LQ4K@Ap`nvhg8VLH7_C-7|0fbSt z^x`(x=ijBh!ADWwX}~2&(SaEOJ})k_UX1Ppr)-XGs)AzIXkImd6{5e{&!dHZrxGBY zN^zo!t9E-zKFQR2l*8i8xi$j(oBjMd4MeuMPW|#&N2Agr&1kR0+Mukv&A(aVSrm=} z2*ba%EGHTi5UQ4`-3Z26U(#j+q{c;fU0!^+~L)*-=mhS zP&h)bmtBEUEqE}1opeI!i#-9%OW9c2F}oO!Z^>7A$2_UNUAW73(am$pjz=Gu6EnOO z{ANFo7D~0V(XxAZRIQ!FpCHlo_Q7s_`ylo9!Qn}L`^SEJ%&<}S6XqH}+%Kgg_kNxR zbyxQe-X7Prf9AK}-+5C%{_lfwsk7QY4=w9Qdj~((wErO(&kXQko!FyU?ZaH^+ee+c z9c!0TtG|A|UDrO?-#7d9%in$yuFrNYhPIz_`Wpyg&Z*)?6`?X>^}Zn(1M!c8tb!Ng z^y(_b8eYY4I)-3kfU>AW;YFlmbb6sw@AB%?<+UFcoLq0dcL|lF@}k>M^DA%}8QoHm zb1C}Fu)7$;V#q2KJja4{03%KM*#!h;4b7Mh2a2gfFc=j4MS`kPuhZM)b~ptGzKh|o zhb|^yfXF^#0b{R?Sw?h&yvRSAMJOoH#=J1o>Yr0>N_t7Eh9c}=T!PjB97Q2ya)3nx zCg}%IUP4efg-t_4fWeXB-{=QMvOCW4i`mr(LxvGIrFT$;O!mSdULQNi+$MV zMX0e38w~#ihaD(YH%Ruk_m3LwrjG!)?JcS^IxVQM*My3;@z;?~4_Gys^5<8Q==Ufr zo+`fK4o@fye(~PD#iVbL+w_AVS}G~F_+~j>9xoTm*d z01aV;UmT7gTZ~z?l+FX^wS*B6U_PC^p20cPd+M@VamjP@X^0dbq~cu*scY`#gKmG? zQzAsI~jeSpG_kC9ou**-e%ygKT149|h)SUaulK4w8flm>r2tQIWP#3p%QjJ(3+ zmS!{tQzrnOlGE|g8~Ov^rnXE5xI8A+8UK`>P9mdxy}iGGXl~gbPkwvTNgxC*!nF&R z7{lh-wDS=sgu{G8RI*hH|K0MLr!+wWGx0HSu#~6|SA zZd?j|_Q-H>Qni}-&%5!XcVtKJ$c^5S8NDMfdPi3Dj-2Qn8PPlPp?70L@5qJTkqNyc z4|+!y^o|^;VL(~1il5>yJSK97oM673n~A%GkTEo*C#M_}Z~>2p{e;I%Je(Zx6i&TM zYT;O6=3W+v-y_PjbGX|fqQpPB@^D6yDb>}{-Pz^BWeXA)Lyi3)#UE!<$JY`WVqOQ! zF{)DmYS9bhU9>hcFX!HQb`6ZnCKF#$Jd*TPWa0dQB|()c5KWiFGK+dF@=0QSx$e>VDcgAzX`(0?(dR2g_W7L#Shm01Tx_RK6-I-v*;;PlMl85shQ38OM# z;i3W(?5>PFw0(?$vSIR5JCEvFm^~kk6UQ?#7F2)QovN1xDJ~2jHR!!awv$B%X;H}7 zm0?cu?hM3%Y(2wnj+Bep!QhlE-(^&<+}6@Q8=-J-YDU5MA;&mvm3VKF_b(#YJwwUH>8VI!b)erU&}NDTpTTYJYk_VbZ4;xv!vS6(^Mw%L zibx?Pof8cC`?YIva(LA7U=#Ng0!P`B_MI%zwNPJm!0A>)MR46o2`=g^=7PI(^6RNX zknITC!QM*fT!&%@iYi(pa#<&-UaHUB7*XECQVrsqGzNA3 zcYiy;6Jz^J<~>4kEE=JB5i!3>kpHh!3C^24cb~F@cCwm!keUrS|XM6ILL&+rcEgq5bs1 zZ13zCLhj(yf`M?;k$=8U4-VBJW&s!smxrVBdh#;RW|Y=*)=GN4ODkF1+kAWX_~dBk zEr{qYsUf+xOm{zIVj9$p7wB~6_96|~HrpF2_Z_PDW;$fmaH!XmvT3^2X zgT)n|fUkeQ3*7cWdt?CMqW4?My&kl-*Zr#B{CMvlo&CMndneU%G@MW4O;eTRj`Bvh z(e+K<%+Un4u)Yay-Hfroj`;IbEK2ExdAxfPtT(HULJ|`)7fJH?Y1k%YB9dh7d92Op zFMB6H*=wrYCdN!8N&8vQuEaQ)F+C}@3HXB~dAe2!$F}+YhpOvR zO?W?>Hs$dIcd%*mI5uX#O}kwhP=z&-5-0F6w^ zsa8H_#Tpn985xIBfCi_WL0 znIW}9F(HxSk#{LN$c_yvnRTrX8J0ES74K!l_LpQUV7k!4dPWrmP1}p{@R~FUFdh)I z63Ut_<0;+48=I@ifBt8Q^d}yk{djcv%l6Ct4qX7iv-QJygpF49Tz;GyQQio#fIC;r zj5?`^(>%-E`a>>-R54uh-Dw4{;SWeL8&rMlAOl6T9RYujD|pIq7qH%uJssQ2jrfDcKrAl_7~ zP;dDF{;9la;O7{{Qu+v*b6V(YfnT%pS*R58gCDNMBOWlc%diX=L(~qzf*q{bF&>zs zJ-N=ZLG?}N#t3A`EadnspN!M-Ekgs=rcw$-#2`(|VAbo7Fd{ z{n_>;Vk8j5E}~#B4y%0A+Mg5W_(Jk=k%0LJ9em=z%2%@eIWP-9?OrnOn2p}e%)J4p zYA|KzkGX!3ILN&aisO=9uWn;YTag^q>;<*1*joE?LHrb%6rdiKlDU&SOy(~r1~<4c zulisM5Ve+f*zJ}i@IO-Fv)KCQ*7X~;1wP4pm%G`=_HJ?z!MheET zDRMx{oYatWX5O5$zB=_aG)>Y!Dzv57G{5&|yyNs%Es*EHs(PtK;ZAWMzTon5o(bZ& z$h?$AlkhM(ib6uHM^iG`<%8hArAJM&iE$lVF$ z!t7!gb!kxEvL$Sygm2>cqSIt+ty@C@f2z)>00HBi7#aNU`kVZ(_^w7oMn8*t-caP| z%GU0(GoAaE8d>OU%=$RE4{)+vDE>}ACE>+f7AM;;Pj?RA9-JhN_UhB7UvjOad<$`O z6EtX#Xn|G@4+sB!-iG8VYpd|@56>{s3jVwH9H0Dv|Kjg!&)mQ5=PiNM7D(mZ?eAUh zr@HqK-q!@unn2>-Ph4;Moq9jU5&y6j8L>cm%#hlv&(-*!s#&z-^Zj1h3#2D9rl)!h zeu(yNud4a3t#NyS^wiD{=hCK?z*cP>O@jZnAG?2b%eBWA(ldcX{T^f6$4^|pA8;HA zjRSvwyyixhd~YFrZ^uM)!QKf%N}kp|c`nZd(sO~NTRnRm_ItMGW}V=_&!6$Q1=0@| z60Y)N#LTw(_bHC%DbDNrr*7Bi-=`K*d)4k8wrykE=WFiY@7pa%X%sm`R{b3z(y>#- zyZJqzjYM#q&K2Xrn%h&}+3(AzsN6gG-u0$6vAuQs@+n$XJ<7cwSB^M5MS}IQ@kd8Y zD{b1BPEpPH-D>HtwYh!i6w$e(wIQhVFJp?vGu6_-E1e=eCZZAC`?n>;U{BHfm#3jIr? z(NBVZ1(L<_nzr*nT2qkV1P2!-iiCVmnxDqwC(U>hBeUSllE!LPi*2sy-uU5haNYX# zTVjk;j8Z(oov8o!DX!@EIO`{mgPnDh0^1TLCVIyB`PltScP0J%J^lNnOeu(R5+^|P z_=mPTIZq$Ef1e@lJj3riE8n-=>N(wmYp&l9k7N5p5}{>izAxtk4*4u*WQ&%Gm@hw9NAw3ru!uxFfi}zdg#Jw)M~L||B2Q1$zt7$8Ozx=n^Qx<; z%+EQ_G|JE+)cSvacp5x0%w&1=^rr3pt$GsvTS74YYCGDaz1qfq%cCq`MeWtcrQT2E ztDo1k{Xk+?FcfatcQv1vCl7qyrS#&cU}xo|5qg+3SuRN_l`FTCsb#c4de9ykdef^4%C3NfQWgMFtxXXzFON~Y#HdS5$t z>>P^E_sw9Y=>^pjhP-!>3IDDq*nDaKlu*;5`1JD(bGowu`j|Qf~ zVeCWFU3uzt@q84m=!7&WeY41Y!3+9G2*wKnCDh?B*8}0JdT+qF%5bL%85gh8--qKx zHX<}j182`~{`BmxS-)QUS&Bb#Yo$}CvC@D&HN&&(hQ3F^dJ-le4!AS{@HSp_j`YxJ z8}%3X8aa=}JvB`58k`*5YtD1a zK=Bdd67KPe^2}z>$%Ulq$ILN6YOcq_2tq~^LK8J0=TDBCx2^{?1+SH23RYgT!|Y04 z8eZ*?c<7PS!pVAr1eT@!2p_Cl`auWT^W7G`Ib^GL$U-VoD!q;=zqAfELWDx>ARiKo z8Q$=g*x)-XRL){7VPuPqOopR?hVfp66!+xFP)NfjD)Xmy2)n$#isnUzLNocrDAIz1Ri2&@*6_>+>m-TpbXB@nQ8{ zXb6A5&ehdDi#vJ~)SNKJY5m8#AA!FCG2G+H%H>v~{2mT=J1^h<=r=4Ty?n^+B&FTn zen)10GB#tu2b;;NlOHhGrE2kJY!2>(+Bo)szK3i>X$Z(*ffbw=5WM-}Bo84SI3(CW zn+D7~ORuo-JVvLu3iLpW;M2lvrr<{cgMe^`afZ2uP=SuE5_8)XRK;h%#&{GA7B!w7-S_?dMwtRbiEu)JXBO=5zsD>zr0Nv#Gk0 z&k;QH*OS=bR@7HGONLn&XvWYIuIhdURsl5WK&5NQo?t%%Svc^Vt6{BFf8B8%!6+Wl zq~Z5N1VU?ZVA%V*LTZGih${`kFN;|%o2uMlQq$3Eje+*}b^o2+(xW}ZOSlm}F+ccXa{fK6Rf&1#|V;<(~*W2nT%?QHq)x)R! z^=-9AZJH2D!s;na2vTmUhcu(^fIP+3iyv%j$Y1SVkg{a4iw^1Paa%nOde9_GpICcr zpO4TNy-@FHvh-X%ermh)%r{PlBMpzH4f)~ug(rmG;RMC68t+i~aT<}sMKM9%AzGMy zG>%L!eKK%jt8P1!7cVvw*+SYVweI+q@?${S3%3~wqb#jc*rTTHv9%*!V2L!FN7 zs_{X$%_A+=%3qa3gYO@Er;k3W4iL6^Qf_1aC^dfSopWp)HhETV;!QMc|Ghre*xVgg zZ1B9)fHIT>&3-5~(5HIbl&%AO|9$CwNEsEYp`3F)zhB|B$LNl1xc)H| zlOnlCs&WQW%t~S_+uC4BfB`He2#AGiunO#YF~#bTVg6I1i$9Ks*C+}#Jke!o)RbT= zBiCU~piM&&A1359KU&`Mg}7un@t-v%-fECtLwETz@7*}wPz!QUfoI(p*k3I^A*%N%?U!F~oVzGk=~tZzQ{&*p#rN6Z)q1=S1K zjLqb}-|(H;xA*HI7ZVj_WJ}IRMi`t(EQu4W7Vi~!1TYMN)A`*)(}?*ObRb3qSo!B* zvE^w2OM;JGYr9a*0M*LpwLC5Ey4-#boq4eW*(nydAcE9)aq5Q59Tov(M|=t?=WHS{ zagumwqXVL37{2TD7NsT{P+`qMWK;1YLmV;twdo>dF;qvg>@htpCE3HEj|AfY*-BV& z79Lh{v*KHKEGyqQivSio5&be7ro`?=#ZC;ziQb4QmUJHv4T6BaRgBvefjl;g3vjFe z#@P=Z1^P!XtzQ`E;phCL)PQ=mSltEGD+QFYIv^Xm%<)TS;4N+!ZMJ>^Qb)X%C|2y$HzxB9D|77RN_%?R zIrwq!z}zCgZ2xwAc;K;EXf2lf9D=lkhv6#=>=-^AK$;$#3k6!K3g@YVL%PK4;rK&= z7JUFf89P_X3dwB^1PvqtMk1JGSS|{!q{-X%N22onN^K=F)rez!F+D4cpbYZ>YhuBs z?$XksuBseMKhDZ}!%`s?rhN3Wu|x}CE~jp@5urHEuQ=-^Oer6J|NBXF1YU3_b!;Y0 zUn40W;7h!Qenel}${P++bpUo#m=eBssn$j_n7Y1-=R*C2i!cOAMvHbmEInH&`!Z)k zgIpn=MI05ErL1Q*=mSlLl;wi&J5kYlskrGm-J%0PrKf@ zya>Q7mjQvtqdMh7)y->P8dU0DHuMDK#DVRVQ_oWZbM}N_-JsZUAh46nkQk?wVqYL~ z6)E{>yLkqhOS=Sjoq=?>K~Id2NL@_>g(GycbNNjBUDjYi27Y=IrcZ)bG*o9b&M0A)`*&7v-b{xDX7Uw4c2I zgrUP{UKkWYBHEOMAfH)?Iy0>6hjrEQd+dlRLl59{d~Vft-n$=cAJhuc_bRKWHT0Ph z)@JPqh^bYhT3e;BbLBGi?X|XgQ~vttdF2<|?b7z>*B;wfqSULHu_`qe9m11m zwL^G<-(lTc{1d7SUi1r3A4k5R&<@z?uR}UPJ9fi;AzvYih56O=7uaiw@}1{d?*&P~ zlS??H2H41A&? zIaPO;>3T{7JS}3XL*}Pux%8OVQ&!RVFRY!`jc5z6zW1T#rpzu_z98(|5+RWu!J)vDz^H|#W6^>}stgFn z_thSLO$l-Fogvb{f-4ouFcb4XiZJk%ocd^eVS)W?miy>R_Awh5tmptFL}s-D>6$hK za{(_M@d88Nsrg-ps!#;>!JLI{K$g+R88PTNJ^E#1yU5!}ZD!nliF8>UEp}Ju=v$A|D zSI+QO3+%ggB@0~*nS+?|pdx-TVi&>-7MH9%RED9Ra*O8xd|CrngrxIx=LpM?P@10X z28wr^6X{&#A#wm6Xq{urQw~zcP%Z$@22aGUE)(XbG_-k;hlBl~-9XSDPNz zYy37X866?^>EVrDib2c2BD{cT8_cMsl86)Qu+D|7oL6FLF1qdVe2YpOlzWeq4yWcRC z1~A1|CUo&HD4epp^sji-DYs{kwkY|H>a3;7b=L1MLk=rS<5C!slwB1qatHK%nK9M* zWDM?vT%P(?dK)(~T&z4!8$O@;SEgwv?^%4M!d@{;+3JTFoUYUmvb#K5pJ08bJna8cgV?2ZRbl#tP1@lpM z7d%U9jC)e!sA^n0_~ft2;_$;_@&Xj9FoDIUOyIL+ft03~r|DBRz~fg?ED_aR%0Q^1 zajfzPt0|I{r&O)52+NuPxiRW{mbSheV+y4j8Jp;vqNY?jM~%?#;w^nxsTs>rKlaYv z@e;rB$rbe?dXAv507$@Hw}e}@Inu0+UqXtM{3zdZxz%)(cyqn>=+C$Fn~AoX^@j7G zP8nprC1S67wjpe}m;WVf^)Nid8=L4_!hKcZ%dn@N!FT*2PU~FRF4;)Jk4fV^dAO-s zhBK)jQJlU6MCH$lKuUK&HHJ#?q!$|kOr9SZ%Nm{7WH&rhk@O4FgW4F))%VTBo_G6o zivhNsLK{uqY!6g_MCD3=vaCP#FzB~ln&R&pUy*D!QHvNoBEOrJ@<))|zpn6_k z)15J@qPwT!aI@7|=JwQgz;y5Vir`h`+*rTA*N9pM6fCa==mV3)3_fvJ&Tavvhh2(d z2Is(g6nh%rM07g2d>VKS(qgr>F7OL@i?FEGx8N^06-UTml(__J(yZbVYIqarTE&}a z2E!u*I)QnV@$k}@@QIm?5T7|4aEUds_q-2Ru@s7x&{<40^!aY}(ltF};`s(9JFT(XQppDSH;FfjO>Y!xEi2EBJtV%*gjiQxRjgcVP=GN!hg`lDMiW$u z9CD+;U_yUsvq`-@y*5jKiOScJ_nD5VGU5PPK&HR%fT)*4M6V(?H|DYSWvh*yUDuKNhbTmDw_n21*};`RfXL;&p<6jx3T4^w4o2q zZ72jKTzR`XpsrwTbBnxNUifj!@;Q(l-H5<+`IX~g+ht8vjYpK*dYlzSa-EJTb?F(% z-IRK`6gB=a6}x$jhmZgCR+TP;?i~{3QqDGC3XLuwEJQ~Po3A@nEfw-`kX;{B zHc=fc_UR$lcFnt{6IjX6*T z7eT40ihfm@z_HCdo?D4#KRlZRf)JZT1)JnhRf7S4Rl*xUARKKzsPPJW?YzP~I65Ut z3DR6um0q)xmmp~O&E!D0M~Uqa3J1qF`Y%CZ=HFKSAk z6^S{FZ+_JPlemLGjW;&0t7q`7xrgDBDUrJ{N=)wJ&^jFVw9qYLe2{muTP`tbFrG2V zaQ&gjMxB>B&Q^SH%j7-Tvc$$I88sr=P*FYS4DSP8_nV0uygJxn z3pjo&^kCJs#PmZ89)Z@EW?;&9bY~G;EsF4n(L9*<|Nlx`h^&SbVf&ZGyZ`&%&mqOG zlk7(bo*B!R=w_bx&;=K*Tu_P~AcjHQQCg*^Q_dzZ-|L2q2c$9IK*QTTm2xd9ygO{OnABFlb~fOGTe4~ zE?r>jBJttnhR=eAu_$r7$!pTfY+gB5yxi=$-%Ll0mmB}!H=ZkQ+(LOQXJ)mT#G}W{ zP21(Bo@lvD5kw!Y6-1c}PJj9zzj%N3T6%y;7pqWd{RqAeL4yw`Y** zIUlaWGQ>KSTkKw*(yLD4#>QZ@Vt zw?Mg$c8cjmBn&U~du!z92L5exC5e6-HMM7cL1}cW3#&*Gv{LXnTt47nYQS$7Wl7yeUEpkI zvp4eoA~*-dZkX?KYryUMJB0aqJ%dvY0WpK@4qBxE3E?Y0>lC*kQp6$Kkm98LV<47O zm0Cj}jRLA4MpME%HQbFDBI|T`X7kr8yYr#0jZnBMMxp!435N8HeD78pEfnk>7?CR{ zvVAq2QZ|bbhaM>ywN@yKt_yZ-z3K&SrBgtdIn}Ci7Q(<#LSs_CJYwSv+9og*N~*UZ z^5Tj@JQ*ZH+J=DU+?;-Ka$i9E4;S8iL4R@h*{b~c7d-hJ@b6%_m29wY`?({_U?lR_XP%0^NkFQ$~3oimtLMwIL<1EHstK#5e%a8r9 zwc7^E!olt!n7sj{`i~5FxgEk#@r1DvuZ1J77_0uqT4bDcL#SV~$KePZ59KuOvc_^AC(mYGsb4(5XXW`-X=MMMlbxTUmBvy>&@H$4FCf_8 zds$z6UGSfAh)1gzdgFrRCF*C zci~}?@H)5r?gKUnbIXRjlecBl4Z0~wx=yUAWiX5s7e&7zUF*uG6T;L4kma3B9bAfe zI7Vx3k%L49iSeKvR+1Zm?be6ALb9st&36qu=W-T+`}f_7*qA!|nj;1hJ1r`?ilvK( zMUg`?dJ0A15siq`;AfzzA}@j3BXgq0RN`&yLqDT&g`c4 za8ohM7i3;W8o&#T+Z&iWUFexg6_WRQoPS;9MAl z9^k%m8Jc;n{Deu#c|I;C$*|jrL zZ;zNCiKMXhf!i$S6~Mpl#B}@6PGX+h=^GX#sSUC-_Z+1|sk-RC=?%tP9NuC6 z6-JHjeC2om)fM(d;Qp&m4pa8r7L*>1hu~LbORmsuR8w=s)sP>aapie%=Y;-?@q#3a zyq%Px@Qe#xbiEuRo(r8FOjzxSOH=5GSqhzCx7NvJKJKx<>BJ9$wIzP1V@SJ+c@opU z2m1Qbj6|?&33KTKoravR4Gh1K+~Jbf*d|+rx3E$l4Of%0=)w>rg(ABca{h`UQkEvD zlO5F6;O#O4F@sP4m}YJxR+_e37*EWr{VMy-8#zcav@uccxHFsuT7%0^^0rAu&b+10xG4EFc=ul8FJkZvW*^AXKI}75# zrUL_H-L|Q6d-Ye4gX$9!=v;YVf}!%xG(n0FUI$l3)7uPlH4M+uRdL-e*m#P`Kdwn> zAwJs!D36A-s^ zV~&lvkrq*VyC|+FvygCWCMOqBz*Vq+UYtGmEn`|F^J!dBM&v)-F(1FSVp#z!f>lOq z*uemdNWK#k?T%<~@s>9%fP~OT)BHts+L6R_QYAg2)<%r*Q_syv9Oy?N%&E%`A!FCM zb6Xw>z9;YQ74PpAEsSd5M4$GY&Qnq~@>(Kkf;I7`P~A^51s%QJ@0|X!ck+`chX0x@ zVzyvBxxj9lTR9sei-_nK9cmf1V_JQkeN$7CyDsBgHE9297s*RBD*ugE;-;78+0JDK zcp<@DL{rR3>Kld#_=Mr~0wbcJMlGuS6R5e>&#*G@EyHo4YC)AOR1BDfxs?iI*`P2i zvx^?13O?hZkzgz+{^(FwFF}JyL1ldQ%{Pb#w61&Zs8k=UO`A=2M*18F@?V-nrv{T% zDjoWnBcV=kvBA&R48JaCZK*osoOhMVsuKd5om)pQ*F5=i=*Kgn>T{t_hz9N5f*gzJ zeW2wX@$xN50?UjdmrRO6M$BE5zM-yEf2N2Sqb!^XGiGU!&Dr&FD>0N*QdmJs;a$)~r$R&$=%~(kJ=x#I=c&Vp(U^M%x7st(5w6PSPuTpisD2jogH2?xf|L z^-vS&u_!Z`iMmXcq?tz5bzPpyB&o>vTpl(AM*13Wkm=A;GKMA?{HM%doqRIyLgB_rza%HXFN21SfRB)ivLasw7qjIBSP_WQTx!IoKoD5=_5 z^$rq~QEk_YQPUXBltbi^h?`m={Yp}l`2)SW5sIh|pGzcc6)pdQ9QcM}?B+!mGB1!W zf)3hzdGPB*8N;up=BTmylxmo4+S?4^*!}WZ{~104obs+pXw%R`?oasEwk%Kjt&2D~tEi+J8H{V65MQpw5xx*5SD1EEqkE^En*yov)lDHiq ze6-to-XThsk5#?)GwYWs*F;pX@bf4r4j8(UP-Q?@_mA&hs#lw&lL-j4hF-e6ss}93 zZSo-}tvX$@;|%NM++xMEVuD#i(9Q3b)#98R5^f+R`%+&iVms*BY8}bN5U=5aa*0so z+{?7b1-msv=D=-33I-`^3e~*}WCXCJ8qCrwe8>f>rNUt|u_#OSJQ(-{EC;~iotd!> zwUZk1coS>F^!UcYTW z*D|F?*=RVPIDYubFhc1?*5V9Epp;3k(_2+klFY4fXnW^jLm27*VGIW{=r%NpPEvl; zpz`#r$o`mu#mpNSRq-s?hHlmd**%R%!1t*UDDKbW^o0E@;ms^YZ}TfSy(pG_5dr+x zNa<#+3`pg9euE3`j@Q}e@YL9MYzn!Hi_OGpcR2Y^PV>ivirwA(qZz@2cMsTXQO(;@ z`NNe2L2XtG!&ne-^L{ml@~-`UU5bxIlk_CHsts5@qVBz7v4t~;)cgrb6eo73$pdFp zs)7FgpRD@*99H&F{>G{zt2-Q%^p4gtL)^_pF&tpJAf^!~lGF+StpYuxM_jVf z0@Mx%(F&1LjH-d9W)MbAEi+sE1RKUoHFH!VV^fXiiS5d4A>{Y#w%!V*ZOUz;ChoRs z5!KIZ+Epbf|*fbLk! z2)vu%<~J|QuJq3-_Z_`VhM=V>!v4i2&~>QC+rMpbx#CIs0Wjujh>54n9R&>m2D{gM z%OAij^q~5S6ktY|%)P;6<#Lfse*ApnDxF-eTy7=dkLjFVrTq)@kDh6^3dXL zWiIR$xrRd!?ANq_Re7;9mAHlMeugnK0;Mpaz*zRvQHv02NCOw#%Oz#w~~<|MrIjyK&N&e*2+)^&ODZwo|~J; zf8XCb>6{+^4V*ewNl3API)=oAy(&IO&8U^3aon0o_@b;CMu<%c@XNVp1O(KU;_q0m z6+o=y$IwLn=nQ)D?avEzEWj5G3$r7?k=S9l-_{pO@8HU!oW($$J2!^0FU&%lHA*n?SO3jLE+G zNc{1vi>RI+?rCK{LRu=meBpwwpgIbm!Hb&p+E3?(M=7-d!?t@L@ga%~6OLA6e@M*R zSP5r^xeX+UgTx#usFtlf-7y_1KcLVHOquD<9$rG%d69)IMfspPoL(Bie{2RzJeU?F z+~)Xxd5cz`nOXM~%#-wN!72z#6hRupM>qHnL>TK^1-mg?r~h{OzeD2Va75e*Fn@XL z2D&!n5z;381)xzQ_@@j143&G0KQOO4b#7h>5OYvMZxo(qK1`OAcJeS7&l}vyW5Z4P zqsm7?0Zwl%Hv+|7xX`iy{#zahpl(F#l@B*Ib<2|F7@lrI-jU(^*-#l!#kjKW=MW&O{7olAfD-Z@)hq`cWh8{K&$TB7 z#@3iY@>?-F-cke^eh*LEf;w(^aIUf|On?9{G3uK+bK8+z3l!GDnSdKdJvASOr*My` z0}9BzNms*y942>)cEGCDAZ)#_PiE8B%#I$KDt2LS!usyWhA;R5JzvS$E+uqM%w?k4 zAmHaR%PFlyuKJ&(wQO1Vz+U{NmVYkrMT*!o(fOMViHGHIUCzv4+)ZQbY*6V~4XL*|b$~$2$!K{C zzP6HVb9?~+`b5zs1x56nO@Y6b3MFV==j{jCkw1ny{vL{s1CFqfDkd$e;7JAnvxH(_ z7ft+wf37}26#{}F;TGP~P;Dg4xgqFBU1*3l0y1gPDj+jP627CJ9Oh@*TOp0cMM>sc z?AVZ+^SnG9;m9q^*T`24k7)ipJbVok@8wwO8NCGu=$!xpM+=~p2Bq0ZQbsdvHq(#B z@7g`0{cA8H0bsb$N?W)zYK4cL3TF-$Y-vpB959BTv~&Fc7@`Cc;-J#XphG_!G(Is4 z#Yo{Yrkq}hTzKyjgp(T4kK448K`Z&B_&$D)rczoQ%i|s#zV5uH3(JLR!r?R&W{lf{ zNZc093KY1;WuEo7c9nGreVt&cTfT_EjR3YT34vhZ60swZWW&l;8TAn zvi%04XM^WWYzTX@={DH1ht8;M7%6k6F0+EnfN=MSwGPx{Vsyh)E6nsM1>pjP)gq_g za%E27bAYGeo_ioi$S%PU;Iu8UxhYcV82*)AHg+91!G4 zyibCe)2^&TK(&&feBfy+N13{nx(`cb*e71z_bs>N#G1fU6$4ba;)jUGdck97!P|+p z-HFJYf(omVnK}DUi2`U->m3GN9-S_&dWThH;vBA_S`=!rzA#H)Q>8rSb@GDBN(<@8 zTX`XUm5`50u!c0AsFFwz?k>PnSpZI_IPR8{BtogY!D^=!BUvaCM zTAJkR6!QU3au>zCaI3al&}e6J;}`grPo1L&6tm^v96s$&9;tj`$YuSU_TxNOP@)N? z5L9=iBh$x-gXwsj-ui=Lfo%z!_>i`-HPGX6n)lI*ilwolnqlfrZX8c!`5@Fi@j-;~ zf4BKqj*KTUbjIM=w|G4sf;?wu;=T(?7Ll72vMdt*$)srE*lmSY8$hd*;G!LfK#-2i zTa;5X@&>KkD)|_&j_!UJ06G<2xCW%DGmTb0@lk8INiH@0k3a|hO8dR*h$naMo@=hB zqi&+7*9t!}0G*(sPFwWwn|lNPZLmiUGywrV+CKQv`kVwyjf0_;UR-QpNj&a#e6oGA zwMZrr>h|7RmPX<62|Etq6U>q5)$;E1|Cq@LzQDSZWgb z2LdgFDvbyL1s7}ORYQOs`m5tQ{v4iI|&89yVul7uC4!9Y;Fhplnd+ zeqv6^@m}ZP#2dLl1V@mD^z&-RkGtQMhZ3V_r(Mi4kHZ;vo1(a&8?{5Ow6*H+Z}wwd zKmwHn+=WhG2Ag&a(L94Ll=|vrV^q0%w|k(Uhs*bv+Unn}R$jjsGs>N`uA^a*yV`k3 zEATeQ#6K|wHNHS2RKav3#SU7J@Qlh1uyH#?coGDr08 zyXAQqXuIrF!X7gdrVYK&piQYr(6x|vRc*nFodmKMD+vUpQuZJmY<^B^S8!2H!Lj=& z&?$i8*}1T4i#Dp}$m+ddy}Zjg2Svf=qnR0YLu1O)i1d-Ud0{n@hGSJ*kMaTit?kl- z10(fr25pnS1`n3jk{8J{E|@@DY5Fm>NeKj~HQhZv&Qj?3>`B8wqE&3+$CjA0041nW zVgeA-VESqqtHDGLoB)}R(dYT89{DDIM5vGL^3FDU_z+5N!$K)%K6P!YbauWX8}P(l zG3Jz)w5Ny`)=#MzV`|tVc6Ca64gLT(9j48x}vww>Axrn=dab zB}A9#70~^6d5|2%a2gMi2cXJ;-~KsqzYg55;|F1AktiKdnev?;0;(|$@qDoI02G(- z+lvQY4g$+Hmq|3KDqt0Y$N|ssq#nSk$80HGI6d-}58;U>8g$$pjvnhV(e|Pq<|+FbNd6wPwUOLP6@}k7;J;rmop;y<4IOHFP(G z)%8u}HT{l7Z_nqv3}6On zexDY=B=Wd@vSgJZ_Lq?yY;t<@{vtJ+`&%w`lIfklrTjs|)jiO8ksk=hVO~6YBCc!= z?`ad~_mGzsiC?X&koX7*NdgkIK`woU9C(tIj`j#)ig4?@>^YTUSxf^Jta*UaKKu@r zkWCys|Fz-!z46jKG!sUof0vKm8|JNTxV84`>Z+wW?qv{sNo$X$X}b-%(#Fb4Wqp0(tKYlEJrVAj?UE_6vT)aV*oDW;1z|thps@K);84 zG5U{gK3t5Eiq;%G?a2Y$aEp^_vz$( z`8gVjR+7#QWKlrxduWPY62!BBgT%qx{e6Pfk}sB$z9OY(uM%*M0uaQkn9ujK!G$4p zIfa>$eG7py5Y7K-t_p4qtSNsoL`_JnXA@ZtV6~`p=7GaZ$TX zmXzm~o32-#^M&`nit}Jt|D6=)9t#@|l#ddnaGulizpc|F!+mOTrK~IH^!xe9SEd*U zPs~xNf#7cCN)5=gm_psw}R5t)*%}mMYIo;P|q;o2llrd}(7=c>Pryui`Chja5v1 zDmy=>&dl^wkNe4cmfr<+fKM_11sncfY0@uPY~<7J7M1=E78Osec0Cl;9e1||Gi<1I z0^_)=;VjSk*=+Y`6*h36(O>VkIvvdtpN=%daplP8nP-O214l6Pn_;jW3teZ6n`Mcs zx5dq}#5uutJ@^}Dsh{OmX~JuX4YC3;zfi_oCl;S*ij(ky)jSR(+!&9v=cVU1g3jCFMDraX5wRxv%JBvS1ZKc6w)jHw(@Gg^{rz{q z*57~MX!xDsdN+?fOqK5zzBR(MYQNvghq3HqYQzx_Te@dN&~1nR#7-UW!5p;Y*tDuk-=(*R$*g z4sXRPz^oXefXQZY&k6W z@8P!fU*WYS0F^I#Lr%VFI`=2$cJIPZd&N)gegbBQXy495Obv8yZ?8IkGVcxE%H_xY zmDFUV^0)R1b9LD!`4xF#v$0nF1}$qpAe zn!f=)N6tB4l(~UDdfpb<7%?HTQp%&pH_++IhPucmzg`**N~YJPru`J0)xcfFaus-x z8wNm=TpMcqvLJE!(rAQ(2jj{xAK2h)569X0NYY7(Sw~jZhUalRN?bQFht5bMJr0Vq zC$MFI_0FPU63_#1cpcj-jVoWeU*43KWa8d_p@AOg&vLIcZ$m}wd9Csz3irQcgz?8P zig}T8sx-3?ymiEDT1O%2Zt#I_eX}mx(;FBtGZd><%{Ws0c0G}rgG7Z$Iyf3$2Rgok z^0{^OJ4^jVJ-fPI?(axj9Ry&?*S$%+l;Hki1d0E^!YkOOIQ@Lxaj){a3hTMsd zJ%!#^=40Sla&E@igYsC{`G?%_g?aiyfzyzagbqP}c+p522jCL}%k(f=U3m(AH4Xh| zvjPZ~EJ+p*7A1;$5+uNrqaaKW=IX#)qz1Z%#QnJ^irsAC1u?pxf%g%tffcU35NZu+ zil$OYjG5~CEaC96Sm=0Yu=I*N0$o5ji2diVE*r_(5)8K4vRj!K8i?dtSxJ7uTFRz7 z457%!aL`wh=fbRd4(T3ua*|GE8GQCYJs*PQpxEk@w=SdSEee!q9VvAMc} zPE-g7CgYk2Db3OAz88e~dRmA`kWe7pjbak8KGw$}Q(uZ4sIXvt__5 zp43n9R`OH|!TD5>)-36L`%*G;6oemc4f_H%4{OE#SiU8O6}m$UFBWG zaLxdGR=$5)1?Q|147<@*tPTYSxFknf9sSe->sGQC&Q=88es6NOA7*-a`bR~=DjX(0%ZgWxYOfM@kT*VMbRL3@jk}hVJ z#z|SFu$D-*PX9jcek?ND5o1{qY|7j+(Ni(H!4vJK!K`4iBz=5i+}zF}Ggv{kjXRHz znfX>{`Do9PR+aGtBj13sC0piO&E&6v+YU8j&z-#cz6r*>70Z+2lA&Yv!_DMcYiJjk zR$qWF5GuPmK1+PZg1vSwWGW+1boAoTSYDEnNy|zEydt{+)4#3;y9>!8ucS)N*m*@G zy(2;u#ZgW}o(>jN#T#8&uqA~}21$mF(-=!vKS|{hA-Tk~9PV({|MVbbja462i{m zgj(%^Dr@G`a5IK%oOe&bJegPFg#bMlK75Ep; zYd%ldvZv(MW|cGUylEVCewFyx=1UF2=*ed0w4W(n<;$~6lm=66{ImlY$S)C_ryqi; zYTX#A6#Xc0TT`KiWJ4kI+{E*S6i`oA9%l-d~QiUn=8cjTn)0jxSqNn$nc9Eap!(oaOd~B zUvOv_Thgy|PulN&uAt80M#TeT>cy>-asp zhAsM$-iAF|L7a}ive+7beN)|2P!3;K?uB_^ zerYAs$7^K5vdK>x=1~(~8n*u!jA|QX;$ozof_;EfpQuKV_(cEdlAcVTn{U~qBkZ;X z5PZ0aK*j$oNth}J@6)SDiWL0jh!Uh|Bbg*c5#SZso$(kFmP-yxts(WM#6hhCI~REm zs!umVaT9XY&RlN8&H%{}$GQT;nii_43n+I6r0%B#crT;E?*; zF91^nMap{=TU(MvN*F_)P(R~HYB48=xMPWGl{$pf1akc}up2e~p=q>A(>$v}L7K9@F<2#$S7**9XIVCwyi_w^!ZZLg5Y^AFYEIrg6gMNSB%b8$+ zy{lA;Tm-uVc}n1YAtx^AI~otW#2sR=8S_COkL0?YAI%~Rv7c%~B$q)3MkCpLQm-@X`C=KwfW!f_ut2dv8`bg#r zTnP1z*E}P~G5CTwuP|8bZbIBLPV>EwmICFt}=+QhJu^+eSBv|@e7Z{lNB4fz8Wa~Ew7R6_x&sSi8)`{o(=pjlzcJE+oZCNI+|xm~!C%_iL`a_UUL3aE4Hhj^>t}FIiM>Sk6|uwE^u6X%LynM2V>=LI zaJ?|Bqd6d$%J)2l1n-rFY0FgR$dFtP$SXbdYSluxa}|x^LYAqm3p;StEpzoNq@5I; z;%8@_A-d?T`y7CJJDXC{X#MJ;wbYXPshcg-N?TiRY(X^53-%IAK-vncLi(!8jq>`E zl*4Oi79&-E!zD8aE}8PyxjLW~>*oo#F8mX6cCajKAJWQTit5zd#8>QF1-U|SxkN|S z0-a;`(ivQBluFV!_-iiw0f{5SC{ZV+k{Xg`ht3F$#bCjpp4R%sD6Q75J#}JWk{vH z7UcVzrQvxR)-@)my!dY&%!cGPSD!d3mku;f_ zKX0AnDNe2ciLXrljFyU<)uJHg`Gkyt49Ls%8EQO^C*whHI;zlkj3D5i-E;4*^gwjl z8|X^#5YX=HE=PLYD<3&I+9w$ush6snHx)kHj) z!nP~A9Y*Akd!<{7#nZ*a+{RB|HG{S}>M9nC=~*$!C(}u`sCtv7e?ioHTuPZ-vd`NtIu&B1!gu%3Q{aXn*L&%StEtBJt+o?(5@ zus*LVzmvuUh27_?O;Efzd_*ERc`pRyTe@0AazmV$E6d!|9jp-&KJaoxcr6{xAHj2R zRvPF(^1a?oO?uuvLk4b=#ucbCArpq-na=Z@ckiiQNz(~`-iN{20;);CQkDmY<0|(_ zM?a;-<-4ctwfE99Ml86~L3Z8HFd?|UveX7fgC!oDtr$3DE0r>uK{hp4ST4~}9um}i z@Mp%g$7P*E(;)6j%k7D@T^gO4b%qqM)zw21)k@#yBONA?J4N25Sz8cv9@C@9mN7Dk z9#IATQfKlQv2oGBMy*&qmkoNvrrpb|`=OX#k#Mr)71=>IJ7~4iO|FK$DTG@J6g1Ud zjfP{4xWbs6;dl(rCJbme;^ zgU9*Ufa&t!Dc0KvY({=SCp&cYxdkJGIr<-55GJ|Z;m*aYo$#7B@V_9pHk1FLhyRh_ z-rEWDuu$8)M%;eYNW&c6?WHSq|Ez9^6A(FSW?!9mMG%&)#K?~(pVN?(Lw*KGgAX)uk;eUNw{|&ya zu3TKM{UGULaYZUoMK$e%j>DX$B1^~J%N6pBt#ge1i{a!TrVg{_?si^nzuiAMeY5>z z=k$2*A04w0Pgb9<##?Q_Ju$-T(T^QMp(pWHZ;v}ivs>*P?H%tOOS|^7c&nebkALD} zC5`s#+LI;tr&%$J-Ohf;Fe7f5?Nu7XBe-18(`kQV9^FeQ@fwsqa=8@DwL5~WD+R0m zy$`(J{#7kef`7N3Y>p}9MWIyJ~H_?K{MuMHG-pOGf$>U4yFVZh0`JgIx_$xK3G<*rs~G1ES46gb9(}H zkD1;A>%UmzCEvu{SP3rIGNmc9FzTww>veDsT2XA3nbkdi;8OX(kD))*X4|!SRn=zIwfP}v z<7JojM&fcgdjmIsRyQ{rh9QF;ySLV?1K}@Yu#hTA^cO9+8BJuBg~QXss#^JAxYF=D zZWv}X{~X^kfxfEGRMpV=Qj~$4JMk*L1#7Ux$-2@KGU$hR+u*Ou58PQ+ll2a&I`Hlz z+Y@3Ck<7KkEuv57FuA7a57r4&z9eu>$y}Nv@UG1Vd2yNbY_z|)lb!d6>4bc!fNXHp zvz#>DQUJig!Guj&4y>T*+{?Q86(rEazMx(jBo8_d6yc04$qM43H*LrS*Ypqd!_8!^ zbh4_}%HOgWq4amt7liZ`brQKhd=nI1HmG$tbIvQtCs@vlsp(_h(me$&Fyk69D$B^J zXr+3QWkJBPW@(z%p5=RU6XTi{E|mi)SisKJgVA*%QF7^9#*(034z1;Q;b1+cmm?ZBdPj)q6LBuoBA zu!XysVn~-hIiuYlPF*_?Z3zB(IJMe8$nNs#-RgUZ_6MI-1Hb#hCG7b_c%1k?d(r=Y zSZ4PR#{vIg+2TKt19o1B+`Ngyc<}xKj)KqKr*}D+?37`Vo@{RZ;hV4V@x%7}@AM1O zM!J18D{##YU^tBgr{Vd}0Te~0eT|WS;gnzluHq;#ECStbi*7nH+ZHU>N&@_hQ&$nf z<%5yg60qe$dO*m4cQ%CbasxJrrwK^g{Vas$!J$nWPA341@F|>MK;g{F8B`!=mOlcm zgPyQ%N2~o%sUVT8Q4?)pWkQz&J7!6pVd;#pK4Fo0nW8~(QayM6kv$(kcu8L#8mc$W zu7)4Y?{Y|krGPwlC*=4o`9vg}Vm??#iUJyrb4k!lOWqr1#DilYHM(ii5H$N0a816c zxt$1t_Kc<|$(s};e`T0WlEw6_y9nr%b%$3Ol-xBB~l8cQqLPKkub^P~(nOO(fuPWs$?bhZhLu?72;v97HbX-f(zj2@U89Cl90*6;i{8 zAD%gS!G8(O;6E3=zy6=)#x&vkaMUpjQW8oCpAOQiObB6ye#)QMW7ae5Ex)Xn z#2l7QK>0Vl3R2)e&!rUpQwr;nhh(sU@2e;;>==Z3!Lz0%-1ZlUz$HiD1*QMQZ(^)H z&N8ToR+4c1=1@5RMn~glmb`>8Iuv|5)Ba+zbJW>B=_Ehz9i6=0-cL@pU+#C3UJhoU{3G!a z(@`&_u&*v|-c*c2>?KTFih<3e(Rer-=c&hE6w@x)iO#3}R@etJfg*I$dpfrmeea`6 zbr5*&INhNR-*DUkaY54S3hY!DI0tqL5pH2=1ceq?=66H_7@;o`oNP18OaE(eU!-WB zdRPqHn`7D+v25}(E%AD_0xGi;+YfUK(3(bSy6#-{!cYs~UFf5x>D3i18)km){KNnbQ)6_)@Y=#$Fs zuvpL3%kB-INS2hQ^r-V{@7L44gWb-ro#S=YnH4GQX=NatNqxb#^St{B+)w-6!_J*e9C1vvO3O>vV-@Nm1< zOqELoK;)cgm8gN?hcu{&B{H$iH$e4bE%k8XeA6ZuX|*1594WYH7$smkK|fC0 zv9hw_h~HvZC@)61OXJc5lMNlnZdc&ZT%+~0NsE)=(2z1icWC6`?wQ>fex`Ai-X!;W zO@rzcAG2`2W_oHXt=bFs0Tf?Y56nz?qYVj_)!Z1x;6F?4RS0r{KFM-oAZS~vRuic8 zM3@wm1;1`>hVZL*npa8uRHvw~9z!J}TCpE~_@Vh#`yC$Mcj4y0=ZUX}9r(SQ^I1@s zlyKc<83_7qR3jC2_b9^WY7#l&+EO!!q*EAsHI5v03H-9nbJ!3j)8;R*@-s=~3nKl* zjjE|#gXuAS%s^NJvJAj=&nhX!q7)YFfG~;zoqgng^w% zbB^`3){(GtFq~013~|1|&1)s2HS@pa07#Oktpp1OHuhUYL^)~}Kw>O`@{%J%kj$4H znpRJ*a*50J8Dq6P;HQRWAtyyFrR1vx3vTp+swG)v^FWB}{%KxnrtUnKdhn4R1T6$m z%>?GO84NTb8vEcaCr3Eh&w6)z{~^ApRGLK z73=SL07*c$zu|U%J?R`BZ11m^yL@t8BH0;`crM=i`^vq) zgGtVI+C6LW(nm35=70_k4?63S-M!-;f;-GT3t%&Un$j6JEpp-F|@1!uSAm znLgV%5ARnVOBEkD&lcOIJKJ$^cM&X{G9LIQ4t)J9S8h5Wwy*d9>&1I3v;3CpcRC(k z=k@DWI$}rAgLoWeJc<4z~4~lTkzetc=wy5I<{|%TWWB67WCGfrp z9@)I5|3%9~-~TpCW0O~Z{j&73Nt*X($PiZBo9<$BmBJR2!w!anOa$27&dK)PK3+JI zK9&;5l9!2Y^9rK*bQ?yYpxMsh{@d3F$GRnksPH|e5bUX~dDwEu?z`)fUNoC` z+e=!s_+H*^`H@M4K=%JS#I!^BHn@2r;O>Z?)kB>QAUnv#fMTVwK*EdUpNscamWqEa zF4Bt8>O~@zdB9eq{^RfrY`xQw@@5mKG;p$D8y)_MLD$Y~$)@X1djs^-t@4nYWmHH1 zk`&dKV&c2NLGf4fKm!lHAQ<;5-?0&tN#oq0q4kGAZ{w)#+PXWu3=$hq8qyJzA@&N6 zq9=k(SmgprL+^ylIXC!G&3Z~J;+Ydbm+90f&4Kj=je(g1&ScCB+$2{u)OJErZCSY|?Bs)q5$ zG>3d)ekH9iFnpn;Gefr%QJHZ-HuoYIlybfT4)b1cio#N)`8rZXnGXxcXf9@mAzoqR4UCaT_JG0gp??pO<{6pcmP@wJ{>k`Qo*1vKfHGLp$vTPVovnr zV#%GkTZM+|lZt#VN6II-Ebrjq@~1E)z7(|+NiygsT9nzS@!6e#|JZ9RjGwPI9TI4-w0Cw0-cm(}V5T9dw2@jKz%R zhrjIY+V&O!t8Q`#SQ~%LsK5>j3|QsiMRKn|4rnM*K~bi|nVhu3w`x|%>n%E&Tc^2M z-b&q)y@TSq=F?uT8@;9#_&F!b!t)f)g=VUiIaLgn;1rA&mPW?O4oc=X#qW4E0NzLq zZ>gb7=(QrkXy;}$#(YTZ?q6x-ew}{Eq;bQ;Q;TNSS)+_^Dr=4*-5@h?c==~dMJuwy zqEvkU4ARmpp0GYF5T~tw-Ka)!Xyg#ycWaVytv5HLdOJ%*&_-F=oV1d2Hhz0RhMrw) zFF68LB`?}sKZ-AyT*YuT*_(e+TZvm%!ms?juV9?g;oWX-o_{(1yvgu5+C|KG7B3*Pw%35Ct68F}YSb>=H8 zmGxw|ZILUmL_8w%gCv60uG6-is~rWexdID-GCb*x8N>kGXRflz<*+AW$H#mOjy@Eo z9wzHfCzI@IgmF>G|4X5H^ze5@m=&2*oTkp$4fQc8K_y9Wz>?cxS9nr6#xC@FS{jWG zDL|hE2P=lL3n$28YEY8fSEs$5;bsL;oF8`SgD3#S9IyiKD*$t62dtR)6^c7w=76QJ zT`^O_M*Y|yo|)}m8qqH;cgrM8y)&DXH{up0KVE@5uN<8(50DkSlo8UFv_q>~)LYL0 zExa0lc%jm!l;EMna^&OPzsg-J>|H9%+O!I+cYd@QV@_!ehD0 zMSo9NWSd}wHpE7Q+cQiKWNUlDvd=D~`KBa|Q~XOL`J?T-#1x$IDyAB6Z9bFt><3*x{R6ch_Z5H*{UeC0{(^9f9p zdqv4h3VyBFq%ZeId1Haial4565(Kq0>8alB43_!cNG$Wxpgj&txcpiL9$-)q5- zxcR_V>U8xSu7~a!5{g5VrhIQ>@8jR+vz$RG;QnaAX zh2)dY(}#XPpEfriY%2Y`8>W>jWgp;+-|3{05!}Bh?+qgb?{tLKNyVI*H zo4jMj8o~OQ9f0-0Zob;ZeZU{49YRHwY3y9ea6YGV%|93Kk@6om@C$slaEW<$JpZ1+ zgyea7BY{_KlVp4Um+jw<8?c$pzrw#S%%Hp$uyTKee@bs~uIh=JMacmuHY!#i(XB%W zOxr}dA+uZdh!B-0Xs+mAB=Il%H)9I7h2G!f4iGX>TZQwDqco~E>@<@;)SJoj2DyZWkR zQW#O{rxoCGmhc}Eb;cQ9J&4uJx??yQNE)2x3xx~p7%wqiv%cOtJE%GCu^Fq0IM5wl zjSQ2Ih36qUO;7tOqWZ9zlwWFIjyuefY61{iZ|=?4x!8ymxtdQcF}F9bZb+K zU~Kiyi|UTCevA+9{c(D)c;J}T-7}AGZPACgtCv)JJ|sd#u)?Is+Zst?QQXQ{kdQO* zYB;`f8uXIJ3)5UxpgE5txUoG&I*ieMZdRplCq`nzINMoCxLhVAu6TPT>9@PlaKM_P zAvJNfYCw^|H_|XTpS(!g&A^3!bTa(l^M?B6_9$;_HZ6R&ymdoYR3iX6(_xkXtjz&H zao-*b#KL#zq8;Owv_EhCdnM9oeY3nTYn|h80=0fD#h%x+c2FECQ$O&dbnszz3$s2& zeJeh3b2W0dpjj>D1lBYTQw~Bgc-yd-b^GZ!JN;;`)J8KoOA9RD5Us@Koi@~3&tIiS zDT_mIAdaq$Xn9NO;F+q^U7F6%Fq_I#TyNr&GM<0*QQn4M>O9+7AxetSo5rHjEEo*O z-l$Nh#B`5QIL(4(m^F@jpY9cC`+|n>Z#Giy_TI7iJjb-|85#NB z-;x|uKaq$QWS-#)WL*B3r)0s&%=VB`V{(~~du5}@30nrvAoB|H{T~fbI73~^ zo(yHE$R$y@OLD%0&w)J$4I(iUQ9c2MFyxCihoqN{b#4kSF|sqcaU9B{N68NRt382a z7%C)MXKLjsH<|)VBj5;MBdj;h39#&?g!2&ql+c4qB zTr<+C@K%pwk8=B3wDI3iU(=(ps5oY@+AOQxoG6j#~?S`GOlp9HxN8`ZE6RQ z(5nIKC{krD-?MtYw6h?n%%6>Qp`5E@t{CK+81Bjz5imAjS+Zg_gIt|9i>FTd;brDj zjkydTS*5B{I=(SmcLhbmz>ip19=Nf`M#?kf$)#2#)ghOdrc{uS`OKvw#5>J#Z4VRi z^fe5FKmprlQ{Eqr4F6zu)Zp%AR+#R~$zo$s-eQGpaSiY=5ONL@t|mUNO4l9qu@4|O z7w2+B0qM4}FqfzN9&$tM_2heW0F=mWVEsYN>%?1>NPj@xx%zufE>YzEM5%_o#{feK zfC!QiNj<_rNCB3}#j=3<(wgf&?vJ~#`qU7!*s8yk z=ihGCHOP5a-S*kQv+VxfYCroDRMlf}f82f9y5rn%wy}lV!8fnJ?b7)`=UqJ2YvT?F zyVRGk)E`4t383`~AX_eR+i~Z|*PVlt3YeZU-8Ye3Xkwe_66bz{%_Cs- zo8||`mG{SOD&@az3fS7RN$Xy>t@f(w$d|HPS+d~TmF2X%^R6XGtZoql`7H_3=lN>^ z$~nClN&qT7a2#-`Aq%BQ6dUieU~oUQo7QmLvrV(}8fSGLn=&^TzKyYk+8;#?my#a) z%0f@ySc69MZfKEpr{ipy(^YxLhyBhOqyL>L|JgCl$EBvi@BY=u8ZVO7 z&~avt<$;hV)I|UPU}?lppJ!CLI-!UYz^_t~g6=wMIF>0%N~mwF96XL_!kX`q*i56 zc@MEBoSz>Z{-P;SHfoHTaUId8zg1nfQ37emBNx|L z^hzhG15r!U%Hak!=EC>9uU3p$asZ=2MMo+8!b{|+_y0T}q!u(_GcqUId*bPhHA*i^7+ z*KM(ZWrvb`y_PdY-NOt{_j=7_IT=p}$%AorHqHCJ2P*JFX2QNV!A#;$!}%p8Wtlx? z3PI%8>K(8)BHP=B`|)peml6=-#*!nupJ*MMej=wqkb9=l%p{KvSBTI7&VD#<7Xz+) z9G1&;s+mwR8`_cy$3U|cdlDv~ zDDT>)iv%mb1fJS_JHR=gY@7G)tef#?gI)uNspxN^CbR1;kK(#aUCZLjwBJLYr5ZrLd3xcI`8WVa!#xUwD; zq%!-1=|QpLE(TA7--P+^`a;y)Baflu0cIN*9Sw&Q5kt;)v!WZP>}W@y;Fbdx_e{f# ziZx?PljPH#z4u21D6B=21=kH5yZ&-xsGty85I3! z2ogJ*;g$2*;%#B#VpUYnuO*!OhA$zMFH-8O}3`9-XlB;<#!!ntqm^yOHpKSMe@{ zw(K7a+6XgEZ;j!Gv}?Em0ZkATnTV%m50D!@xrS8bFY)O+WhpgcEwWs^p;M{L=^b@E zv0`(@^{zgv2ZGw}OrCXy=M^1n&JV-;!|mew91L;SV*ON}5X0n+Z(a3q?4pv9&~8)_ z1G_z#D>BP)FL>oB!3d^1xv?pTsAw$j;)>^)3C)@fS+J#+w|3Su)7&j&q&8P&jzKMz z?Cj2T4Bkmht28a8b_8Bb6pe@pXAxO(K*HmGyWuS^5FsdAg7q@ zhOyE*f34xV=iF-nBWi(683=~vAUyO9RvpAo%XU;G8;4Q35RPPb-Ee~i!5f9?(z{pt zonN<)j<$b$zwYJh3Az)JCa?U4c;h!QC(yu$EZJ_rG4gWQ?-iI_c$gdzNV83e;*^g6 zfjkpX^g;b@t`5Ii)p!}^2%7`0fx!4T;>Hl+$)Yz9s?aq z!~C3X68ju8fmiy zf17{0@K3L4XSeMq{X%zFo1>X1+!Pb`a;$yfiqle==mc^gFHklz_?0Vr#V90lu0SED z&lA>FS0Xghu5&zXTm%b&BSu4aEH+h5U~P&dWbd!0kltDxdGmqfqEv$K2s!C0Xz*!F z=Izeo->2F5Hr~nf=$xN(Dat|uS^$QeAO+{uwBN7zwj8`tZ{TlNT*h*D&XK#^!!pey z_|LizjaWppsFp^%MfEmmX>@!$7!Gc)Ji4iZd+bVzb8|uM1I})n$>~aRs4`T+M+>49 zxHIW!1gs1@qz)$e#dJ7@tZaWwGlQ24ToWGO_l8|^(}pSJD4pYd7Q;7YP5&$r!4dpt zJy>deBM<`u3&d;=aWptnyIP#mb2Kbq5lUIQC2oNrn+xSX^3kW)22Dm)X=iU3r zhS3{M)CF&4q0R zMk4mj%|Gx$GJ=3VJD)EXF^Wbv^E!)UXf)z9r*tK8#=(y;^ceMm2}K6mk@9 zKfU~Op;C;O`p@IBGcB&qw?RVkWw>=)V)ta-cDK6$*r8UgL<8a15ZNfhBKFqdek$7{ ziXHULli~KD#F0L7Mc)_Ghi8khgNrFLzGsX6<*;*^bwAL-mHf;yycHHojI=e*!KO?h zi-08E;TTGDKunA+9HB&B6j5d+a|l#MS~Ent=~IAs+RH|h%hMq$cM`Bm1}kXOJ4DSH zl3F*ya*kpQr~g9P|5ZL(UKXV$_Z_}41^v4I>veiV0*tb^VW2tXQsCshBwOUUSE(_W zt$=}~zAQwjB=(8-sn^@THtgSExP|}P;VWnE=yKbol%9d9FTN!9dk@=w0+r7Te}P4E zO5*58VSh(Wt0At_7GfsRhNA;ZBmD22rkP5^3L*?bTHcCcl$|v<0`j6zK|h{pph?uH zqDhcS=93^XI$*|LK~V}g;|Y$EO>`5glx$EMe*5Rd{W@^Jjvpwy%u&Y9B|0qHmY(s8 zt=JsNaBY5yrEQ1N{g_QCJd|mlzgY`G9^28UXmAo&01?&~U0XP^-4a!bV&^dUNXZPd zz6QLIe={@dMDigY0kN83DfVj{_CcW8b0A#orB6-BF$jSt3lJs=A6?$U_@s69z-C)4 z3}e&1Y`{3gsSoas2aN|W5*Um)Z0x^5TCPIhs9iH?cT~~t&k)`YHY~OK9Kx$;_abPw zbGUzauwHK0Dz$t4dOOnYVbJc){@dgA$aj~5cE=~%N3nLxLA%#`2LQ0t?mxouZ69?` zBJKXUY8t9`ox@jZT~xzG(=O^UvLPW ztWmA1#h}P8G+kGJ+qU0PTffA#Bi26Dpgej~L0yHUE=~ufa~~9tC5mI$tn_{PuRa-O z5t8NPlLh1jeByuDxog%^t9oWAfETVX3zUbcPIw=iD;)I~AWBct8+Jk%fGh)5zS^AV zQz!Y1&-`;W7Q~PsK6*37CS%9?9P3AM@%(;sa}B&@Af^kl{|bdN6FfXJQ&^)_@doIk z%>qb|D~xKeGV<$Vk4o&6SaMRF4Yx&Q1l6c}BN zn@%Ry>9Z$reM*;7QtpPAE4*pgh0h*53(neHkvk2%o6UY!hNF?3bp7QSB%;EB1f}It z!bcw=_+)V9g5pfE@;1AiwWdOPcr(nf01(}|?v5|;KVnX$>lqn}^~lwX1F@HLl?f(s zb`Iw<;AO7p3@!|Fx$X@Y2FuaC@T&^$B_0j`;et9Om@5ac6#?Akut8K?|7-q z{ydsiV))ewnf$psIrlJU#G@%?MwG;&U@L1XkKe#I!G6U%K7Q&cnJ{jr;alw|OL@Vg zLWOPK@*p*Z0p!Fu`#&9v^8NMp$<9w&pv6=)U^y7Gt_N87k&$SjDh3*r@~crl@1i9M z-Y=i$eaIrAlC@SX6r4*x$Cwv919AcBSq$$5Di(1Wji{{>TUY@8s!Xo07DTq6UBwWH z3lgOVJSden+`dR*@Q`mCy#)J#53Jql<7`4b90KZ{XbHeDav(qef5ROjcp_NkQrnca zOa%Bpb;TDDP4o(xE*>*sKa`Y<+{G3GqeP#?-kms%AFtp6~^-fTPmOh$tFE2~3%D~hEc}k?x(H*M2~%NGr= z#Rmwz2Jv2^kpe6j?8;oloV+wdL6S4_weDp#VL?b8Xi+M;QRFkBYD~+qmqG4q%o^qK zjhqkxYVF|exKgF?XH#qKp^L5NRie_^ed$T^kV7bHax5UIii|C>lB76*6zVLzd(5g; zoS;f?%uj+p(Hx$*avvB+1}o%ik`XfAnGa5F5m0*C#;5m!r)%#O_0+e72DKCg_174v z2k#zuQZ{pP`NrlzXH}yK zZ?J5cer;|UDbmwk!0P}0yVghGp1*@FqXLx=79Z%>K+S&teKThVhTnhR$l+g43ljrF zBl`XK_v>CW%2Cd*SZOnB2%qO4ZRvHQUIz-E(sBnYl|0-`)--U{Yq<@B{|^{^?rWJW zh7f{4l@TJBNa=H;|KFvl%*R*=S!kYyPQFRFp7DY2}fiYe)7 zGlcfKw^SjFO%H~y)yaK`3HGxAm!>TLb$b?;`wc^_Me4VN6^7eldddR&Xw)hP*F*?{ zp|D9%oyQN&@R_OF4DF!{>(}LI_j$W28{SBZK5Rn^Yh1FKtekJW{26T}i{>47UC2Bw zz0h4TnwUFG$sJp+uUjct7jKcG3sg5}6dR(W_c{L=6Rc(p41zYiYrU^dwZ6}}a6{c3WWhKa~#$+eM) z(%jKPv&&HDr*S_Wy;JM|9+W06y+4)y9}bp2{c0p%i(&wniX)~pw>zO!Lrs4yb z^Y~-V0PU(xjvJ6db>ecZdP0F=(}gW#S48v#_dLSbYqRB|V_K2}tus8g?0z0dm1jp7 zT%6mhJ%H&c0BMd&!^e-zx#My9FL4;0e3XB0yTXB^P4+V#ng8D$IUq`wb&=R;k}+#( zCWEvUephkW&Oe^KGVuNK7Q4)=GiE2u<7(i*zT0e2(+yalrXS!tt;zBoQ9fR z_^G`9;OAlp&Y-jrr|f=wI-E{ow+$!OgpZgz5EiFZKWW?*2g#xq{j#(c3?7<)x5)@< z_Qbn!(g2vnXEclXL)H9{9@O3-pEP*yN3i!T4-;C+eT4cB2maoEOi)|DTmkB%9HtVQ zt(FBX31d8JyBjivO@>;(1akHLO1jRkz*1tL4g#Hyn$a&~AYREe{bw`zbM-SH5uiqI z#@WZjr5rl9Gzm>7K$dviVRG$&3qoM8^MQ55(ZR>kNHI49iWJC8jvzFpT&tU!XK2XWGZ+$X7RTs^K?j`d-60#87xfRe{P18QdtME;Yh63l!oFy02bes+*ndHr9<3lY%3S&QkIr5LXbgHS(0v)BD5ZQmg|qTV>@XlcCj}mTD0*}W zoQ>++BNbO#bp=`+R0#g%s8CRz=jK3S8Iz!#R(b7mTo)BhTE&aes_hlH3Yr^JaX6uK z3BD3+Im`OP!39P?L>=HqB7D03L9_}KKFB9ICIWI^DzY<4u)^R$@aKV=yW@$p*ve1sok<4yd>U zy}-5$=$}CLvoQY-AJ=p=8V@1lrps}X;Lb3{QoYj=lt{2n40fCtIkkmx4iGER-~l!R z{nQ;eJs&g?Oxc1v^K~%R@2Gb(>PfRe)R+}g%#*Fwvt|AW-4;32PJNoIs)%vuAd)c~ z_~olN{P`D+sBu(MpleUDugG`j1)hJ+Z)@Jch$iMMD7?xfWUbD^i8NkBeF^hrB)C9}YQwtK$=lLd_)YULqOnPFit z#{B!;CN}gqOFK-JyUwnH>$*|yIR_sM{hJl5Ek7YE?7q20-<0KcFP7B|gW3r^aGDhh zM)(He$dFxi(W?lTIkF)!I!H!X#f0|@>zByA{_uG1@YO4D8-uRR+NxMFM!9q`X|5R{ z`X|_D%j0XvM&~(E>u!Qe)fefj>IJadmi;itFP!GeU~APXU}g@}KdyMB1IAs+tfon7 zor=Dk<&Pw$+8+)-q?cxC_y|UxtuNHHhslrw2i_1>v5_xJH6^Q}tLy!ECB{;?c*ES3 zL-X@`7!u#jl_EjJiHwB_U`=M1Qk=N!XjdtkV*s6zbuS35^wW+V9{z3nr_S~+y25g% zv34`r*hrqOHA^8~!KNUN$2NU8p)b0MIZ?Ul(#RKbWjf#`)D1pM3SVcj|S! zKPwhzOvJ)24ps-VT&-Qxn8>y6)|8)f_;x90!x9vXkAyCZ1kXag7p@FxA|V=QS%s?m zc6N$fv?X+{`=3p;h~oDkvq>?wRfslA*ha#%SxdF@!xsJZCEyibA3WPwi z#8A6QOgrL6E~#NK(>F>JEI}0Jb9pz%0i&h`YsF257a8VK!2I7C#dTxe13XY;19P%s z1bnWK8YnSxtUT8nW~9HsCM6XJ)I}UT8hUD$#?t7>h<{GQLJ1u(ftO67y;VHlr5O5toe zP6tHLdw4;aiNTseVgf)KwJ3w3rvc)eqP)-zR$4UmlD9}AWV*F1mH&c`W<-Zlm%W?| zT{3!*U&-VWc3yHxfKeBq*xh#R6N{ElLy`puQVr%pSiREf5FWX9hzFI_xdDYK7cT&(gOXNmAP zCb%Bhcbqm#_|1VNpC)g7ru7II)UeBR2_hR{sY#16Ga?+N%keLO6~3mf?Q=@?WSch} z@9aR~B_l^zoW{oa1>{es{E@{_wHRkth(1s>)6lf(U_zkSlRO~!NOa(Wo*4Q&#Qeh= zeD)F2NpcoOUZo5(mzp(jIUkGk+@?m8amdv4bm9I>2~06PQ~vEkNJLQ#naacYGF^)N zjBnO^*ca%MBGb!iw=i5!%E-Ic5!`FJi&eb^^&=jz$6<< zh+y`!vGxk*X{>oTky-c&Yj3(*8d#^X){3}9DXq!j4Ht%YYim{9J3RIPCtj^GYkEw? z8Tz()UfbJ5A06*NPE$k}wL7FCbR-32f1pJj%Xs%w$WzPilVsCjT>&?S1cjq~KgHb6 zY-7I4QVv3MAH}aA9QPptPLLT$%kYRj;5zwlVO8MD#pcDtW<(ZI#QV?~4yYmKox@kH zg!pzeDu`jVBor737z7tuw5hMz3M%K}Ow>5fEXPZNfe*1VcNgJM+Atf-m^!J5#;v2( zxDC9m5>9ygCPT4ihwg7$QKXeSFl^p>mn(sMR-->EiK$&ovzLoxf#2;M?<_h^q1~-G zAjx91&pSpiip+3ch9f#p$J#J{R5c=N81Fdu0Bul*m9Om=7}PnHwe!(co3? zjoMMiBO^)R46BHSUn;V4%1*%aCyouaHff-4=HSa_UvJ23D;>%C-qh>uM4@>8FE+WB z&P2&UJHTttQ2jsXU{suoii2Upnj_vCada>F=q5HbybbX1+;U499cui_>zv9xt_poX%Pia2noDxDW|BQJtjzDV(O4V~xQ^JFS(*iZ|GZWJSt zPy)r5Xpf+;P5&@Qd}M@Dta~p4C$F+T&TwlY?}j#1$MfQW0pOdV+luL(h<`ga2wYJ- zPn4LOyK>IZ=c3lxJ@By&9N#^U73CO@o*!F*2X1uMD%A9I>BLy1Eq4vh1#3A)>{7W} zwRV`@iUy1^QbHuKC#;BM|Aq|{buN{dxWX!>CixXHcs>`**R!LU?nk5v>Q2Ha3_sdRuAp# z0z7vq-!+pxF|9l0ed-^CDkzEEcYF?l@~X~DdE)x$XxGGJ2-O6wZ^R44cmLO(Q*jYE zBEaQv()4Zv1{lQH#0`oWB9JX6lY_d#VjP>VKXx9{T8G?^c}U}-K$0tUBna=hDd;<= za(Ci#l958P=|h*;5C%WC|Oj>}1EHM7fd_CQ?+y zw>Tn6c|Oat+>O!m`iiOpl!_7AS=Jhj%1Je$+kUBgzwq$PI z@ZD%inWA_%ii{>MRs?m$ONpax5(~^w0fYa&RF-}i!P@a%{Ol)% zfySknr-~B>Kk-whKM@EnKCD&cfTLhowV@%#l!P$HL{Hmh$AntXqiHO znIUY=0bxTy2vfsaDKwjOf*MzRX<4-b>d7M*8C*(&T;838Ey@W^g0FMCAdyMsn4vY; z>)C2iJ@|8bb5@i=D8Izg3BkoV^TPH5Bj+@1dMw2df5Du^~z2;>P#J)jY6# z=g#nIl#WT}LV}=u%^+m2D}`b)P2Kg7tG}fMR{~Rn!r(Dj$QnzdHdGgHK*AM%d4Qcr zQz4dJ{v1B+0&myH%8JbE5)r|yHCUe143hH0S>BLr@#yX{Ug0lr4Mdrd6lbJ@C&Id( zXtM{TnK+Mr(KIrI6p7dXG8|^(yo*6z^htn(8bNZaQv;JB9gew{TTVhRCk;m;+0qb^ z_JU&$csM$c3@1VrVY0k)^YOFo$g{Ntciz^RNCcz_-?hVc4|ReDk4Q__)V2$&0nn`6 z(|H_b2880FtqBJOhdr`%%@gmbf<4RPl?^K`$CTQz&jF;^(cTMJ+FPMFTyZiHARq;9 zQnp00Vc|G0q5RaqNJ^~U55hjFDI%73{rj&A?lccVTOGhLGpv-fOixg0GQEyrXA=DQ z+RRz8onJ1Xm1y^Vc0Q?88_rP8S6A}#tpy;V2X<9EC8YK(BU;5_sc=<5LP{*2lVo64 zYeXdk`?tz4^17Mdw8&=d#oFy<)yPc!t~t>upEEF|}X-qu*MT4IqIOzCr>ed)88O+Iwn`WNzX|3b}2ZKNwU z&{nrOY*DKvvDqfi!F7(O(uli==_IHnn{HqNlf z4s)s&7&;jdkFH#i64EyZoRx55M}Zm!Rnsc%bp`*WA-c$rIyMSy-Tw|YDptQm#BHgC zj`#P#^XWMQJ3OXuv&t8E;xlC-2~;du#Z_FzdsVA0YKW)uk7)bWW2<9ckXh#gRbkF& z;3T=6y5PmTcwV}!nI|I8@?k-7w46G>7nF+qs4v__`kKA;Y0Uu?WsxD_XgLN=`wr6F zSTsQxz7=$~TK!H=BfL;~jmrq%Qn{pebCeFfMJ%$RH8%fl69-L(xqJ)%FrU<`+_Vr% ziK!H{kkZcSbAsRVsBw4!Rl|y#5<(a0+Eh|sumSL+waMl0mZnf{9^N#9!^a%Y1;q0l zqReyabP2*nn4HlH9!zZ0fnYGv%geMN`Z&&d4ljNFph3QM&gaI@sW#Ig16#^1^@?>W zd&MzUt04WEH9l0~%v>&k3RS!nu0{`q8@$BPsaHCZxIEfQml|YglbHvJ!&o1!T>(Og z-n;$nmx8okb(#UVOYVN5{cF6OU@XqZ38-;F5*Igh0gh>RGUXIc5Vh5};VZ1a929vm zVHu4oBvUKoS0EO$m0XO|Ggto_i-mHKC3?7ArGxas>RJgBEZ!-~{3~5Y&cy>j!k@0D zhS;Ag|7<7{XqXwabj)KwSoNTm>#hHSkQE$DJ@v&v6UN)Z7g#Dv(z& z;mYNe?|>>BAb$Js=0 zAf6))+362rWChyB$O@qczb1d@7@9}}eo_@RU@1f#MZS_gJ zOK(6)NUHS37hJ5>4@Pug6|OTeVpAe>HP@WWF>mS2z?R%V$}!XUWg7m=R5nmED1_pT zE{K_NxNi@+cK{4LFIK8LfoLRo1$OqXMyr|Ucctx&YV2`ncv70N2z4UZrarb)|eV>3mTMU1XJObD@+w8H?G z+2^QY-RC$)3wB~0sM*D74fq%ghSw~#Q?3M#;!n|&-<}QS8^-Y1YUKm-&H5;XFw*v1 zaZ2zq0XKlcLE;?46vKKvbRHJy?msc&iILR6cO|x=JZ1+?N2->>yPWDlVZ7X@HMBgA zOB*`1Jk|M9pwt$IZdPVL)$W(`6eJOEd-gapnC-&S1+Uk7h$G$v1lJVk z5*EfPf>c;35VqeRI2rTgJJIk_S);%&t>gqHD~IfiqI25v5xofN_>v0R{?&p@9We-5 z(5j2JG8KGW0)VN^BLK|H>qqaxgTs@5sre#=f_I_$Xzg8CT>+(*M1*S zLeN#Vxw*zT&Zu7w(JZrhv*m#{xLK710bfm7iCb%U$v7s^(wh0d`PpN2OVzLqpbejy z1<+s$T+_ruld+kM=BjleC`%&kS}~-pWsr!N(+(rYodetqa|!?3FYfMczYTyS;OT1E%g=AY*(RTO0ZNYZ7na1bc94OP zK5O%1(BKV^=X?Imk`n$KYCtNO|4J)DVOFwx>8oQ^0bNK#sLjbQY__Gl+8CH$@%Wtb zS3sjR`x|k+*L+_vH|FdQM6cEP;2$1o@N-GBb%5Ec>_wg49Indd`pij1Pj~d&@^ASV z^En1`FOpZrR6u4hln6me41;OsKr}%r zj`m5+qD#*0?9HluJ7)QBXkS}L)Vyq@%E4C0FvbR1M<>uNu~DKDb%7t{^BajJic(%a z>XpV&LXk&v2CHJCKe1G?9Oa{y3d)Rgp_=lb@j;QEh;lj}NP!8OJxg|#hOgww6!#gN zPm3ElN3@yoTR1NlC)4tw_)d9`+Nx9;Oz`2R*Ff`TWo2%_19&RXYQi3)hn`{r1_Hci zG+3xiGhzhLgBP&R0}4dA6L2Ad_Vr9+=%m;{#a&u7x6T0}3^I_+%S6Q)s3;YEnO)@K zo=<5+$*&llxhb=yi~i2pb37UC^=_E(fTdX~SiRmp+4;$%yEVD1h1@2K=xDQu@e?-R zGSYGC9AwjKsSukS$JEQLyR)tQihj?|zX{1Gz<^Zip?kE>`)n7&Yeq^P3h1#JX__rH zD_JCT5zHY{k<~=$#0E!lbdFULQP@zy5jtdZha|6%i;dYrwIF!z)r_J8^@rGQws>m> zk)hggV*OLnor(I2!-#lD0K{g9--@jtIvw zZQ^NLr)LsH!Qm6t*Mm9yTqb=%RI#ku1o7f*I*F8A642xLY3H8+zIEFS1z@uS6z|3X2y19vCB|69teT^v3Mq8NR3(bwyg`|=alC;WQ zNe527)`hA*D(4b(D&Q2Wv57ngQ5SIKU#DXw#^nXiO%kB;Je0yQO116X;pVMshR&La zr?n6t@w&w#OQ2(V+*d8rQz0zB=B=d+JU1Sl`=56FZLJYG`tDpuJU{Bsbj1dO>di-i zvPEm|-7SAb!33jhS?%YIMl$bJ;HFj1{421hdKYxWxm0o@5iyRh>X!9Kyrjz}+1F+e*5ZkfLvC^r=QRGH-p~8v}RHn~pfr0U=RR zZT@u-DS1RE?$tQUbYAOd6%ee7U>PZe_MV>%X}pazXUbD$g zYL3m^2wig0EO|!;(VLE@X^nB}ygAr+_~7mSK8Hb)SFF2cD1uly{c>529wi;_sp2^( z8t_moZ*RW=_Z)pkR_~4Er9)7dteZ^V`GmrIvAj!R1XUN`?dRG$JbWFfpQPf8M9aef zy#lx7Xb;F>>nFpg^at#&g{!a>?jXMqHXNV9_Q8Jx#Wh4OBVTK%Ue;t z&{jzC{IepZP^`v=>!KY0;}kRxonPM^fyN9fBJ#){wk@ULvD8+Ur)fYHlG91k{}>Z5tEOuNDf8~h0te}1K^u2q4xNp(l@1T3LwIL+ zi#L1q0D5`p8o~a$GQC*28CR3h@f$6wTc1Dup{N8jo|Y*1igQJmFMU^z)TlV4ct-$b zK$^c$KEilA#b9{1grBkqM&v^D)%;86P@G1vgY~TT`Y*RFH{eh0JM9<~&RSsAHj)vN zbvm}TYzOs=M;-KOmGkiS%paR#i zc~-#&V9Yn*_#`!JQ->4}9|j*(0?7!=Ba~|jA|t*txv{_4DuVWnR__FNh0uBm#sED& z{-V@9s;b|PAq{6~_X8CZ0_c<+ld@+_3yRjk)qxFZG-I|LdQF`%T@Ug{_~8jUa)&=~ zds37T@CT&h0%V4nF>hj{a3{dL74c-~2F~lW_yBwynMV)*);Ty`LVmB%Sw2Wm60s=& zQLd^=+@Y(c8tJF{OEp!=Us5Wh`gQ;d*^U8#?h`T!o=deR|Kr?yt>WVy!xBaM)(C`^ z41z^2vvU(r?lt7eQd9PFy&CV(rEYR#76`7N?bmA!w-Pcdtpv1M z6^M>Z`%ul~)<#LTR1Q9@P^j{E;8!cMCdy0ED9~PRA-cTY{*_VYc<&z_(}!LrTxr#R zt+=EL_I(SLEDb`~k zk^QCkKp)Etm$4E`_j7mP)ls~eA5?XgrDX%K96Kx1x(1iLPoG^O?x^F zNIV_ofwY^NlhL%)AqBD5*Q%ZQOIB%sZw+Kn_*a*_29%4e*2Y~ z?eTSpuGC^Pb&};{LcP6{&X2zIs8`uQ^yexMe@w?0=D6j{Cz15)Q9JiHP^;ERKXuxu zS}y-?YTqI=d_`~m5o$Rut~OD*QbG4qul}vcgcX})DFv42=j-bjy(G|4Eu4xudpHAFv-hu1VutY};Qv|Z>%AO;z_ z{#;Y^xp)&H#>r9{-a`X#-MefAE0W>M|O zmhQ#5DTb_S_5vsZGgV_8zWC@Sd_r?!0`^} z1M5U`D|8hg=SRQEqE|q7p%A$U?{@Svd^to$7Zi0h>_|ZVWYxiZvEPSL>5E;4OP4yl zT~Uk)ZIgTBCN2|RP)6pcl~eZY{-=5mebhamptY$4EhDEh8ApyaV8jqOX381nyaA1nip?A_$-wiHb|+k~2~uw-jcny2Sy@?O zSHlO3iw~MBF1|8Y=!#13ZYOI61g9?5U;{H^61*f{KGFdsL^&*&hNa1W>056Oz4c7x zYx}(*ucr`occ%Z&UYk4S!k=Vf%rtAF9XZY2+3gQeZ^xULi;3`DEV-3_pEYc2#6e`o ze201Ks&Wm$o;sn^wOASfi%_YT3n}$cNT5qs;^7!6>*~5fbIYQe>jKfUmz+ZqIbsk! zI3$fL0Pfo=hQ?enyfYv3G@&^V9Pi#TVE$Zfng9E|uHXds7HF7DRL^PgzN0~6foPn> z#;W>bOX6aMmDHYfyo^WN2S0WKBabW-_fAJ{4c{?nsi7AzotE1Sk0>0?fah&m;$3-P zk(jQ(U&rA_zG-P>1;0J-5X5E7D^F27S#5$m+_h9_-fwX}qB;|0-E{Br6ET*q)eY9j z|J(b&Z2xxLKs@Nv9>WG#+HW)QraL>V0EfrZ_OCnA z4OF9tp-FEG@ks%v+RVlj$hD7Vui(yhTr3e0#l6E%ZB0crPG2jbjazkiIBOJ; zZqY+OJH?;`3$WrbEA=qMjj99!Uz7(M@p1T{#ZS)SBdbrFqm3S~u7c#C#0l_F>_Z0m z63M|j>wya54LkBH-itYb$?zfr0ou-n>4Oa_;B$t5uj>}IN0Bw*c1ha$v3K*Y#`w@U znNmsg=I&D(f{%_AxV)*mt}jGM+vX@FKG!|sC zHUuGs@Bj#VDhHfhqsqtyj*cj-gCh(~!>miHJ2B%UU>j7x#Dnv;8WwZ{xlDD!b*Z6B z3N;Q)oktH}rHxiWvTe*qJ=)NpCP24OYeT1O?GqBV9?FtTFHe<=gkFQrKn0u zg=UEXv$?BIt0WP+REu-qj-a+(m=_^$fa*B7sL?v!go{}DnsbVgjR&g_F#E{XgC8CQ zcWC{p2Wv052Sd&-AZ+TwAe>%#T6S4;_v0}FbVjOfd|aK4wf2+mpFDs3>@j#-@OsgI zmy-4>nt*Ap$#P<*r{J3lC;1QmXL)%!NzCQ{5d*tu?8)$BHa_nUuiZ@GyO${!-%CV`QPDMn~p=Gb$QvP*m0_(6v zp=t2zMqnP{$#5=ex{o6kz*Zm_L#Kz#;YNHoYOQ}kf`z3t=fx!+68=)ey(LAX6*Y&i z`_vqbkkHdmwarZg=)BXkM~rH>#m$0vdnwUGANhUD2)n;8FWWCs@85w@| zylLR3!fZ25lorpd_+Rq#0l1_d>~>zh{ZUwcuNoSp`4}7OMUn1Y#B$KHVh)yPpK_}8 z#88}Zo)wno_tFZ>2x#SW2{l=ESQPJ1P$ru_{tHBxpD*}oWLj2TixGodH2Hyyry-3^ zpyV9qOTx(8fw@aik1SaP81?IQ$j)KHYmU@8+C$2e=$eR8(iUFp^n4G7IjLge?15Hx z$-a&MSPzIu>;%&JJDOXgq-+?Bn9&2ekf^%EM^4uiWH!kUF$qaIvq}77AtVr)QpjT#BliHW^hLa z8s>oUx17GA$OV+rAb#LQa<5o~PsIdy+Ru=g5=a(*a;JHYI8S|Y2@Sq70EkbN^1|{6 zz8tPdR3xh4ZB!%$?Kcd*cAKg?tzk6{V+pP=SknjcOZY`;uPISU)P1K#0epEmu2E&& zOD%dg$asgJzeY%!~jOcv!)1BEc8qqa=@=yf)}$fCjZ z_=dM5O7Ojh*xE`G`Q9Kf2qVXT1H$!aIzc&3x>{KVLFjJfKGei@Ih;=X??@LaWtbHG zVfe8Ho5#cqa)Vzm@dNPzKe0hy@@XP|aW_9dca|p05$p{>&mg_{A^!E=p$2yL9S8$3 zWY-`n(q!*gf#0AI!t6_OueS}rJKN#6~X z8=w=J7Q{olJ~#*%rTZ4?JScgVQ>S#vUBvV;0*CsHfe9o&q*~4BL9#LZHN2SC8v03W zV@EG|%#%}WX> zI#ngNrP1}C#|pLClJ`&rKd(}sMz%0IrJg;Fb5AOcm1##xfD0OfRf!||ECu4olyT-s z<0?r*?nGe3(JVn=5<(f{fI<&VXqxM_y*Pex*lfiKgQOoe;;`-#l41e<6&_}`m`uh~ zkn>st`rODNTYEi_2!&2fd&>zVWk2tS{j9jp%Bz}cT?cL}uSdU{>|1fh*``FH_359# zlu|`C{1S!StYJ8-YgTV3Uf#u;jWbJmsCzUy!|e*#}+o^am|{8w|3^>EZ$uk~!C{0Y0fVUzh8Eq;$%O z$ka)xL@qhFL8Rb{$fHo2iEN?zMt~^-PP&eM?vv=Kp^`EkaYPP`*#-j$pYnp-{YkhB z{9xctzz(^TBGRIrZ-z;SD}bY%S8m1;0ZV<6g#_1Hh!tFQnY-7>3M{u=xaQo`@~5J_ zehYj3{NUGCc+knR=Jk4(?&2GU0Dr?N87BUldz5&Mm0Z@8L8t&u)&{w1B5{b_vR+hj|esSr>4~B=$ z?D}oVZ%{#!kFW&O+^u-r1D-=4_!oOsb3P$z`dfvl-r4wIG`OQbfU>(u5NaKf_Nvg* zYuUx)GdeM-AXw8}Q+yd1yP4eI7it=8CQGFa0-s$9+$FrIBn)bD0M<-kI3KafgmmZT zR`8Th^y-{V+%Jv12?#Fr(h|2bG>xJRqLeJiH4@uc?uo-?Dh*&YZAD!md9)Uae_tA> zAvdSF;;rktf4pK8&5B8RDn-sCe^LzZuD$(B?PXHU2{29shi{u6%VIz(`EWu<6T@Q4 ze?c_%xH)h0kQ3zaUhjjIw1PBgu0;ox ziYw_B`Ju4x{u+GcZl`1SYpdL%3&(q?v^!98@BLkTQ)+IJ;vIozyw`iV6LadfD1>%HQ31^hHbugwo~3LG9Z*CBG_jQ(P`AS`)`ww6(HM?|THMW+=#D90AmqE#*v@1&)%7#N?*e?~^sjq!x zJegAm?vtYzD=A5Y|1mJL3i?V^qKXqZ(VAVqJhlB&sT1`oCA7||6;A1`wNtOc4nL+E z#o|4qSbPfBA*RI7#B9eR2#K=HlleHz=M2W2^qg!1%=5_?3vfQg_O~ViC zPrsTi*PY($UpWr6y`BP7l^(y()=AV}f5hnG?LVdkh_$x6MIE8 zp`8CMmUE2oTmh3(WU+l8#;|Hzx?T;}k9V(-(0H;T$t;Vx`^=^I41+*Q-N|@)_EU^N zcS9dU9?g=0qJ$E^jH!%I*1E|*lsAi;Y*0+*Z?mrkDg3D)pJ^KH(OvK*g)M4dBa!8g z&L8XtrnbFd^lHCX6K_(EA1jFwM>pUqTh42BQg)w~WFY@zC4mUU5=o$uaj(3A0FDGd zUuSyy;tkYUO$_~MG?~N2QEdc9j3rIP_+8(^@q(I94;57mvsO2#M61fE5^bVkwNh<> zNv+|!y<`zI3CW4+Y+G)BGtZ!UrMTr+#ZBF~AnKk$bD$5tYp`^os*Nh^RBfV{$;>vr zq+zH)4s<3bMiu;{faSK5t`xjVUx_31!2@`+{mp}(69 z5~zsr_ZMuP>985QD&5ob^bBoIYSN`^-;Gv&WKxQRUCbwLFCa%du29o9-4r+A9@xq! zo$S8r);q6c8xbw_M*8FJhFx2V3oyWTyt|PAyIx4<=M3uC?O!@bx@(PSN;QZR+ zYy9l+^sEghGI62EiIlV2l373LWoqsxm4Jc0*#9^B zsY}Z0Cs6$G#*GWLSHfH6H{-=<9uz_1gU^94l*ECu>t>U5q6QkxW-7nwMz)h}X5YB~ z?Fh5MqskhpXYl1JEwyK)4Xs!&9Is0<27JB# zwY*^;PuF!1!9=DK_-?=N+Gp(sAe9e5w>V;>X%uXt_DPegAN%Lm`ixLqG;Wn-sqh1j zduCtPt-^+Z8NdDe_SX@2>9H{|nBfp0@?TNjwifS;`>SK};eUF1;|}K5))tPIpK(Om z`}_@5UCQza|22a&^+=YW8y@CQHYV@=%>=*NBDgt)zqqb22L21t&r_H1dFglDTMWT`Gm5*L%M7ou}vna6zZQu z6isN(>zq#Gh*IN8s$xrRL|($8 zC&Ov1aK<6Yh1;8wmFC~CuRmJPBE6VlV}gHymJsDvQ&~w5X{*8-tT4Qd^#q=OUW-r% z7?dTLzrH%YsZvaa2z$NTCnE-gOZp%D6-7iSj|pBG8=sCR$>b>B!B%}OEK=lmNkG=! z@9VqT!BIDSaeU?*y5Hl5;&kcP)r;EII|poY3YQ4x@yU94WRTHpd8Zp9d;Qg?a}{D*QR@o( z6=_NnY)LD{kfeBym01pt(2{&M-m$;C|5GUaZ^O4NV=_t~hLMO8sPGg<>d`ke+;Yn{ zI411kfEQo&_O4$}lxHyown5Ty1YUW5?nrovVbS5cU9^0yXOA2r28&lM3vdS>%CUxz z@J5f;>w6%z@an&x(Ezhv>kef8U&IiEub20%33?f+SdVVey3vOvHLS#{ECf>q_T{T8 zjM5B6JT{wnbY+~5*o;jSFe=W8mL5m1KUW9BRhj&P{i7CEY>bOnw#j4gOA)g}hQ=@C ze(%6cd@(nHe&eh06Xbd%-V0hqGr^~Lw=Eq6lK+gP>%{%qr) z%Wo0FREG2VT;~*u6X}F3Kn@qkm7kes zK#o0scklvL7;p079%)SBSnAMz$efy^>xaCCY#4C3`a(-xN3DMA&5s1ETcF+j@+z z(JZ@ulb54)^BhYwug@=r_?WJ~Z+3Ad_F%g7tH1XQlCQkL07BN-f0>OftxpbX&98(ef`b2@&c5cTYT^Eg?XSUvs_ ziJ-TEG1%?|2@6D-4h5lYYbYS`je~zypojGov1x8ZEiTbj0HIDV&1fU2Eh-`27KGRLb2utbIVV`EMaTw@ zN}<{u0K!=OH2wEtf3oyP4f}(;SK;Dl$TSY-q_%PXP19$q-~UJF-)k@BxO1%7=*D4q z@2=-IC?D75Wif%!Wwff6qw8Ve6Hh}Z{YYg2SG1{*^EqAS>(4g8ba}v(vZ>{Z zm0La@>z25D+8F~m61cz&LlP|=U2uRNxa7&t71!hG$5w0c%}yIX(mrn>rsLt@e<}_t zJYyFAUVrCbgmPDIog#dTQcwHiz#=YX4SZ7Om($WMyQ&$q;?9Q|_F-B{h;<;mG*XK` zRm?$Dz_E3z-;$zSpE-Xs?2Y@ca{B{?X2shNV<%Nci%>v!u)vb8<;a20hvg?C>zJGT zy2OA|pv78mLP`|?_3Ft}%7G6}_zoaRf7Ke?iBf?_ZX~UQI>Ij%Xc-)GeWBN51|@(O zmvgUI0L;!30uk*S9@5svhjuGEnHwFram>CuX%ROk%K_$V5QqrwKeQ}OXS2#gWuH5h z#wdz+QY=T@I*{V{W{X?$2{MC#DgxN-vr?#tjwRFO7T0)5kS>8xN7b)*k5D*kD(i*n z7f^|`aE;np4V&5*@>HPp6eEe2$=*=L!Z$)BS|IdIy8EAu1n}zY>35xs&YOElb$Pe> zB>hP&l*!4ydhzP?@X4E(2PX&5cf4#lfUGr~Kz)t$O1LVwIc6b;wC)2)-tK+XV$a{{ z*)+c_C>iY<7PP9gc*-@3q0!XwRwK+j{`!h1U-S7UGst7`_4Pi++5pW%An5~2GqBp8jc1RTC2txW6{F*-J{;cp z_1xF0EAKK;MAm4W9Ual?@4(fnZyHmLcyf!fKYTWhN^L5IzTk=}z+=yd;9f4KQ_SH! zo|V`PT~a~QNo#<)f#?g%R$)AYzKu&D&asXG-PoAqA<+-V-!>RR8)mM1s@!r}Ke!3u z1L1W!!Pmv%_(}pJ=}CDqzAXp+zE!8tQ(;rwunl0E^%fTq9C64){CX7e9|UFFbc&N2 zkAlaBr+2)_FUOO`5K3ERqLSwqzf7U*Vs?xF2xY!Fe%F*7UJ9;{-vMq+2(+%({=A&c z+(34{>+TRdDzFfi#+n%z<;Is~4i4~m+XLIF&c7{Hhu*v9^1s5;fkC`G@WmURmG3Fg zGSr5TAl+cR+yx7GTzfvxpoj_9#rW8vyyGb3m2<2n_Fsz`bSa?J52VQDlvfAtG?2e= zH5)ndCwPpm#yS@lnuSy*F3bfE(V}zkYMycST@Z;&$?K&T=Y~cC&c-)m_iK+5^mEBE zkb^p~NKBS)^7-Z4Wau)i`gk#ykw5@*oMfefK^xII#@*#sv-D}k{b)z1ryxo=y^Ut6 zXvR~W+Z&b+CUapa#~qd#DRy|<1oEr|I%)W=^U?T$oW3_E?iX~7OcAAXf9iKt*92{< z>-@rtB^5Jwr7@EHJ;`1sA_$$A`}fzvId8$3U3+$9Fa+;jn&5?IKq-B`tzd$NMaR;f zKp--ePAZNZqfZ-Sw$V#ggLw^u2Mpvt)+z?R-CF$1{qKl9-#*OB35RVUx*a>8zO5B#4*l9YHe_%rJzA zb#C0ogRHLPQ7^hkwiQn>q52}ADw7z75k0!V>^e+th(tlAZ?~TCkE)L-h147qH5fRe zv;ARv8+)Td&e2vVsMwK@TZT(MBGrC)2wa^9o&Yor2)^ur(NJSX1eV?V4!5*yMzig3 zGC}xVrOotf9#Y!jLI6L2zhSC2cC1s&2|a^yM(;bLT_M!-@kPssK^1KamT;$%6+60G zk-NJ-_`1REa20da-~^cG`RpBlQ5AyS4TNQbD|TvGmC*ZTh@wfv&`?DhuQsy16%?^x zQ-@MeDpVzSg`!EX8fK5tc;l-pEQlij;4&*mT;#y2t{Bozbqox>44@?0 zQcs-FiX;T4L-PH^Yk#Hk7{n}jfkOp{4WaTLialb2K=j(!EL&Ww`hK!jb(@T|kYd#lWC|Eu z>HdvlOqJ==(Lqn{@isbsM_&OHE=P+ZT=SE&e(jy@GcCHq5C7{=&JwYiI7N69f))CG zUL}n6H?Q{i4N?>zx!CqDPVPCEcg2r!=mRgV1=UXGiuS4qEv#!vfIYPoBakg+Tfih8 zFDeNX9oab#FLK(fC~{g2I0pQMT9rg5D2~sfZ|?7ZqY`$B%l7!)G1VQRMh@?`Km5m2 z`q8c9Rl>s8M{Z8IPJU380KUodbv~Z%u;!#j*LWguXQMe#2Z?FBJYgDW0FBq z3MYF3RYY-n4>bfE#{B&XJXL2cY)>U#k?-0y%i3uAI%8r=MWTg{3K7Mp;al#NW#;gG zNqgREwH!@tBPW&Z?PcHWw6iXILfwg~+?g@2bNUa7=Of>Lq8r@Oor~>$Kfx^8l3z?F z+%bs=9I)GKh7wdLV3tlFnrhdJJQ{4M2F%oRA_{MC6+DG^m&%(b$B$nlw#7HJKSN{zKEEsVwm1Zv8jEUnt&b1R#TGieUJ0>>+8A|p~&h^#NDk)Bnh zl7{ixNOPK4CA4W>I*Q%E?;DBFO-5LbObdB3$)yz;wjYJx{aVM*xMBlO-m7a@SnU1n zc5_hxQwe3&Y9@dt=><#_GvTGHc>6c(;hp^cQ$FbFq6%iNY^gM!;s46{+sX5nd-apz zXo$EB%d)3~?8xYeK?1=zl~8h~B`fLegn_P#EbrsA-kDS@|p_+If3cb^B1RC5caIi0+47m zvxT&*7$o)qNR4zwfm?N1=v6M3kiVrtP1*|296J#8eBJXAZMe*WyZrhYqmBHCjHD;t zK?S2@I2PY+I9c7}Ocs!ZPjZ4I3OJ^>Ka}eV5S+T}GixRKwDIlBtA& z$%de{w3YSAxFB=M?Rff5@|B>$KA)6ZA4p;Zj;+su^t7qzk^uClhqQ0nP?Yu|_GxwJ)G}^eDe} z{LjTlu~=v)mepL>k_;UT2iKy)&NW#mDyocS8q!9s=jv+Dl;SK*fkOO5Qx;3FwEjEW zy@%Ps;u;Lyy&hZI!A(40II`rJ%W`%(%*&e@)}fuEHGe)PquXq}m|l|q_Ewf1xrHA> z+CM6kn`gt~Iv;|WsJwJy@7rQpuz70;`!u>%rL3OkAG43+MK%~`*W>X3t@dEqD&CjF zt*FgaIYPeox_n=Zz+DC~#l4u$is2Q7fznHIESSapXK%qi51|&rkDY8(ya)SA{thfE zH)QO}N7xWxuu((#k{Qr{0*@1VA}wyn-(($}v9j*I+nh^agx1Mp8RT8E z4wjgvs))E8s4|K3a~vlp|Wl0PA!(p4T|{=$KMy_WInB zCkSfwVWnZGHzuc-`DoYne$2jMI27Do+5$I%=ZT!{|z z%eUm8BMw3ePcTG-U2%{G14a>LW_AbNY#iV0?inytI$Yi&kkqP!#bVzT?)<@dg+IjK z4evxaptHHdtpR)5AaE5MKfB-x(fCDYF5{l=RS0Bmow4joMS&NGd zQnppt5jd0d4(>^CjB>0)7oW5{Vfkr$@Op(FFo!LyL{xmpfi67C*0=HEUB@*c5>U4Y*sC5#N$$VSGD4VLzNpFqMNFW4Ins+hcDKALb4$flwxYZz{0v+-$$fQn?h_EiEa${vE=kjNKfhL3}@Ezv4+u9F_S);^t z^N$2sg5M#WbvF1$IX6mww)2#PLm?YOCdpHJ^wlr|dX^Oy^#@=>5jCPCG(Wp0QKK>R6h0^>#HTGSz1 zOf3v`P5!nh-D`3U3WP}Ia04868`+AH9{+9s!)Hdp&HfBW@J|%`l9}$4cGk*ToX)u2 zy6+x9Xi__CuT^UYV!^<0UpJ^0=oH`9CzwMf4b%ayRY$W~UK*-KT!elTOf5`07)ndb z|M=yoPtPDN+QHM*_0_5CQc>ngQcabu!x!S3ic_+#so{fI!ROYAPLdyeq9D*K;XwOY ztTbjD88t&z5R5b1I}fRQqL{Ns4XWlGI_eMR3@Pf7SVLXTS(c9b8^f8c243)lYTx^~KA{aalljN21-yV6$N69o<0O|Wz;I;w*bsz)PyUn;X8MHJfD!nIJKaH4}wDKo0OzO zO)cA~IXehTTGEvI>}Jbrycj_tJY*)xY7dQp!g{Gq$HGk5ZN@IRf$bx^qAqc{y#AC#OsUQ`WZ>c z7rQbWsnW?QgYn{GD3VWbPDc4O>6$~pe`n;C2;LX?d(aeMC1GWs~PBO1cIwi;1u2Vh8x0QObNZ^B*&Bk zT*A1!H1XibAvdN42##%watuc}D=-&vt?vpN>&uw_C-?^EM(u zcsWOhzMbrQT3+|tBmRvU1rcFryOg2SU!OH*@fXK04y$#b5J0~ljY#{CxK|*jnAjCJ z%-7hH5>kPH9$Yx26U!ym38uMgl-<)5xJ5FG3AAYb-DnxRkVS>zi1yA(Tpo<;0vL1p zX#=X&@C0iGjh|7pa3l`ns%LD z@Rw7dp`#rKZQ>?uCwx<-Z!)P}`RJ%Ek5PWdFw1txiZd28jvfh;+Q)LjVn2knYJ4fn zb%Ozh_2AiO?N~~EzoiwC7(zTAfjl@utp`AYI3L_rP+xJdzyl7yq246wy8bPakRO21 z{s4sT_Li4!Ax9{JLDMDn2J--S>7Z2+yKs+V@PxV|uW`^W7T2iA!pi5Q(et0pnMclU z^69&xDZU%15xR)ikWpn2uRDAs<@*Zdw7@~rfX31EPf%Bo(K4S*AlVwwgjV-`fyNT% z^^NAD0iM=en5Y*8P`5dU%QYbW(os|Iz5P;>YdE2!R)+A$x1w$0%q9A|jo{65bGa+Ukstpa1+-r z?vW#~<58D!i#B@pcD!)Z_QGg(9JmYS<(lq0DC69gT4)EZvlI1Tw4#84lnRbU04J;T zp)}em&$H9g{01^VZQkUTF!b({Hen8JVcRE>bVl4yC}Jl3k{TPfJrtf@z~_7Vk12fe3v8YS_id9cs!O z!pg4ksNf=VNVgT)#v^gPn7ZTO1o5}y+w5j>`Ia@hfa;<(<7+%Dkd^aGQ!FpVZMQKe zDX$Ft(R2U%_F-66?7Y|8`3}Os7?Asml|^o#KTh57fF26mEo&ciM08X@hKL+YSUg~g zV9+A(#!h>`Z&+AUBEh@!Dd|aTK9ac;t8p=ZBqIAO`GHbn!oFHs0@oIhrgAR#puYWh zJtkE_Y`K2y-lSgM3Mz?|wve`7REBQqIDQy|TkE#c88)3cK5y>zg;7&pPCnM3DQe{% zUSTlgjxC~8WivL~080P>lB#jj@Z^;mmpsz7_$(*G4IH{B7sq$d!di-IQM>AkAh;Pk zhcHEtH4ZI8stU5B5j(9grK{+$n!#qjhSzM7bku$=P0y8oHiM|dZTJ_ORa_=c-D?o1 z^fD=>**PK#Ov|>Fq1!rHc;{j&E=J?U^;-l3 zz8;>cB0OAptiL|PL^iV$^gM8`8R9Qv*e$dt&n_LKIxWWn3hcV{t2}|9&Fnu}>O%K0 zgf$hfN7ah#v6wz&`o0h*ugKQ5;clHx#9Ov+kNVOF*5M1pg0188=tJLBhQs_CYp+_p zZ@U*IMC^ZPYqN9&=FbWY>b@MHN#F?44%zx<$AjV_>l?t6o*>Dzv%ReKpST=!8$sIa zKewyuf4GV-j#C&o%qA-%oE4 zk`dO}h>FH@NOR8rr_o=ZIJQxvj+JPjpp|$ttRd=g`kkD+d0>%9w3P+U%I77Cvo9?` z+5AgIE2GKyC;W@MTz0m64l~z+{ z(kX2Rg!37$0q%ZacJHRAvpNb1H`S^je=}IxhT?k1u%kf>Mi~EQbSa~g>6_CHPws_R zO82y63b;yDwVy1!*ZiqaxGzE@2=t9W$R?J(Z`-yw?Ygt9SB;Xc z=Dw)gAIw9f$`60x`oJi=e%hPajv8!Oj8ZEZ1Nw$_c@WZ>itc9%-Ad5Wi{y3iEZI_A z8|&IQo6ee0-%WdTt-1i-VzXL(y=dEf=2|S`j?|IrxO1gp5cA8?yJFBCiW8sWE!jUE zJ@5)}cx2zDa)g>WbYa?xLi%nB;E>2k?{>^7+uWzdCf9cGJHye#dZ`-A;6h2fZ$Zw! zae6UzLtp7XpTozs4oz-&EMcE`j%yKOLG-I0P*3QWQUgJ8YwDbOtE?DReuAP3?o%47 zHE*nP-vbTgj-h@%qp}Ur3Z9d}f#?|gl&UxM3sk&U6T2TY2EB@W7wC9swNq&o&JOCv zo|h2R{`}~L>raB2yAyZ3?MpSiya8r}l`lAg4$5ph9fV>iu4@v-OjB?92ApR8h&{1^ ziE$mUuw57f!QD4t-H~={4B-JcRIJ;Rp5%UHS=itm2yqZ^!0;YXC-p8Ou<+&H(l7T? zU+$&9+~WnRemO>z_;!v{rxA5|<|qe7wV+~lMoLv>11F^loqam-k^3X6>B&tN0Z6Jr zQq>L!V5AwTF`Og*ojTYx8g#2L#+V|~7vrzE+LT3ye2?+I$wz4)Pq$2`I18?dj-UzI zf&Q>TmGa0`&F(3J@r?8Mksl{Jt(3lyl>eY?O+Lw*6CNr71!@BMacR5!3P$-_9Z?nR z8e8Vkiw3Oo@Jno=hkt6_c#b%kC<{99XQU2>|AIOgTV~vXV`n4PunHg!IgKcJ5=YKD z(y-sB$T&)s!j#8SGmJIrNJKC;ZzqxzCLJQ-xP?jK5ya=}1X>o$yEf$Ll~O6J?!hK5 zJ$l!nu7=seClN2V7QdWu^o@S+k3Zt4Kv4b{0Ri+_rFCkM&(L2zj4|c6(B6$u-XD*K zFjYFdkrNK-F~s>k&Krv{1h}yea9@|$=kNXJo2j+Fcq#^8wGZ#cH#3jK0g+=(RN zK(RX|`Qv!j_`B5Q_|@4X9Ug=R1&U_T!9`DaQEEX*%z&((_7JGCmqpGmk;Yc*%++Cn zeKmHR6x%fM^yQ8gqGh(B5fKPc83*GJ>6Xn%qk@oLY@O(Yu_G9O+u#PX$|wYxVvlE5 zQg^J20HH=`ZX}ixwI?lqO;;@e@a0VgxtaC0+iI>lw{3NWpXQ4X3H288sjmTUS4QRC zkwmBOn}9!rS2O$O9U70PNj$p#a>WS_N-3{A*7gZVf`2uQg12v-(yf{_!7xBoXqp{b zB~cp81&BSCk+8%gY4vU*9!&%z%PKsKKdC(2DyuZH7)~kq@NOap$3K-<5Vgtkr2PH~ z-YX=}S7b5xbScl(`jBJGC)E4;hP_EqgR+4XWLYq@gxf9nsqh8(*%wl<8U0mGaLwY* zGBB4rQgM}o^yRaEFS$&PX6R6zTr}?}rOiXZ7)Gm2%}EU<+_`PP-IVS}&=S^155f%K zUZTUHqi7TUt{@9LM8dB|xLA594i$NnkNX5(3<@gZt}+vx^$N`Y#^jS+u$4OxFWQz4 z6)XmAb8S|-)?J$%(x|=aOv)i9E1d)gr3jJB_f9wWY}w77@@XNnOE6^;6^P0~HeIHk z5cS0Xdq?d!Z;b07{1te`(JZSnGfVg>;NrVh+J08_` zVnhvBhs{#}A^hL`-y{Y9T}cWyvS;I4iskpENywW1^z4* z95ys}AO7aS!%kLwfa;ED+}H8cFl0{PkX>}=5SBG8a*kaENPhR-7a&*y+a>I1oE#<)PUqIgF+EoPJA zvb=KlX^3uy4g$#clhE?vI7g3)a!v|8n=}Ac7hNNyBUc}x1pqx7PTp}&jz%asd_CMz zZhP0|>%80qgE7vH`I7Ty#I7-J9nd;~TLqsS`CK}(DEyr*Z=aDOMQ$D3FAm#qX~q*+ zYPYa6vLv%HL&DOtc#^0`cn>T$Drx--y)KRwn&xD>_VsDjeTX#Ab)EmEb3f0?;dMN^ zcD%r~eB8T_x?_bSQ{$yC!XcN4TgveH^6bqo$0vVz^XkRXSw<*p(|_Ozpxv3klgZqj zr%y15Vv?xEs^@7X$83 zgJC)NKn!;|BNReLn_*XB9XMbwPY$0R{hEEf{WZ!iAuBz-cysjP$>Fbur`bN-yMM~C z_+z$S*9siZ$79;^buSe}U;XvXv%{YcpSh(_RcYO}!XXFymqQN7;^b*M(=A`zhxXed zL!eo`E%G{Y*ZSp0?%N4fGcF3cWG*m=2$ceo4V5mIRIE%shwUXXP1h~MUT&r_)-cOoDg)wer;{+1s4wOil*@bu}ryF1wK z&Dm=K&`tiKyjk2NW<7JLCYy2UZm^4D=-3)SC1j=C(pRQUOHDC{27OP@PF_7edv$X7 z#;w-+-`!~b?q<#Z>#h3~fatj}tK|to`Z6hBGgu6ZPT)1O$0vseXNTF@!4J<4xo^u6 z?xPoHhd&;kWG_#So*$h2HT%oqUptOh9bdl7et35LgJZ-AM91!2$i?$5X5+!b#dpRQ zE(-1M4Vk{(wK@eaYo?^kwEX$a#+#GlUyh!*;a^V2GqsRlyPsW7%ZY?AfTK0f7;hZ3 zQ~@k^m5~k}l|3hH zZ&!vPHzqMJKD`icKi}>1Xxk`8CY%h+;zQ6>DxZw~^irprkzeQLVLP8(m|TRFj)l4v zxukXlQ%gR%^k+xTY4yv(KgD^00&4J)egtRw>C?)Y_ColUlOCC-MxG z`~=csbT~WV)f}^Z%z%sWc zP8!E3CQ7zOu4A_0Vlr8+VN@e@d~@OCj}dDZNmk%d?9fp?a92ArKPM5FaB!CcFT##L zsrqy>QKB92acp*^Q%Hs-#Y}-BZN-(@b!3zhKd8=(1wS8l)G7n;Hzo;-i>G8?)gEPIg&&RX^29FVE zVAd#@IVyZX7PtpGiI>*~z|VCtayuhwzeM}@z{^mM&6uM9xi3yl3k9wThW z831iPfQ*B`ScqonH= z+_E6+9qN;ml&XJNKjuW=t?cE{AwtiKbP@*{{E_^Egn?gwfc543Iq`-+7$p21S)NZ${t9ofRqzb7#DUuNUpeuO7vAV zJ?QyQ1QM$^VsOt)&lwaqx=F>q+Y%fd4~ z3VIC}$+pd!=_AGEXvh_d$puNQ)PUqTn(M(INT2Nz4N7Vp@#_hr6`Fa_={`}Ih&)019xE*J3&)Ac> zDPxLGVou1`bkraPGey3v*JT-X8!-nbP~UfP456XUZ?H zJiDC_XJn0=x`WL0BG747IGsN8Qb~re^eCj7;cbDzDfdy4W{eh*nV=3zB!a-(cv{4~ zOD&{>Sc>XE^u7{~7ZIDQ+kd5uGj>dyx7T?Nu+)bGEm+cC8!J~Y5NFX^l4ID@4SHl; zNK$uuHI!~H{j5cZ@|8@lt*1Wf2xmlC`|?_>F<>{K92b}*FoG=kQVI404_lHF`qs#? zB^K1O_oM8)O!4>nV?AX2-G%j+;$s(Yw-(-oCR3Q#n}GknV-v|V{SXlEyR8Z&9CUZP z8-_)Ja1=ZS*_NdioMQ$&r(cmN`Tk7It)h=?xrOaJ{vOyNh#;)Mid^|Tg{AeS^6-~H z*gCpO{8j}H1?6tT1RN_hfI@a?U5A_3x8CWpI(mTxw*B*m^8ANNnstq~qe{63CVJse zJq;BKU`;WW22qB#g!Y<>BeVvEWJq9E{~d2M-{~Vo^L+LtIU0m7oMS7>YsqFw0y8Mc zjSdKM4itqyrX?EXUg2Z6WiT2gC3_(yJ8?w$yS6(5Vc6b->0nkMqjw}MGm-{(FSiSaKSCK{ zZ35iNo`vaC7ZQp2lE(ubl)0$c?p3kn$-&vdo1-Uhejr5oHsj5Go_~OW!XSA(-~Rc} z-~73PAK3rNvm*f@{aFB@su)BvTfNLJU^@-sr^BNke>wvwf7U}FTtMfiw*}s0?j(M* zlZF9GBOJ#!Jq=@G*|(kE!~b~r-8bJp{Lc7gfIGsQ!L)3-Swm6>{BnoC+Q}x@qcP-x zU-t9&wTvoo6P$Ji`FUIM7&ogE-;9>C4IZ8bAdaX8ple$NDIn@bNONl^0jB#dnKCX? zd&O=|0Nau0iot)`A=(o9iFa?C@>WBO2vN|3$H1{$97F0w4J^2`FvwuWk9gmMsPF}q{d-Lt%n?1*1qJ{b7;v$tf$M&~9Zh@{aYo(OyZW~kuIXC-@s7a*Ci z+sPD#8|&c#(8OVH?5-gg4?68#DFZjrw@aFL4f*=p;mNT>+b2(;eED}t!a(nKwv)xZ z(9c?a*-f^9qlZQC%wP3wpS>TNKk8dzBF$<1ce1@7K<&3dR#O1OpUKvz#kB{?zo*AZ zv^>l|{9OlE4Z{DGZtEEc^H+1*XXsB*ebn4blvb&S$)1>74RFHG+&pRS^E{ta9@O+; z@qh}0RUhq|(rt*W7|{rUcC}?@Ds|VW{;*=w1H;Dg5Tklvs%)D0zL;PUBvYRpLvmG{ zZdv*xpCiW}uI8>!Y#M629FL^z1iE=f3@_DKdK`2NPf*41D2VIfwpW@6$!QYYP`L~f zP@5YtuDiK;^~fcq3Sh5vH^Qe-WY1Av$j2(ro|Lo8d^&(VX|;pr-F%u~z7qolDhl&C zd)DTQ`M68&u;^wA0ZA9&qdUSZ{FSfG$E=~aMDGmGw^!y8mykjzzI;?vU}iVkoS(J( zd*s6uvfplef{C78BywtlS1o9(-HIFLJ7Cu@Znm#RWvZSLR#eiCxOuh?zPRhg85i2E zVe%|UjDxx)w_!unw=l2lD<|q?zARK|CummvP_ny3I%jPkK;xgTusA4Z?;r=9$+f`Y zTb0S#07=-q@I7266=zK{ZmN!zsypbl86pxZD3AvXNo~5ql1aPlYyOQd-DJ_-Bd+&! zLC31LE+j)B7ciYbI?SnZMt3!Y7tN=1R$Ux7{?xPrpraS3hbL#5)P(d%h}e@Iq6;-T ztZxP2)0#SF(LBlj8hIMu71844QWC_SqAR?Jwy2a~iv8=azq-RL@h~&~xIMe#UKm%Weryhu z9bR>80PB~Z4o?m<^_gwfPuc=@bip?okA@C7qew%PHxy(-; zEABqGn`+<|`Db#K-<6Y2EQ~yj#{k>%hP~^vTQK2IsDmFy7V%#j+`w$MAphV(sd`%O z9K3)u+;VBx@QT8v}k)jtq! zW)?kgQ&JuE7u2mg8Ui;Vxcpxh@@0TS-USATqb=-Mo`ZekX5x4WWxyC6qj%@y(R}JT zq;eMgCBd`-9AF3lE!Sk47931u==`JS>PZX0zidjfHa8 z4t=2o^bwnnCtY$M7PT3VB<6Q2Y`#SFm#1*{>-o~4jq_w31bwu+rkRzeX_sH{m|qY{`(|%*BE%o}hy4 zz{Dhg$gz%G?RpGwg+kE5u@`aJFPA&J^&+Fs@_-3`R``ncDaU)5Sa(%xy0~s2ZShT@ z9qS3JtAtn(awGS!b=7EZpUmJrWG)9&6gskRHOxOu{iJ9j#>XUeO$#S27Nbk{?N|GQ z*Y{)c6yL3MrwOxSUKP`&$!;q+fhwgqx?@ckfFjip1G5n*$Tw|--c7=raQk^cq)Awg z8a}X#-Iqj)%~FV$<3F#TK0EyN;N;}sujjjFQ|Y6;N}R_sNW>&Nw?yP_a~*lRzbr1l zb*KP04MilskWnhV+3DZjfM(1ac3Lmmpu&}(7WtELz5x%vLo>ia3oqKba|ImCd*S(Yq`2SYGFh*fJo}gQ6tlX;Ep6!$gTn>n}u|m zK$emg*AXt08YTt@li0PRTLLcZ9ke}uatvNwjwCvQlC@}^w(ulvVMZS0q(STfVGO?v z8ByrN(U8K6n3pj_!sBvV4u@D3M}`$vjBk?s>K9tqMn+3Tp;weJBh0+C!gYj!fE4Tt zgX^L$g>2;;p=>)IwvjUkrtuK7DM*1V$)htK2)6mFZH1-zkalpqF7Kh@UYage+Po z{Am{9S-g7M3lZE?a`6PWW@GP?c`#yo2R!A~EN^a#0eD0XKdM+~K|C5b4-z~?W;~YX z`RpAM4>tWDogJRM0WAmK;j=CB3U;i^oLut>v~oZ+9gkleLSUu$17-(1(tAKus2m{R z2_(%t=#cU&iq|c)vRntOfuGPtQ9#L_xA|fQN{Q?Vl^dT-$CpJgOoTfleF&l7Gx#Vg^c$@~?GE zP9cJ|e%q|o`$g)8LKuzc0<*xJNliaahoFWKO6ko)D{mbQkvHx&8Pj9f$d+5-60=G@nT=4|%V|5IA)gWjRf#AK8~e46apm&P1zo zPHV3@ZCr9Bv0lCrDrv2?*h#TCf)i;?X6@Y>7(JA5CP~wN48RJs+!I)`N^foP&02nt zP!=!9FX4_#%Cgm4yDGRO{3|vPBgwJCu&O~r8Im>yrt+qkza0-$UhCEd8iv{}Z*1S_ zXiV6^bhjJ6RH+Yl#DGs4H)0$))5jDkyUodBMCeN$*kV1?cWff=G-6>ipXT-OG~V&jLBfepI#JNiI-hM!V);#~lKI@31LJqA#4K@{n2aY2 za+>g7?w5LnwpP|AJ=W+N8{Dd>Vmr}Xm4Sa;N9wGY8!|UAAj@`pA*ijV~%p}-`BsI{e691U`R!7^MUUEC-B>GO>}PNlus$7 zn%0h$@{;^sdG<8(n#D408W$Iky}Gvgnx*<1|Kc?kb?8@vj+aZ}_vG?&p^h>LT2kx7 zjTy?^vD5M&yZS&Ld0}Zq(rc+(G_U;NL%i_+;zfqb%B<%fzC=%c#jzxo#!VLAs0w6h zW?(Bju?Dd!0~oOxtC-s&(#DyzXFh#$TnHoZ@KSVwcr49i*IAen+|5$sQZ%L5w4@mF zs(Hyf#^Yeb#$=647Jf%fqrDj!nP8$D%C^Ln;^@v(Dad)`xGurCr!%w8DEDCqyw*PD z2dChP^yc($&khfszB&F&3oFM`etEKyxhLIya&_(Z@sH663-##dfM`D!^H;rZTlewB zoQ|^s^ep+D)Uvvi04|z`FdCEo z5YqLc3MZ$EZds{6qXWR_QnyA2-N2F^&CWP}99F!g78A>~(lWQ#D*d3BW3XCqueg4R zb=ROa9h$c{+)gAQ1$zX-v%m;eK)*)KD0&lvmjGPPpyHiTa@@iPIg6DOgFNfhrbcJV z@U+4V4BjM4W3DCG|66voxE=?>t7`>uB~1=eDVQmUe8 zPa0_sVass=g$w4OJa>KvfB`sG_WK}tMmmc^fFeyKA_U`0fH!4pL05vpr-ct%b>b0W z<;Uz6xnEY}&CpAdU_t0Rrs0i)x-oPwYz{b0LHzu6SPdNDi*u@bkH2q19r#=1v|r%D zW5$=_eIaR>IyQp`uSg3fzxks5VCS5szD^%rSE?fZ{*13f*aOtWeDFGFulKhaOFYrU z2oFC}cq3*3;Ek4Ad^8?4Ixzvq00Ig*F|0u+P{xoOnqPCT zaiTf*&TR@*8a=EDZF_Pae&`YrNuzh91FLsJoa%76C7&R_mk^%Jv7MOpij+35B*HZC zCoo_3_-nPvE0Q(xC_IdcVj!t-DPF>dKA(w%HNu=TxWJGdUh;#LTCf6lm2og|JRT2& zrqfAlpdSV`eMjw9?wuu+-aVJJ1Dv@FGe-Cf3dbNa-{kYlx8h8Nxos$8rply1ooC)! zNi39}SqLtYu<>ksOG`ss-4MrtCxW<{ulnO z3h(rq7X5a_)efvBPWyDQlWAqtwZUnkzsv*NjE~f%i#dOF6n%yNl@ZZBm&bE}%uov2w)}kqD%xf?@yI z+Pjfg&Adu0Lf(axQNJ}S3d*?ER&Hf1|Kb{IUO!8E394Ih6^8#v`H{rjeiCBD^rJND zSpA642e2I&afPkt=@_Rm@p|@}&0shLCo<(W7HiJu%2^w)|Er2ZjNF+$X@+ypg!#lI zT^Bp0?XCH*i^H)PY1#COobnh(?kT}rQsQ1h=#aL^Ivz9XtMs*2sm&hZIMkR#`cTt< z7`zD?12&i7j*3dvw7%D(tJnI1>GX*SXS%5M`3E#*Zes}gD@6my z2O{-l*GcYkIrat-*OH+DtJpyvRPsAjE$k~OHy>2;bWsin`EHF*oxkMBVd(uZ)YV0g zF|7iIjn3VF^toStro(6WU?YRQ)IAjAlJlo&@4)s6yxaS|=hivJl;2Ho?l3S=^mLH8w#kQ7f z*>(@%BYS(0pk*_IKYQn@PAi&TfX~WB)K)B;#MF8b_dA<9lVoa?jHTRsDUJ);ljOS) z)Q8q&h6*y>w+}JrNJvYHp(JtsQeByT?j;*t(+@nZWmUd?NNXOg#|`UE}5xv*rTVazbc=@l~B!{rF zNe+$cH>t8ny(NpZvt*IJS!I#Ls;f?6f;3PXFH0Vnmpj6n_W1ZY2MA-baIT~PUN8)k z{PI9_X16mHP8@0j1<{k#T;eyF&sJIS4K#2JK0HVF8e_-l_=r-s!4Q4}6Vk*(X-TO2 z--_wD1r>IummO}dmhCZWtO~<&`y^@4pnw7|p)VpZIe{cP4@M`Hk8n7?kQL;bwcYoq zJf_~DNfYH2h*Z?O19|JNf-??jHA(xt$=wNlr9VK$m_(JHS!Zm6S{i+Hbh&~WP8$RV zb=Awu3X>quYx0AenpAdW37^15l~~aS=4y^Roq@VdX(DGn?}8`wvI1mO!buVk`n>^4 zsBQfC25P20KYG!^0d@CB9fs8wzLVC0%ZhU=D7?&H2N2p2*K+M4?DqT2gM^CU1T%XC z;M&zH#ZA})+H1m{83)bsU??{tdeq|UHFAZ?rRE~{$NiNAMp}`H_6xA({13sqCLC)e zkjp%x4bU48lxPM!m&5|<;C?0A$tEvoy61NHpa0AR74AV<`MNd?Bs8Mg!SJ7_F$#ZO z4XMHq6<)=wSxTJ>u#$1*a{3s{0o_m&XJDmF=GEf4nf7q z%v(O_BF~9F8AQe<`+rHsiR4vDhG~F9X&?;wreR;TuyQrMmtx19!2*9z=9A!h*PL7e z+bJl%0x;V4HGns$w{3AlDV$7Wm|ph#zMg#6rbn(n4Mdd=c4ur_7EnghhsviCj@iqU zu13n#-l3Zl)0L6lnoKg%3XAoGRK8)+NZQp)9Z*5Ca=_H0Ycg`+QRw5Q;>*G(S3&QG zYw6#hezb1;*dGpP71&iEA*uCoIQZch5}JsUm-ji(vswPWKzW7%Z9ui(;qW5Ae8-86 z9Lj+kA^Ps4p@f3+@nc|4!xA(KPXi!aZ}xO$zrh58!Bv+)uQY@(qL_Z(yaTm-niB13$^LHt|qD8yJ3nX&2g+ouw{oypLR5L#?P(HNea* zVqe8g>(Dc|MZ^^r@78$jSse)LU(7^1{V{BVMI>00`}eaXE+%t7@rH3CsM@WejS(lD z!9~ZfV3q~noF{JECh#vMhU#SNnCxV|ZZhW zuYN}^Y6U#;=Mj3$5WPT{i#&or zXZIf<)&2keL$@EHPzRr&j+^|=&1yAZWx%;&IK$8ixgfJd}ypO~2mk z)iq$ppT1TJ-`yz%jnZrUmS&;x(7_hkeaFX|9k;9&?7! z{#=H8v6&uHqj(_(-xFH$`U*p*o6mKTAk-fU-Zwu|&5_naL?H=1Sp|ij# zPm3GJ5e&%vZctv8z|%g);{XbN4<~h}26E7?nYy^mvxCQnLAp}W^HGg})CoroaqX$>Xzdd;XXTS80v-X)<-o%xuMlQc zDf%DTcUqLy_|oK&nJ`01FoR#u(MddvL>SLW*$Ob~gl zw#kFoz~{yu>5h+$#bPymzAOCQ>livxzP9w}dxq+m#&BDkwmY4S_hCf;@T#Al9h@CK zHUJzeJ5hb{ouHw#foyE^xRDvbXfYhx5ojIo;fLaKF)tz~4L2sO-%2Elq>PLX4SzU1 z`{nTPMfShQ?vJ@6|5ph)(drPE5+$ZE_9+#%qrgE2;f@H(nI!Lwp@Al=g{@$sNlR(b z(65F~o_RMc3`p2`VtA57-`gvrs_zE4itAj(ltgQXt+W$KyyRv}5Hqw=8YQ6S=!EJs z#78l}-c<>GC>r=1fW(ow5l+>I@Olj*K?j^r0Y1o_czhJW%a$*YP$0SuJ;pXQ-t0m1 zZckK}>MTq;0r`2k1+Q^jI^Cb=4&a;cv?m{p>loNEsvbMbdQ`vK?X?3rk4BDz;D2}8 zyL=tWsSGJz|JbV|z-_)hlE>CD8(&9RWxwFg_`KH4z{RJl6^|QM4VS!ab-(_Eg~n|! z$kZIOsHxH4CgqK~>~m?^16|5hI(6TT1Q5xn?jJwF$`Lh^iRv80lWG>*K>s=I?fv`N z_I|(B?eYVZ>aN;aZClbhd67*wRI10T@w8R;w|BF0FErt-f#v3==eVtmBrQ1;V0pfU z9+80$Om_$y(y$O$O^aZr0YYp9YeSiSD=>`#qViS19W_ib-vHQ+c6bS&)L%@0kam-X zqzoRiLCL+h^LF3#%ayL5;+viovzX-bmt*wtv$)r^BgD(I_I-p6ik!@Neojl zxdaFtnV#d=!JS08EpU!}nww+&nvd)A{2gYhgITmNKHhyJx@b|{^~wN^&uAl^i0BVp zHO+Kqo3u1n`#pWfiK?-Z@^T_4md{`OxfjJP(@gi9=mpizr@bX`LgFgn#R7m}r0`ON zU@&Y?KDMBRyD4l}OJ*#AL6|Wm(VDjUu0j1~W<=>nHzwd>+IM%Pg&(wPUU!>F|H)iZ zJKLy?4+8^&YR-Mdy`?cHVXVBsevv&$#VD-47FFV#SYY+Zpd3y1G%W*<9ru*&_hUy> ziv4IjUFpr}-tBsI6pk34xkc^iTg9Cl;Ex!k)!qKY-T%`vAA;+!@_w49%KG^rGZor#|KcP7lvd)*(yk@H7MsHo-AdJcB=`h{6HGLV^@ks0u&!_l^xHy z#Bc(P&pbxy!fxdT;PA>o>s0tw#YZIOpw_ag3McwWh9QNWO=d_=0`lM_%ts?ZRxKB_ zF)1I9$M4D_0SQ73Oje^yY{@xXQ?(0tJq?KCS7(njk`GiseeeUR7<7?DdrLpY4g|M+ zPSmX4O5$mGmhiKSqkVo5f8p6AXMWmyAMb=bhMq zCjn6q782F_{COvtt-E3Z#5DHPYY2ui>HKG)d!0FsKc9vOjUT7^1-pI4JBoCiaUyF6 z{0I`uQ!?Uwv*Rre8Sd0W$t(2uZE^Wd$7JT2n?+2_C|9Cc6>-nm3PaiM_u296K7P$n z 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

efF?pLBfLbrvyILf`{=SH{ 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

B_C1=@#PtJLH~_{qc589lwf^S~_OoO?w} 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%0DPwYrRrq{R-B=%2DR*6nk)@aY%Z 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∓17)-n+iNPyVsbN=V5j6?>4AC=%Ix}= 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

>@eY#h2-)-z#|1`E6iKIrD2DSdq?VK>`zp?At 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 literal 0 HcmV?d00001 diff --git a/deps/sqlite-amalgamation-3530100/shell.c b/deps/sqlite-amalgamation-3530100/shell.c deleted file mode 100644 index 57faceb4..00000000 --- a/deps/sqlite-amalgamation-3530100/shell.c +++ /dev/null @@ -1,37308 +0,0 @@ -/* -** This is the amalgamated source code to the "sqlite3" or "sqlite3.exe" -** command-line shell (CLI) for SQLite. This file is automatically -** generated by the tool/mkshellc.tcl script from the following sources: -** -** ext/expert/sqlite3expert.c -** ext/expert/sqlite3expert.h -** ext/intck/sqlite3intck.c -** ext/intck/sqlite3intck.h -** ext/misc/appendvfs.c -** ext/misc/base64.c -** ext/misc/base85.c -** ext/misc/completion.c -** ext/misc/decimal.c -** ext/misc/fileio.c -** ext/misc/ieee754.c -** ext/misc/memtrace.c -** ext/misc/pcachetrace.c -** ext/misc/regexp.c -** ext/misc/series.c -** ext/misc/sha1.c -** ext/misc/shathree.c -** ext/misc/sqlar.c -** ext/misc/sqlite3_stdio.c -** ext/misc/sqlite3_stdio.h -** ext/misc/stmtrand.c -** ext/misc/uint.c -** ext/misc/vfstrace.c -** ext/misc/windirent.h -** ext/misc/zipfile.c -** ext/qrf/qrf.c -** ext/qrf/qrf.h -** ext/recover/dbdata.c -** ext/recover/sqlite3recover.c -** ext/recover/sqlite3recover.h -** src/shell.c.in -** -** To modify this program, get a copy of the canonical SQLite source tree, -** edit the src/shell.c.in file and/or some of the other files that are -** listed above, then rerun the command "make shell.c". -*/ -/************************* Begin src/shell.c.in ******************/ -/* -** 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 the "sqlite3" command line -** utility for accessing SQLite databases. -*/ -#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS) -/* This needs to come before any includes for MSVC compiler */ -#define _CRT_SECURE_NO_WARNINGS -#endif -typedef unsigned int u32; -typedef unsigned short int u16; - -/* -** Limit input nesting via .read or any other input redirect. -** It's not too expensive, so a generous allowance can be made. -*/ -#define MAX_INPUT_NESTING 25 - -/* -** Used to prevent warnings about unused parameters -*/ -#define UNUSED_PARAMETER(x) (void)(x) - -/* -** Number of elements in an array -*/ -#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0])) - -/* -** 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. Note that this macro has a like effect on sqlite3.c compilation. -*/ -# define SHELL_STRINGIFY_(f) #f -# define SHELL_STRINGIFY(f) SHELL_STRINGIFY_(f) -#ifdef SQLITE_CUSTOM_INCLUDE -# include SHELL_STRINGIFY(SQLITE_CUSTOM_INCLUDE) -#endif - -/* -** If SQLITE_SHELL_FIDDLE is defined then the shell is modified -** somewhat for use as a WASM module in a web browser. This flag -** should only be used when building the "fiddle" web application, as -** the browser-mode build has much different user input requirements -** and this build mode rewires the user input subsystem to account for -** that. -*/ -#if defined(SQLITE_SHELL_FIDDLE) -# undef SQLITE_OMIT_LOAD_EXTENSION -# define SQLITE_OMIT_LOAD_EXTENSION 1 -#endif - -/* -** Warning pragmas copied from msvc.h in the core. -*/ -#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) */ - -/* -** No support for loadable extensions in VxWorks. -*/ -#if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION -# define SQLITE_OMIT_LOAD_EXTENSION 1 -#endif - -/* -** Enable large-file support for fopen() and friends on unix. -*/ -#ifndef SQLITE_DISABLE_LFS -# define _LARGE_FILE 1 -# ifndef _FILE_OFFSET_BITS -# define _FILE_OFFSET_BITS 64 -# endif -# define _LARGEFILE_SOURCE 1 -#endif - -#if defined(SQLITE_SHELL_FIDDLE) && !defined(_POSIX_SOURCE) -/* -** emcc requires _POSIX_SOURCE (or one of several similar defines) -** to expose strdup(). -*/ -# define _POSIX_SOURCE -#endif - -#include -#include -#include -#include -#include -#include -#include "sqlite3.h" -typedef sqlite3_int64 i64; -typedef sqlite3_uint64 u64; -typedef unsigned char u8; -#include -#include -#ifndef _WIN32 -# include -# include -#endif - -#if !defined(_WIN32) && !defined(WIN32) -# include -# if !defined(__RTP__) && !defined(_WRS_KERNEL) && !defined(SQLITE_WASI) -# include -# endif -#endif -#if (!defined(_WIN32) && !defined(WIN32)) || defined(__MINGW32__) -# include -# include -# define GETPID getpid -# if defined(__MINGW32__) -# define DIRENT dirent -# ifndef S_ISLNK -# define S_ISLNK(mode) (0) -# endif -# endif -#else -# define GETPID (int)GetCurrentProcessId -#endif -#include -#include - -#if HAVE_READLINE -# include -# include -#endif - -#if HAVE_EDITLINE -# include -#endif - -#if HAVE_EDITLINE || HAVE_READLINE - -# define shell_add_history(X) add_history(X) -# define shell_read_history(X) read_history(X) -# define shell_write_history(X) write_history(X) -# define shell_stifle_history(X) stifle_history(X) -# define shell_readline(X) readline(X) - -#elif HAVE_LINENOISE - -# include "linenoise.h" -# define shell_add_history(X) linenoiseHistoryAdd(X) -# define shell_read_history(X) linenoiseHistoryLoad(X) -# define shell_write_history(X) linenoiseHistorySave(X) -# define shell_stifle_history(X) linenoiseHistorySetMaxLen(X) -# define shell_readline(X) linenoise(X) - -#else - -# define shell_read_history(X) -# define shell_write_history(X) -# define shell_stifle_history(X) - -# define SHELL_USE_LOCAL_GETLINE 1 -#endif - -#ifndef deliberate_fall_through -/* Quiet some compilers about some of our intentional code. */ -# if defined(GCC_VERSION) && GCC_VERSION>=7000000 -# define deliberate_fall_through __attribute__((fallthrough)); -# else -# define deliberate_fall_through -# endif -#endif - -#if defined(_WIN32) || defined(WIN32) -# include -# include -# define isatty(h) _isatty(h) -# ifndef access -# define access(f,m) _access((f),(m)) -# endif -# ifndef unlink -# define unlink _unlink -# endif -# ifndef strdup -# define strdup _strdup -# endif -# undef pclose -# define pclose _pclose -#else - /* Make sure isatty() has a prototype. */ - extern int isatty(int); - -# if !defined(__RTP__) && !defined(_WRS_KERNEL) && !defined(SQLITE_WASI) - /* popen and pclose are not C89 functions and so are - ** sometimes omitted from the header */ - extern FILE *popen(const char*,const char*); - extern int pclose(FILE*); -# else -# define SQLITE_OMIT_POPEN 1 -# endif -#endif - -#if defined(_WIN32_WCE) -/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty() - * thus we always assume that we have a console. That can be - * overridden with the -batch command line option. - */ -#define isatty(x) 1 -#endif - -/* ctype macros that work with signed characters */ -#define IsSpace(X) isspace((unsigned char)X) -#define IsDigit(X) isdigit((unsigned char)X) -#define ToLower(X) (char)tolower((unsigned char)X) -#define IsAlnum(X) isalnum((unsigned char)X) -#define IsAlpha(X) isalpha((unsigned char)X) - -#if defined(_WIN32) || defined(WIN32) -#undef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#include - -/* string conversion routines only needed on Win32 */ -extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR); -extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText); -#endif - -/************************* Begin ext/misc/sqlite3_stdio.h ******************/ -/* -** 2024-09-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. -** -************************************************************************* -** -** This header file contains definitions of interfaces that provide -** cross-platform I/O for UTF-8 content. -** -** On most platforms, the interfaces definitions in this file are -** just #defines. For example sqlite3_fopen() is a macro that resolves -** to the standard fopen() in the C-library. -** -** But Windows does not have a standard C-library, at least not one that -** can handle UTF-8. So for windows build, the interfaces resolve to new -** C-language routines contained in the separate sqlite3_stdio.c source file. -** -** So on all non-Windows platforms, simply #include this header file and -** use the interfaces defined herein. Then to run your application on Windows, -** also link in the accompanying sqlite3_stdio.c source file when compiling -** to get compatible interfaces. -*/ -#ifndef _SQLITE3_STDIO_H_ -#define _SQLITE3_STDIO_H_ 1 -#ifdef _WIN32 -/**** Definitions For Windows ****/ -#include -#include -#include - -FILE *sqlite3_fopen(const char *zFilename, const char *zMode); -FILE *sqlite3_popen(const char *zCommand, const char *type); -char *sqlite3_fgets(char *s, int size, FILE *stream); -int sqlite3_fputs(const char *s, FILE *stream); -int sqlite3_fprintf(FILE *stream, const char *format, ...); -int sqlite3_vfprintf(FILE *stream, const char *format, va_list); -void sqlite3_fsetmode(FILE *stream, int mode); - - -#else -/**** Definitions For All Other Platforms ****/ -#include -#define sqlite3_fopen fopen -#define sqlite3_popen popen -#define sqlite3_fgets fgets -#define sqlite3_fputs fputs -#define sqlite3_fprintf fprintf -#define sqlite3_vfprintf vfprintf -#define sqlite3_fsetmode(F,X) /*no-op*/ - -#endif -#endif /* _SQLITE3_STDIO_H_ */ - -/************************* End ext/misc/sqlite3_stdio.h ********************/ -/************************* Begin ext/misc/sqlite3_stdio.c ******************/ -/* -** 2024-09-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 standard I/O interfaces for UTF-8 that are missing -** on Windows. -*/ -#ifdef _WIN32 /* This file is a no-op on all platforms except Windows */ -#ifndef _SQLITE3_STDIO_H_ -/* #include "sqlite3_stdio.h" */ -#endif -#undef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#include -#include -#include -#include -#include -/* #include "sqlite3.h" */ -#include -#include -#include -#include - -/* -** If the SQLITE_U8TEXT_ONLY option is defined, then use O_U8TEXT -** when appropriate on all output. (Sometimes use O_BINARY when -** rendering ASCII text in cases where NL-to-CRLF expansion would -** not be correct.) -** -** If the SQLITE_U8TEXT_STDIO option is defined, then use O_U8TEXT -** when appropriate when writing to stdout or stderr. Use O_BINARY -** or O_TEXT (depending on things like the .mode and the .crlf setting -** in the CLI, or other context clues in other applications) for all -** other output channels. -** -** The default behavior, if neither of the above is defined is to -** use O_U8TEXT when writing to the Windows console (or anything -** else for which _isatty() returns true) and to use O_BINARY or O_TEXT -** for all other output channels. -** -** The SQLITE_USE_W32_FOR_CONSOLE_IO macro is also available. If -** defined, it forces the use of Win32 APIs for all console I/O, both -** input and output. This is necessary for some non-Microsoft run-times -** that implement stdio differently from Microsoft/Visual-Studio. -*/ -#if defined(SQLITE_U8TEXT_ONLY) -# define UseWtextForOutput(fd) 1 -# define UseWtextForInput(fd) 1 -# define IsConsole(fd) _isatty(_fileno(fd)) -#elif defined(SQLITE_U8TEXT_STDIO) -# define UseWtextForOutput(fd) ((fd)==stdout || (fd)==stderr) -# define UseWtextForInput(fd) ((fd)==stdin) -# define IsConsole(fd) _isatty(_fileno(fd)) -#else -# define UseWtextForOutput(fd) _isatty(_fileno(fd)) -# define UseWtextForInput(fd) _isatty(_fileno(fd)) -# define IsConsole(fd) 1 -#endif - -/* -** Global variables determine if simulated O_BINARY mode is to be -** used for stdout or other, respectively. Simulated O_BINARY mode -** means the mode is usually O_BINARY, but switches to O_U8TEXT for -** unicode characters U+0080 or greater (any character that has a -** multi-byte representation in UTF-8). This is the only way we -** have found to render Unicode characters on a Windows console while -** at the same time avoiding undesirable \n to \r\n translation. -*/ -static int simBinaryStdout = 0; -static int simBinaryOther = 0; - - -/* -** Determine if simulated binary mode should be used for output to fd -*/ -static int UseBinaryWText(FILE *fd){ - if( fd==stdout || fd==stderr ){ - return simBinaryStdout; - }else{ - return simBinaryOther; - } -} - - -/* -** Work-alike for the fopen() routine from the standard C library. -*/ -FILE *sqlite3_fopen(const char *zFilename, const char *zMode){ - FILE *fp = 0; - wchar_t *b1, *b2; - int sz1, sz2; - - sz1 = (int)strlen(zFilename); - sz2 = (int)strlen(zMode); - b1 = sqlite3_malloc64( (sz1+1)*sizeof(b1[0]) ); - b2 = sqlite3_malloc64( (sz2+1)*sizeof(b1[0]) ); - if( b1 && b2 ){ - sz1 = MultiByteToWideChar(CP_UTF8, 0, zFilename, sz1, b1, sz1); - b1[sz1] = 0; - sz2 = MultiByteToWideChar(CP_UTF8, 0, zMode, sz2, b2, sz2); - b2[sz2] = 0; - fp = _wfopen(b1, b2); - } - sqlite3_free(b1); - sqlite3_free(b2); - simBinaryOther = 0; - return fp; -} - - -/* -** Work-alike for the popen() routine from the standard C library. -*/ -FILE *sqlite3_popen(const char *zCommand, const char *zMode){ - FILE *fp = 0; - wchar_t *b1, *b2; - int sz1, sz2; - - sz1 = (int)strlen(zCommand); - sz2 = (int)strlen(zMode); - b1 = sqlite3_malloc64( (sz1+1)*sizeof(b1[0]) ); - b2 = sqlite3_malloc64( (sz2+1)*sizeof(b1[0]) ); - if( b1 && b2 ){ - sz1 = MultiByteToWideChar(CP_UTF8, 0, zCommand, sz1, b1, sz1); - b1[sz1] = 0; - sz2 = MultiByteToWideChar(CP_UTF8, 0, zMode, sz2, b2, sz2); - b2[sz2] = 0; - fp = _wpopen(b1, b2); - } - sqlite3_free(b1); - sqlite3_free(b2); - return fp; -} - -/* -** Work-alike for fgets() from the standard C library. -*/ -char *sqlite3_fgets(char *buf, int sz, FILE *in){ - if( UseWtextForInput(in) ){ - /* When reading from the command-prompt in Windows, it is necessary - ** to use _O_WTEXT input mode to read UTF-16 characters, then translate - ** that into UTF-8. Otherwise, non-ASCII characters all get translated - ** into '?'. - */ - wchar_t *b1 = sqlite3_malloc64( sz*sizeof(wchar_t) ); - if( b1==0 ) return 0; -#ifdef SQLITE_USE_W32_FOR_CONSOLE_IO - DWORD nRead = 0; - if( IsConsole(in) - && ReadConsoleW(GetStdHandle(STD_INPUT_HANDLE), b1, sz-1, &nRead, 0) - ){ - b1[nRead] = 0; - }else -#endif - { - _setmode(_fileno(in), IsConsole(in) ? _O_WTEXT : _O_U8TEXT); - if( fgetws(b1, sz/4, in)==0 ){ - sqlite3_free(b1); - return 0; - } - } - WideCharToMultiByte(CP_UTF8, 0, b1, -1, buf, sz, 0, 0); - sqlite3_free(b1); - return buf; - }else{ - /* Reading from a file or other input source, just read bytes without - ** any translation. */ - return fgets(buf, sz, in); - } -} - -/* -** Send ASCII text as O_BINARY. But for Unicode characters U+0080 and -** greater, switch to O_U8TEXT. -*/ -static void piecemealOutput(wchar_t *b1, int sz, FILE *out){ - int i; - wchar_t c; - while( sz>0 ){ - for(i=0; i=0x80; i++){} - if( i>0 ){ - c = b1[i]; - b1[i] = 0; - fflush(out); - _setmode(_fileno(out), _O_U8TEXT); - fputws(b1, out); - fflush(out); - b1 += i; - b1[0] = c; - sz -= i; - }else{ - fflush(out); - _setmode(_fileno(out), _O_TEXT); - _setmode(_fileno(out), _O_BINARY); - fwrite(&b1[0], 1, 1, out); - for(i=1; i -/* #include "sqlite3.h" */ - -/* -** Specification used by clients to define the output format they want -*/ -typedef struct sqlite3_qrf_spec sqlite3_qrf_spec; -struct sqlite3_qrf_spec { - unsigned char iVersion; /* Version number of this structure */ - unsigned char eStyle; /* Formatting style. "box", "csv", etc... */ - unsigned char eEsc; /* How to escape control characters in text */ - unsigned char eText; /* Quoting style for text */ - unsigned char eTitle; /* Quating style for the text of column names */ - unsigned char eBlob; /* Quoting style for BLOBs */ - unsigned char bTitles; /* True to show column names */ - unsigned char bWordWrap; /* Try to wrap on word boundaries */ - unsigned char bTextJsonb; /* Render JSONB blobs as JSON text */ - unsigned char eDfltAlign; /* Default alignment, no covered by aAlignment */ - unsigned char eTitleAlign; /* Alignment for column headers */ - unsigned char bSplitColumn; /* Wrap single-column output into many columns */ - unsigned char bBorder; /* Show outer border in Box and Table styles */ - short int nWrap; /* Wrap columns wider than this */ - short int nScreenWidth; /* Maximum overall table width */ - short int nLineLimit; /* Maximum number of lines for any row */ - short int nTitleLimit; /* Maximum number of characters in a title */ - unsigned int nMultiInsert; /* Add rows to one INSERT until size exceeds */ - int nCharLimit; /* Maximum number of characters in a cell */ - int nWidth; /* Number of entries in aWidth[] */ - int nAlign; /* Number of entries in aAlignment[] */ - short int *aWidth; /* Column widths */ - unsigned char *aAlign; /* Column alignments */ - char *zColumnSep; /* Alternative column separator */ - char *zRowSep; /* Alternative row separator */ - char *zTableName; /* Output table name */ - char *zNull; /* Rendering of NULL */ - char *(*xRender)(void*,sqlite3_value*); /* Render a value */ - int (*xWrite)(void*,const char*,sqlite3_int64); /* Write output */ - void *pRenderArg; /* First argument to the xRender callback */ - void *pWriteArg; /* First argument to the xWrite callback */ - char **pzOutput; /* Storage location for output string */ - /* Additional fields may be added in the future */ -}; - -/* -** Interfaces -*/ -int sqlite3_format_query_result( - sqlite3_stmt *pStmt, /* SQL statement to run */ - const sqlite3_qrf_spec *pSpec, /* Result format specification */ - char **pzErr /* OUT: Write error message here */ -); - -/* -** Range of values for sqlite3_qrf_spec.aWidth[] entries and for -** sqlite3_qrf_spec.mxColWidth and .nScreenWidth -*/ -#define QRF_MAX_WIDTH 10000 -#define QRF_MIN_WIDTH 0 - -/* -** Output styles: -*/ -#define QRF_STYLE_Auto 0 /* Choose a style automatically */ -#define QRF_STYLE_Box 1 /* Unicode box-drawing characters */ -#define QRF_STYLE_Column 2 /* One record per line in neat columns */ -#define QRF_STYLE_Count 3 /* Output only a count of the rows of output */ -#define QRF_STYLE_Csv 4 /* Comma-separated-value */ -#define QRF_STYLE_Eqp 5 /* Format EXPLAIN QUERY PLAN output */ -#define QRF_STYLE_Explain 6 /* EXPLAIN output */ -#define QRF_STYLE_Html 7 /* Generate an XHTML table */ -#define QRF_STYLE_Insert 8 /* Generate SQL "insert" statements */ -#define QRF_STYLE_Json 9 /* Output is a list of JSON objects */ -#define QRF_STYLE_JObject 10 /* Independent JSON objects for each row */ -#define QRF_STYLE_Line 11 /* One column per line. */ -#define QRF_STYLE_List 12 /* One record per line with a separator */ -#define QRF_STYLE_Markdown 13 /* Markdown formatting */ -#define QRF_STYLE_Off 14 /* No query output shown */ -#define QRF_STYLE_Quote 15 /* SQL-quoted, comma-separated */ -#define QRF_STYLE_Stats 16 /* EQP-like output but with performance stats */ -#define QRF_STYLE_StatsEst 17 /* EQP-like output with planner estimates */ -#define QRF_STYLE_StatsVm 18 /* EXPLAIN-like output with performance stats */ -#define QRF_STYLE_Table 19 /* MySQL-style table formatting */ - -/* -** Quoting styles for text. -** Allowed values for sqlite3_qrf_spec.eText -*/ -#define QRF_TEXT_Auto 0 /* Choose text encoding automatically */ -#define QRF_TEXT_Plain 1 /* Literal text */ -#define QRF_TEXT_Sql 2 /* Quote as an SQL literal */ -#define QRF_TEXT_Csv 3 /* CSV-style quoting */ -#define QRF_TEXT_Html 4 /* HTML-style quoting */ -#define QRF_TEXT_Tcl 5 /* C/Tcl quoting */ -#define QRF_TEXT_Json 6 /* JSON quoting */ -#define QRF_TEXT_Relaxed 7 /* Relaxed SQL quoting */ - -/* -** Quoting styles for BLOBs -** Allowed values for sqlite3_qrf_spec.eBlob -*/ -#define QRF_BLOB_Auto 0 /* Determine BLOB quoting using eText */ -#define QRF_BLOB_Text 1 /* Display content exactly as it is */ -#define QRF_BLOB_Sql 2 /* Quote as an SQL literal */ -#define QRF_BLOB_Hex 3 /* Hexadecimal representation */ -#define QRF_BLOB_Tcl 4 /* "\000" notation */ -#define QRF_BLOB_Json 5 /* A JSON string */ -#define QRF_BLOB_Size 6 /* Display the blob size only */ - -/* -** Control-character escape modes. -** Allowed values for sqlite3_qrf_spec.eEsc -*/ -#define QRF_ESC_Auto 0 /* Choose the ctrl-char escape automatically */ -#define QRF_ESC_Off 1 /* Do not escape control characters */ -#define QRF_ESC_Ascii 2 /* Unix-style escapes. Ex: U+0007 shows ^G */ -#define QRF_ESC_Symbol 3 /* Unicode escapes. Ex: U+0007 shows U+2407 */ - -/* -** Allowed values for "boolean" fields, such as "bColumnNames", "bWordWrap", -** and "bTextJsonb". There is an extra "auto" variants so these are actually -** tri-state settings, not booleans. -*/ -#define QRF_SW_Auto 0 /* Let QRF choose the best value */ -#define QRF_SW_Off 1 /* This setting is forced off */ -#define QRF_SW_On 2 /* This setting is forced on */ -#define QRF_Auto 0 /* Alternate spelling for QRF_*_Auto */ -#define QRF_No 1 /* Alternate spelling for QRF_SW_Off */ -#define QRF_Yes 2 /* Alternate spelling for QRF_SW_On */ - -/* -** Possible alignment values alignment settings -** -** Horizontal Vertial -** ---------- -------- */ -#define QRF_ALIGN_Auto 0 /* auto auto */ -#define QRF_ALIGN_Left 1 /* left auto */ -#define QRF_ALIGN_Center 2 /* center auto */ -#define QRF_ALIGN_Right 3 /* right auto */ -#define QRF_ALIGN_Top 4 /* auto top */ -#define QRF_ALIGN_NW 5 /* left top */ -#define QRF_ALIGN_N 6 /* center top */ -#define QRF_ALIGN_NE 7 /* right top */ -#define QRF_ALIGN_Middle 8 /* auto middle */ -#define QRF_ALIGN_W 9 /* left middle */ -#define QRF_ALIGN_C 10 /* center middle */ -#define QRF_ALIGN_E 11 /* right middle */ -#define QRF_ALIGN_Bottom 12 /* auto bottom */ -#define QRF_ALIGN_SW 13 /* left bottom */ -#define QRF_ALIGN_S 14 /* center bottom */ -#define QRF_ALIGN_SE 15 /* right bottom */ -#define QRF_ALIGN_HMASK 3 /* Horizontal alignment mask */ -#define QRF_ALIGN_VMASK 12 /* Vertical alignment mask */ - -/* -** Auxiliary routines contined within this module that might be useful -** in other contexts, and which are therefore exported. -*/ -/* -** Return an estimate of the width, in columns, for the single Unicode -** character c. For normal characters, the answer is always 1. But the -** estimate might be 0 or 2 for zero-width and double-width characters. -** -** Different devices display unicode using different widths. So -** it is impossible to know that true display width with 100% accuracy. -** Inaccuracies in the width estimates might cause columns to be misaligned. -** Unfortunately, there is nothing we can do about that. -*/ -int sqlite3_qrf_wcwidth(int c); - -/* -** Return an estimate of the number of display columns used by the -** string in the argument. The width of individual characters is -** determined as for sqlite3_qrf_wcwidth(). VT100 escape code sequences -** are assigned a width of zero. -*/ -size_t sqlite3_qrf_wcswidth(const char*); - - -#ifdef __cplusplus -} -#endif -#endif /* !defined(SQLITE_QRF_H) */ - -/************************* End ext/qrf/qrf.h ********************/ -/************************* Begin ext/qrf/qrf.c ******************/ -/* -** 2025-10-20 -** -** 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 Query Result-Format or "qrf" utility library for -** SQLite. See the README.md documentation for additional information. -*/ -#ifndef SQLITE_QRF_H -#include "qrf.h" -#endif -#include -#include -#include - -#ifndef SQLITE_AMALGAMATION -/* typedef sqlite3_int64 i64; */ -#endif - -/* A single line in the EQP output */ -typedef struct qrfEQPGraphRow qrfEQPGraphRow; -struct qrfEQPGraphRow { - int iEqpId; /* ID for this row */ - int iParentId; /* ID of the parent row */ - qrfEQPGraphRow *pNext; /* Next row in sequence */ - char zText[1]; /* Text to display for this row */ -}; - -/* All EQP output is collected into an instance of the following */ -typedef struct qrfEQPGraph qrfEQPGraph; -struct qrfEQPGraph { - qrfEQPGraphRow *pRow; /* Linked list of all rows of the EQP output */ - qrfEQPGraphRow *pLast; /* Last element of the pRow list */ - int nWidth; /* Width of the graph */ - char zPrefix[400]; /* Graph prefix */ -}; - -/* -** Private state information. Subject to change from one release to the -** next. -*/ -typedef struct Qrf Qrf; -struct Qrf { - sqlite3_stmt *pStmt; /* The statement whose output is to be rendered */ - sqlite3 *db; /* The corresponding database connection */ - sqlite3_stmt *pJTrans; /* JSONB to JSON translator statement */ - char **pzErr; /* Write error message here, if not NULL */ - sqlite3_str *pOut; /* Accumulated output */ - int iErr; /* Error code */ - int nCol; /* Number of output columns */ - int expMode; /* Original sqlite3_stmt_isexplain() plus 1 */ - int mxWidth; /* Screen width */ - int mxHeight; /* nLineLimit */ - union { - struct { /* Content for QRF_STYLE_Line */ - int mxColWth; /* Maximum display width of any column */ - char **azCol; /* Names of output columns (MODE_Line) */ - } sLine; - qrfEQPGraph *pGraph; /* EQP graph (Eqp, Stats, and StatsEst) */ - struct { /* Content for QRF_STYLE_Explain */ - int nIndent; /* Slots allocated for aiIndent */ - int iIndent; /* Current slot */ - int *aiIndent; /* Indentation for each opcode */ - } sExpln; - unsigned int nIns; /* Bytes used for current INSERT stmt */ - } u; - sqlite3_int64 nRow; /* Number of rows handled so far */ - int *actualWidth; /* Actual width of each column */ - sqlite3_qrf_spec spec; /* Copy of the original spec */ -}; - -/* -** Data for substitute ctype.h functions. Used for x-platform -** consistency and so that '_' is counted as an alphabetic -** character. -** -** 0x01 - space -** 0x02 - digit -** 0x04 - alphabetic, including '_' -*/ -static const char qrfCType[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 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, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, - 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, - 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 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 qrfSpace(x) ((qrfCType[(unsigned char)x]&1)!=0) -#define qrfDigit(x) ((qrfCType[(unsigned char)x]&2)!=0) -#define qrfAlpha(x) ((qrfCType[(unsigned char)x]&4)!=0) -#define qrfAlnum(x) ((qrfCType[(unsigned char)x]&6)!=0) - -#ifndef deliberate_fall_through -/* Quiet some compilers about some of our intentional code. */ -# if defined(GCC_VERSION) && GCC_VERSION>=7000000 -# define deliberate_fall_through __attribute__((fallthrough)); -# else -# define deliberate_fall_through -# endif -#endif - -/* -** Set an error code and error message. -*/ -static void qrfError( - Qrf *p, /* Query result state */ - int iCode, /* Error code */ - const char *zFormat, /* Message format (or NULL) */ - ... -){ - p->iErr = iCode; - if( p->pzErr!=0 ){ - sqlite3_free(*p->pzErr); - *p->pzErr = 0; - if( zFormat ){ - va_list ap; - va_start(ap, zFormat); - *p->pzErr = sqlite3_vmprintf(zFormat, ap); - va_end(ap); - } - } -} - -/* -** Out-of-memory error. -*/ -static void qrfOom(Qrf *p){ - qrfError(p, SQLITE_NOMEM, "out of memory"); -} - -/* -** Transfer any error in pStr over into p. -*/ -static void qrfStrErr(Qrf *p, sqlite3_str *pStr){ - int rc = pStr ? sqlite3_str_errcode(pStr) : 0; - if( rc ){ - qrfError(p, rc, sqlite3_errstr(rc)); - } -} - - -/* -** Add a new entry to the EXPLAIN QUERY PLAN data -*/ -static void qrfEqpAppend(Qrf *p, int iEqpId, int p2, const char *zText){ - qrfEQPGraphRow *pNew; - sqlite3_int64 nText; - if( zText==0 ) return; - if( p->u.pGraph==0 ){ - p->u.pGraph = sqlite3_malloc64( sizeof(qrfEQPGraph) ); - if( p->u.pGraph==0 ){ - qrfOom(p); - return; - } - memset(p->u.pGraph, 0, sizeof(qrfEQPGraph) ); - } - nText = strlen(zText); - pNew = sqlite3_malloc64( sizeof(*pNew) + nText ); - if( pNew==0 ){ - qrfOom(p); - return; - } - pNew->iEqpId = iEqpId; - pNew->iParentId = p2; - memcpy(pNew->zText, zText, nText+1); - pNew->pNext = 0; - if( p->u.pGraph->pLast ){ - p->u.pGraph->pLast->pNext = pNew; - }else{ - p->u.pGraph->pRow = pNew; - } - p->u.pGraph->pLast = pNew; -} - -/* -** Free and reset the EXPLAIN QUERY PLAN data that has been collected -** in p->u.pGraph. -*/ -static void qrfEqpReset(Qrf *p){ - qrfEQPGraphRow *pRow, *pNext; - if( p->u.pGraph ){ - for(pRow = p->u.pGraph->pRow; pRow; pRow = pNext){ - pNext = pRow->pNext; - sqlite3_free(pRow); - } - sqlite3_free(p->u.pGraph); - p->u.pGraph = 0; - } -} - -/* Return the next EXPLAIN QUERY PLAN line with iEqpId that occurs after -** pOld, or return the first such line if pOld is NULL -*/ -static qrfEQPGraphRow *qrfEqpNextRow(Qrf *p, int iEqpId, qrfEQPGraphRow *pOld){ - qrfEQPGraphRow *pRow = pOld ? pOld->pNext : p->u.pGraph->pRow; - while( pRow && pRow->iParentId!=iEqpId ) pRow = pRow->pNext; - return pRow; -} - -/* Render a single level of the graph that has iEqpId as its parent. Called -** recursively to render sublevels. -*/ -static void qrfEqpRenderLevel(Qrf *p, int iEqpId){ - qrfEQPGraphRow *pRow, *pNext; - i64 n = strlen(p->u.pGraph->zPrefix); - char *z; - for(pRow = qrfEqpNextRow(p, iEqpId, 0); pRow; pRow = pNext){ - pNext = qrfEqpNextRow(p, iEqpId, pRow); - z = pRow->zText; - sqlite3_str_appendf(p->pOut, "%s%s%s\n", p->u.pGraph->zPrefix, - pNext ? "|--" : "`--", z); - if( n<(i64)sizeof(p->u.pGraph->zPrefix)-7 ){ - memcpy(&p->u.pGraph->zPrefix[n], pNext ? "| " : " ", 4); - qrfEqpRenderLevel(p, pRow->iEqpId); - p->u.pGraph->zPrefix[n] = 0; - } - } -} - -/* -** Render the 64-bit value N in a more human-readable format into -** pOut. -** -** + Only show the first three significant digits. -** + Append suffixes K, M, G, T, P, and E for 1e3, 1e6, ... 1e18 -*/ -static void qrfApproxInt64(sqlite3_str *pOut, i64 N){ - static const char aSuffix[] = { 'K', 'M', 'G', 'T', 'P', 'E' }; - int i; - if( N<0 ){ - N = N==INT64_MIN ? INT64_MAX : -N; - sqlite3_str_append(pOut, "-", 1); - } - if( N<10000 ){ - sqlite3_str_appendf(pOut, "%4lld ", N); - return; - } - for(i=1; i<=18; i++){ - N = (N+5)/10; - if( N<10000 ){ - int n = (int)N; - switch( i%3 ){ - case 0: - sqlite3_str_appendf(pOut, "%d.%02d", n/1000, (n%1000)/10); - break; - case 1: - sqlite3_str_appendf(pOut, "%2d.%d", n/100, (n%100)/10); - break; - case 2: - sqlite3_str_appendf(pOut, "%4d", n/10); - break; - } - sqlite3_str_append(pOut, &aSuffix[i/3], 1); - break; - } - } -} - -/* -** Display and reset the EXPLAIN QUERY PLAN data -*/ -static void qrfEqpRender(Qrf *p, i64 nCycle){ - qrfEQPGraphRow *pRow; - if( p->u.pGraph!=0 && (pRow = p->u.pGraph->pRow)!=0 ){ - if( pRow->zText[0]=='-' ){ - if( pRow->pNext==0 ){ - qrfEqpReset(p); - return; - } - sqlite3_str_appendf(p->pOut, "%s\n", pRow->zText+3); - p->u.pGraph->pRow = pRow->pNext; - sqlite3_free(pRow); - }else if( nCycle>0 ){ - int nSp = p->u.pGraph->nWidth - 2; - if( p->spec.eStyle==QRF_STYLE_StatsEst ){ - sqlite3_str_appendchar(p->pOut, nSp, ' '); - sqlite3_str_appendall(p->pOut, - "Cycles Loops (est) Rows (est)\n"); - sqlite3_str_appendchar(p->pOut, nSp, ' '); - sqlite3_str_appendall(p->pOut, - "---------- ------------ ------------\n"); - }else{ - sqlite3_str_appendchar(p->pOut, nSp, ' '); - sqlite3_str_appendall(p->pOut, - "Cycles Loops Rows \n"); - sqlite3_str_appendchar(p->pOut, nSp, ' '); - sqlite3_str_appendall(p->pOut, - "---------- ----- -----\n"); - } - sqlite3_str_appendall(p->pOut, "QUERY PLAN"); - sqlite3_str_appendchar(p->pOut, nSp - 10, ' '); - qrfApproxInt64(p->pOut, nCycle); - sqlite3_str_appendall(p->pOut, " 100%\n"); - }else{ - sqlite3_str_appendall(p->pOut, "QUERY PLAN\n"); - } - p->u.pGraph->zPrefix[0] = 0; - qrfEqpRenderLevel(p, 0); - qrfEqpReset(p); - } -} - -#ifdef SQLITE_ENABLE_STMT_SCANSTATUS -/* -** Helper function for qrfExpStats(). -** -*/ -static int qrfStatsHeight(sqlite3_stmt *p, int iEntry){ - int iPid = 0; - int ret = 1; - sqlite3_stmt_scanstatus_v2(p, iEntry, - SQLITE_SCANSTAT_SELECTID, SQLITE_SCANSTAT_COMPLEX, (void*)&iPid - ); - while( iPid!=0 ){ - int ii; - for(ii=0; 1; ii++){ - int iId; - int res; - res = sqlite3_stmt_scanstatus_v2(p, ii, - SQLITE_SCANSTAT_SELECTID, SQLITE_SCANSTAT_COMPLEX, (void*)&iId - ); - if( res ) break; - if( iId==iPid ){ - sqlite3_stmt_scanstatus_v2(p, ii, - SQLITE_SCANSTAT_PARENTID, SQLITE_SCANSTAT_COMPLEX, (void*)&iPid - ); - } - } - ret++; - } - return ret; -} -#endif /* SQLITE_ENABLE_STMT_SCANSTATUS */ - - -/* -** Generate ".scanstatus est" style of EQP output. -*/ -static void qrfEqpStats(Qrf *p){ -#ifndef SQLITE_ENABLE_STMT_SCANSTATUS - qrfError(p, SQLITE_ERROR, "not available in this build"); -#else - static const int f = SQLITE_SCANSTAT_COMPLEX; - sqlite3_stmt *pS = p->pStmt; - int i = 0; - i64 nTotal = 0; - int nWidth = 0; - int prevPid = -1; /* Previous iPid */ - double rEstCum = 1.0; /* Cumulative row estimate */ - sqlite3_str *pLine = sqlite3_str_new(p->db); - sqlite3_str *pStats = sqlite3_str_new(p->db); - qrfEqpReset(p); - - for(i=0; 1; i++){ - const char *z = 0; - int n = 0; - if( sqlite3_stmt_scanstatus_v2(pS,i,SQLITE_SCANSTAT_EXPLAIN,f,(void*)&z) ){ - break; - } - n = (int)strlen(z) + qrfStatsHeight(pS,i)*3; - if( n>nWidth ) nWidth = n; - } - nWidth += 2; - - sqlite3_stmt_scanstatus_v2(pS,-1, SQLITE_SCANSTAT_NCYCLE, f, (void*)&nTotal); - for(i=0; 1; i++){ - i64 nLoop = 0; - i64 nRow = 0; - i64 nCycle = 0; - int iId = 0; - int iPid = 0; - const char *zo = 0; - const char *zName = 0; - double rEst = 0.0; - - if( sqlite3_stmt_scanstatus_v2(pS,i,SQLITE_SCANSTAT_EXPLAIN,f,(void*)&zo) ){ - break; - } - sqlite3_stmt_scanstatus_v2(pS,i, SQLITE_SCANSTAT_PARENTID,f,(void*)&iPid); - if( iPid!=prevPid ){ - prevPid = iPid; - rEstCum = 1.0; - } - sqlite3_stmt_scanstatus_v2(pS,i, SQLITE_SCANSTAT_EST,f,(void*)&rEst); - rEstCum *= rEst; - sqlite3_stmt_scanstatus_v2(pS,i, SQLITE_SCANSTAT_NLOOP,f,(void*)&nLoop); - sqlite3_stmt_scanstatus_v2(pS,i, SQLITE_SCANSTAT_NVISIT,f,(void*)&nRow); - sqlite3_stmt_scanstatus_v2(pS,i, SQLITE_SCANSTAT_NCYCLE,f,(void*)&nCycle); - sqlite3_stmt_scanstatus_v2(pS,i, SQLITE_SCANSTAT_SELECTID,f,(void*)&iId); - sqlite3_stmt_scanstatus_v2(pS,i, SQLITE_SCANSTAT_NAME,f,(void*)&zName); - - if( nCycle>=0 || nLoop>=0 || nRow>=0 ){ - int nSp = 0; - sqlite3_str_reset(pStats); - if( nCycle>=0 && nTotal>0 ){ - qrfApproxInt64(pStats, nCycle); - sqlite3_str_appendf(pStats, " %3d%%", - ((nCycle*100)+nTotal/2) / nTotal - ); - nSp = 2; - } - if( nLoop>=0 ){ - if( nSp ) sqlite3_str_appendchar(pStats, nSp, ' '); - qrfApproxInt64(pStats, nLoop); - nSp = 2; - if( p->spec.eStyle==QRF_STYLE_StatsEst ){ - sqlite3_str_appendf(pStats, " "); - qrfApproxInt64(pStats, (i64)(rEstCum/rEst)); - } - } - if( nRow>=0 ){ - if( nSp ) sqlite3_str_appendchar(pStats, nSp, ' '); - qrfApproxInt64(pStats, nRow); - nSp = 2; - if( p->spec.eStyle==QRF_STYLE_StatsEst ){ - sqlite3_str_appendf(pStats, " "); - qrfApproxInt64(pStats, (i64)rEstCum); - } - } - sqlite3_str_appendf(pLine, - "% *s %s", -1*(nWidth-qrfStatsHeight(pS,i)*3), zo, - sqlite3_str_value(pStats) - ); - sqlite3_str_reset(pStats); - qrfEqpAppend(p, iId, iPid, sqlite3_str_value(pLine)); - sqlite3_str_reset(pLine); - }else{ - qrfEqpAppend(p, iId, iPid, zo); - } - } - if( p->u.pGraph ) p->u.pGraph->nWidth = nWidth; - qrfStrErr(p, pLine); - sqlite3_free(sqlite3_str_finish(pLine)); - qrfStrErr(p, pStats); - sqlite3_free(sqlite3_str_finish(pStats)); -#endif -} - - -/* -** Reset the prepared statement. -*/ -static void qrfResetStmt(Qrf *p){ - int rc = sqlite3_reset(p->pStmt); - if( rc!=SQLITE_OK && p->iErr==SQLITE_OK ){ - qrfError(p, rc, "%s", sqlite3_errmsg(p->db)); - } -} - -/* -** If xWrite is defined, send all content of pOut to xWrite and -** reset pOut. -*/ -static void qrfWrite(Qrf *p){ - int n; - if( p->spec.xWrite && (n = sqlite3_str_length(p->pOut))>0 ){ - int rc = p->spec.xWrite(p->spec.pWriteArg, - sqlite3_str_value(p->pOut), - (sqlite3_int64)n); - sqlite3_str_reset(p->pOut); - if( rc ){ - qrfError(p, rc, "Failed to write %d bytes of output", n); - } - } -} - -/* Lookup table to estimate the number of columns consumed by a Unicode -** character. -*/ -static const struct { - unsigned char w; /* Width of the character in columns */ - int iFirst; /* First character in a span having this width */ -} aQrfUWidth[] = { - /* {1, 0x00000}, */ - {0, 0x00300}, {1, 0x00370}, {0, 0x00483}, {1, 0x00487}, {0, 0x00488}, - {1, 0x0048a}, {0, 0x00591}, {1, 0x005be}, {0, 0x005bf}, {1, 0x005c0}, - {0, 0x005c1}, {1, 0x005c3}, {0, 0x005c4}, {1, 0x005c6}, {0, 0x005c7}, - {1, 0x005c8}, {0, 0x00600}, {1, 0x00604}, {0, 0x00610}, {1, 0x00616}, - {0, 0x0064b}, {1, 0x0065f}, {0, 0x00670}, {1, 0x00671}, {0, 0x006d6}, - {1, 0x006e5}, {0, 0x006e7}, {1, 0x006e9}, {0, 0x006ea}, {1, 0x006ee}, - {0, 0x0070f}, {1, 0x00710}, {0, 0x00711}, {1, 0x00712}, {0, 0x00730}, - {1, 0x0074b}, {0, 0x007a6}, {1, 0x007b1}, {0, 0x007eb}, {1, 0x007f4}, - {0, 0x00901}, {1, 0x00903}, {0, 0x0093c}, {1, 0x0093d}, {0, 0x00941}, - {1, 0x00949}, {0, 0x0094d}, {1, 0x0094e}, {0, 0x00951}, {1, 0x00955}, - {0, 0x00962}, {1, 0x00964}, {0, 0x00981}, {1, 0x00982}, {0, 0x009bc}, - {1, 0x009bd}, {0, 0x009c1}, {1, 0x009c5}, {0, 0x009cd}, {1, 0x009ce}, - {0, 0x009e2}, {1, 0x009e4}, {0, 0x00a01}, {1, 0x00a03}, {0, 0x00a3c}, - {1, 0x00a3d}, {0, 0x00a41}, {1, 0x00a43}, {0, 0x00a47}, {1, 0x00a49}, - {0, 0x00a4b}, {1, 0x00a4e}, {0, 0x00a70}, {1, 0x00a72}, {0, 0x00a81}, - {1, 0x00a83}, {0, 0x00abc}, {1, 0x00abd}, {0, 0x00ac1}, {1, 0x00ac6}, - {0, 0x00ac7}, {1, 0x00ac9}, {0, 0x00acd}, {1, 0x00ace}, {0, 0x00ae2}, - {1, 0x00ae4}, {0, 0x00b01}, {1, 0x00b02}, {0, 0x00b3c}, {1, 0x00b3d}, - {0, 0x00b3f}, {1, 0x00b40}, {0, 0x00b41}, {1, 0x00b44}, {0, 0x00b4d}, - {1, 0x00b4e}, {0, 0x00b56}, {1, 0x00b57}, {0, 0x00b82}, {1, 0x00b83}, - {0, 0x00bc0}, {1, 0x00bc1}, {0, 0x00bcd}, {1, 0x00bce}, {0, 0x00c3e}, - {1, 0x00c41}, {0, 0x00c46}, {1, 0x00c49}, {0, 0x00c4a}, {1, 0x00c4e}, - {0, 0x00c55}, {1, 0x00c57}, {0, 0x00cbc}, {1, 0x00cbd}, {0, 0x00cbf}, - {1, 0x00cc0}, {0, 0x00cc6}, {1, 0x00cc7}, {0, 0x00ccc}, {1, 0x00cce}, - {0, 0x00ce2}, {1, 0x00ce4}, {0, 0x00d41}, {1, 0x00d44}, {0, 0x00d4d}, - {1, 0x00d4e}, {0, 0x00dca}, {1, 0x00dcb}, {0, 0x00dd2}, {1, 0x00dd5}, - {0, 0x00dd6}, {1, 0x00dd7}, {0, 0x00e31}, {1, 0x00e32}, {0, 0x00e34}, - {1, 0x00e3b}, {0, 0x00e47}, {1, 0x00e4f}, {0, 0x00eb1}, {1, 0x00eb2}, - {0, 0x00eb4}, {1, 0x00eba}, {0, 0x00ebb}, {1, 0x00ebd}, {0, 0x00ec8}, - {1, 0x00ece}, {0, 0x00f18}, {1, 0x00f1a}, {0, 0x00f35}, {1, 0x00f36}, - {0, 0x00f37}, {1, 0x00f38}, {0, 0x00f39}, {1, 0x00f3a}, {0, 0x00f71}, - {1, 0x00f7f}, {0, 0x00f80}, {1, 0x00f85}, {0, 0x00f86}, {1, 0x00f88}, - {0, 0x00f90}, {1, 0x00f98}, {0, 0x00f99}, {1, 0x00fbd}, {0, 0x00fc6}, - {1, 0x00fc7}, {0, 0x0102d}, {1, 0x01031}, {0, 0x01032}, {1, 0x01033}, - {0, 0x01036}, {1, 0x0103b}, {0, 0x01058}, - {1, 0x0105a}, {2, 0x01100}, {0, 0x01160}, {1, 0x01200}, {0, 0x0135f}, - {1, 0x01360}, {0, 0x01712}, {1, 0x01715}, {0, 0x01732}, {1, 0x01735}, - {0, 0x01752}, {1, 0x01754}, {0, 0x01772}, {1, 0x01774}, {0, 0x017b4}, - {1, 0x017b6}, {0, 0x017b7}, {1, 0x017be}, {0, 0x017c6}, {1, 0x017c7}, - {0, 0x017c9}, {1, 0x017d4}, {0, 0x017dd}, {1, 0x017de}, {0, 0x0180b}, - {1, 0x0180e}, {0, 0x018a9}, {1, 0x018aa}, {0, 0x01920}, {1, 0x01923}, - {0, 0x01927}, {1, 0x01929}, {0, 0x01932}, {1, 0x01933}, {0, 0x01939}, - {1, 0x0193c}, {0, 0x01a17}, {1, 0x01a19}, {0, 0x01b00}, {1, 0x01b04}, - {0, 0x01b34}, {1, 0x01b35}, {0, 0x01b36}, {1, 0x01b3b}, {0, 0x01b3c}, - {1, 0x01b3d}, {0, 0x01b42}, {1, 0x01b43}, {0, 0x01b6b}, {1, 0x01b74}, - {0, 0x01dc0}, {1, 0x01dcb}, {0, 0x01dfe}, {1, 0x01e00}, {0, 0x0200b}, - {1, 0x02010}, {0, 0x0202a}, {1, 0x0202f}, {0, 0x02060}, {1, 0x02064}, - {0, 0x0206a}, {1, 0x02070}, {0, 0x020d0}, {1, 0x020f0}, {2, 0x02329}, - {1, 0x0232b}, {2, 0x02e80}, {0, 0x0302a}, {2, 0x03030}, {1, 0x0303f}, - {2, 0x03040}, {0, 0x03099}, {2, 0x0309b}, {1, 0x0a4d0}, {0, 0x0a806}, - {1, 0x0a807}, {0, 0x0a80b}, {1, 0x0a80c}, {0, 0x0a825}, {1, 0x0a827}, - {2, 0x0ac00}, {1, 0x0d7a4}, {2, 0x0f900}, {1, 0x0fb00}, {0, 0x0fb1e}, - {1, 0x0fb1f}, {0, 0x0fe00}, {2, 0x0fe10}, {1, 0x0fe1a}, {0, 0x0fe20}, - {1, 0x0fe24}, {2, 0x0fe30}, {1, 0x0fe70}, {0, 0x0feff}, {2, 0x0ff00}, - {1, 0x0ff61}, {2, 0x0ffe0}, {1, 0x0ffe7}, {0, 0x0fff9}, {1, 0x0fffc}, - {0, 0x10a01}, {1, 0x10a04}, {0, 0x10a05}, {1, 0x10a07}, {0, 0x10a0c}, - {1, 0x10a10}, {0, 0x10a38}, {1, 0x10a3b}, {0, 0x10a3f}, {1, 0x10a40}, - {0, 0x1d167}, {1, 0x1d16a}, {0, 0x1d173}, {1, 0x1d183}, {0, 0x1d185}, - {1, 0x1d18c}, {0, 0x1d1aa}, {1, 0x1d1ae}, {0, 0x1d242}, {1, 0x1d245}, - {2, 0x20000}, {1, 0x2fffe}, {2, 0x30000}, {1, 0x3fffe}, {0, 0xe0001}, - {1, 0xe0002}, {0, 0xe0020}, {1, 0xe0080}, {0, 0xe0100}, {1, 0xe01f0} -}; - -/* -** Return an estimate of the width, in columns, for the single Unicode -** character c. For normal characters, the answer is always 1. But the -** estimate might be 0 or 2 for zero-width and double-width characters. -** -** Different display devices display unicode using different widths. So -** it is impossible to know that true display width with 100% accuracy. -** Inaccuracies in the width estimates might cause columns to be misaligned. -** Unfortunately, there is nothing we can do about that. -*/ -int sqlite3_qrf_wcwidth(int c){ - int iFirst, iLast; - - /* Fast path for common characters */ - if( c<0x300 ) return 1; - - /* The general case */ - iFirst = 0; - iLast = sizeof(aQrfUWidth)/sizeof(aQrfUWidth[0]) - 1; - while( iFirst c ){ - iLast = iMid - 1; - }else{ - return aQrfUWidth[iMid].w; - } - } - if( aQrfUWidth[iLast].iFirst > c ) return aQrfUWidth[iFirst].w; - return aQrfUWidth[iLast].w; -} - -/* -** Compute the value and length of a multi-byte UTF-8 character that -** begins at z[0]. Return the length. Write the Unicode value into *pU. -** -** This routine only works for *multi-byte* UTF-8 characters. It does -** not attempt to detect illegal characters. -*/ -int sqlite3_qrf_decode_utf8(const unsigned char *z, int *pU){ - if( (z[0] & 0xe0)==0xc0 && (z[1] & 0xc0)==0x80 ){ - *pU = ((z[0] & 0x1f)<<6) | (z[1] & 0x3f); - return 2; - } - if( (z[0] & 0xf0)==0xe0 && (z[1] & 0xc0)==0x80 && (z[2] & 0xc0)==0x80 ){ - *pU = ((z[0] & 0x0f)<<12) | ((z[1] & 0x3f)<<6) | (z[2] & 0x3f); - return 3; - } - if( (z[0] & 0xf8)==0xf0 && (z[1] & 0xc0)==0x80 && (z[2] & 0xc0)==0x80 - && (z[3] & 0xc0)==0x80 - ){ - *pU = ((z[0] & 0x0f)<<18) | ((z[1] & 0x3f)<<12) | ((z[2] & 0x3f))<<6 - | (z[3] & 0x3f); - return 4; - } - *pU = 0; - return 1; -} - -/* -** Check to see if z[] is a valid VT100 escape. If it is, then -** return the number of bytes in the escape sequence. Return 0 if -** z[] is not a VT100 escape. -** -** This routine assumes that z[0] is \033 (ESC). -*/ -static int qrfIsVt100(const unsigned char *z){ - int i; - if( z[1]!='[' ) return 0; - i = 2; - while( z[i]>=0x30 && z[i]<=0x3f ){ i++; } - while( z[i]>=0x20 && z[i]<=0x2f ){ i++; } - if( z[i]<0x40 || z[i]>0x7e ) return 0; - return i+1; -} - -/* -** Return the length of a string in display characters. -** -** Most characters of the input string count as 1, including -** multi-byte UTF8 characters. However, zero-width unicode -** characters and VT100 escape sequences count as zero, and -** double-width characters count as two. -** -** The definition of "zero-width" and "double-width" characters -** is not precise. It depends on the output device, to some extent, -** and it varies according to the Unicode version. This routine -** makes the best guess that it can. -*/ -size_t sqlite3_qrf_wcswidth(const char *zIn){ - const unsigned char *z = (const unsigned char*)zIn; - size_t n = 0; - while( *z ){ - if( z[0]<' ' ){ - int k; - if( z[0]=='\033' && (k = qrfIsVt100(z))>0 ){ - z += k; - }else{ - z++; - } - }else if( (0x80&z[0])==0 ){ - n++; - z++; - }else{ - int u = 0; - int len = sqlite3_qrf_decode_utf8(z, &u); - z += len; - n += sqlite3_qrf_wcwidth(u); - } - } - return n; -} - -/* -** Return the display width of the longest line of text -** in the (possibly) multi-line input string zIn[0..nByte]. -** zIn[] is not necessarily zero-terminated. Take -** into account tab characters, zero- and double-width -** characters, CR and NL, and VT100 escape codes. -** -** Write the number of newlines into *pnNL. So, *pnNL will -** return 0 if everything fits on one line, or positive it -** it will need to be split. -*/ -static int qrfDisplayWidth(const char *zIn, sqlite3_int64 nByte, int *pnNL){ - const unsigned char *z; - const unsigned char *zEnd; - int mx = 0; - int n = 0; - int nNL = 0; - if( zIn==0 ) zIn = ""; - z = (const unsigned char*)zIn; - zEnd = &z[nByte]; - while( z0 ){ - z += k; - }else{ - if( z[0]=='\t' ){ - n = (n+8)&~7; - }else if( z[0]=='\n' || z[0]=='\r' ){ - nNL++; - if( n>mx ) mx = n; - n = 0; - } - z++; - } - }else if( (0x80&z[0])==0 ){ - n++; - z++; - }else{ - int u = 0; - int len = sqlite3_qrf_decode_utf8(z, &u); - z += len; - n += sqlite3_qrf_wcwidth(u); - } - } - if( mx>n ) n = mx; - if( pnNL ) *pnNL = nNL; - return n; -} - -/* -** Escape the input string if it is needed and in accordance with -** eEsc, which is either QRF_ESC_Ascii or QRF_ESC_Symbol. -** -** Escaping is needed if the string contains any control characters -** other than \t, \n, and \r\n -** -** If no escaping is needed (the common case) then set *ppOut to NULL -** and return 0. If escaping is needed, write the escaped string into -** memory obtained from sqlite3_malloc64() and make *ppOut point to that -** memory and return 0. If an error occurs, return non-zero. -** -** The caller is responsible for freeing *ppFree if it is non-NULL in order -** to reclaim memory. -*/ -static void qrfEscape( - int eEsc, /* QRF_ESC_Ascii or QRF_ESC_Symbol */ - sqlite3_str *pStr, /* String to be escaped */ - int iStart /* Begin escapding on this byte of pStr */ -){ - sqlite3_int64 i, j; /* Loop counters */ - sqlite3_int64 sz; /* Size of the string prior to escaping */ - sqlite3_int64 nCtrl = 0;/* Number of control characters to escape */ - unsigned char *zIn; /* Text to be escaped */ - unsigned char c; /* A single character of the text */ - unsigned char *zOut; /* Where to write the results */ - - /* Find the text to be escaped */ - zIn = (unsigned char*)sqlite3_str_value(pStr); - if( zIn==0 ) return; - zIn += iStart; - - /* Count the control characters */ - for(i=0; (c = zIn[i])!=0; i++){ - if( c<=0x1f - && c!='\t' - && c!='\n' - && (c!='\r' || zIn[i+1]!='\n') - ){ - nCtrl++; - } - } - if( nCtrl==0 ) return; /* Early out if no control characters */ - - /* Make space to hold the escapes. Copy the original text to the end - ** of the available space. */ - sz = sqlite3_str_length(pStr) - iStart; - if( eEsc==QRF_ESC_Symbol ) nCtrl *= 2; - sqlite3_str_appendchar(pStr, nCtrl, ' '); - zOut = (unsigned char*)sqlite3_str_value(pStr); - if( zOut==0 ) return; - zOut += iStart; - zIn = zOut + nCtrl; - memmove(zIn,zOut,sz); - - /* Convert the control characters */ - for(i=j=0; (c = zIn[i])!=0; i++){ - if( c>0x1f - || c=='\t' - || c=='\n' - || (c=='\r' && zIn[i+1]=='\n') - ){ - continue; - } - if( i>0 ){ - memmove(&zOut[j], zIn, i); - j += i; - } - zIn += i+1; - i = -1; - if( eEsc==QRF_ESC_Symbol ){ - zOut[j++] = 0xe2; - zOut[j++] = 0x90; - zOut[j++] = 0x80+c; - }else{ - zOut[j++] = '^'; - zOut[j++] = 0x40+c; - } - } -} - -/* -** Determine if the string z[] can be shown as plain text. Return true -** if z[] is unambiguously text. Return false if z[] needs to be -** quoted. -** -** All of the following must be true in order for z[] to be relaxable: -** -** (1) z[] does not begin or end with ' or whitespace -** (2) z[] is not the same as the NULL rendering -** (3) z[] does not looks like a numeric literal -*/ -static int qrfRelaxable(Qrf *p, const char *z){ - size_t i, n; - if( z[0]=='\'' || qrfSpace(z[0]) ) return 0; - if( z[0]==0 ){ - return (p->spec.zNull!=0 && p->spec.zNull[0]!=0); - } - n = strlen(z); - if( n==0 || z[n-1]=='\'' || qrfSpace(z[n-1]) ) return 0; - if( p->spec.zNull && strcmp(p->spec.zNull,z)==0 ) return 0; - i = (z[0]=='-' || z[0]=='+'); - if( strcmp(z+i,"Inf")==0 ) return 0; - if( !qrfDigit(z[i]) ) return 1; - i++; - while( qrfDigit(z[i]) ){ i++; } - if( z[i]==0 ) return 0; - if( z[i]=='.' ){ - i++; - while( qrfDigit(z[i]) ){ i++; } - if( z[i]==0 ) return 0; - } - if( z[i]=='e' || z[i]=='E' ){ - i++; - if( z[i]=='+' || z[i]=='-' ){ i++; } - if( !qrfDigit(z[i]) ) return 1; - i++; - while( qrfDigit(z[i]) ){ i++; } - } - return z[i]!=0; -} - -/* -** If a field contains any character identified by a 1 in the following -** array, then the string must be quoted for CSV. -*/ -static const char qrfCsvQuote[] = { - 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, 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, 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, -}; - -/* -** Encode text appropriately and append it to pOut. -*/ -static void qrfEncodeText(Qrf *p, sqlite3_str *pOut, const char *zTxt){ - int iStart = sqlite3_str_length(pOut); - switch( p->spec.eText ){ - case QRF_TEXT_Relaxed: - if( qrfRelaxable(p, zTxt) ){ - sqlite3_str_appendall(pOut, zTxt); - break; - } - deliberate_fall_through; /* FALLTHRU */ - case QRF_TEXT_Sql: { - if( p->spec.eEsc==QRF_ESC_Off ){ - sqlite3_str_appendf(pOut, "%Q", zTxt); - }else{ - sqlite3_str_appendf(pOut, "%#Q", zTxt); - } - break; - } - case QRF_TEXT_Csv: { - unsigned int i; - for(i=0; zTxt[i]; i++){ - if( qrfCsvQuote[((const unsigned char*)zTxt)[i]] ){ - i = 0; - break; - } - } - if( i==0 || strstr(zTxt, p->spec.zColumnSep)!=0 ){ - sqlite3_str_appendf(pOut, "\"%w\"", zTxt); - }else{ - sqlite3_str_appendall(pOut, zTxt); - } - break; - } - case QRF_TEXT_Html: { - const unsigned char *z = (const unsigned char*)zTxt; - while( *z ){ - unsigned int i = 0; - unsigned char c; - while( (c=z[i])>'>' - || (c && c!='<' && c!='>' && c!='&' && c!='\"' && c!='\'') - ){ - i++; - } - if( i>0 ){ - sqlite3_str_append(pOut, (const char*)z, i); - } - switch( z[i] ){ - case '>': sqlite3_str_append(pOut, "<", 4); break; - case '&': sqlite3_str_append(pOut, "&", 5); break; - case '<': sqlite3_str_append(pOut, "<", 4); break; - case '"': sqlite3_str_append(pOut, """, 6); break; - case '\'': sqlite3_str_append(pOut, "'", 5); break; - default: i--; - } - z += i + 1; - } - break; - } - case QRF_TEXT_Tcl: - case QRF_TEXT_Json: { - const unsigned char *z = (const unsigned char*)zTxt; - sqlite3_str_append(pOut, "\"", 1); - while( *z ){ - unsigned int i; - for(i=0; z[i]>=0x20 && z[i]!='\\' && z[i]!='"'; i++){} - if( i>0 ){ - sqlite3_str_append(pOut, (const char*)z, i); - } - if( z[i]==0 ) break; - switch( z[i] ){ - case '"': sqlite3_str_append(pOut, "\\\"", 2); break; - case '\\': sqlite3_str_append(pOut, "\\\\", 2); break; - case '\b': sqlite3_str_append(pOut, "\\b", 2); break; - case '\f': sqlite3_str_append(pOut, "\\f", 2); break; - case '\n': sqlite3_str_append(pOut, "\\n", 2); break; - case '\r': sqlite3_str_append(pOut, "\\r", 2); break; - case '\t': sqlite3_str_append(pOut, "\\t", 2); break; - default: { - if( p->spec.eText==QRF_TEXT_Json ){ - sqlite3_str_appendf(pOut, "\\u%04x", z[i]); - }else{ - sqlite3_str_appendf(pOut, "\\%03o", z[i]); - } - break; - } - } - z += i + 1; - } - sqlite3_str_append(pOut, "\"", 1); - break; - } - default: { - sqlite3_str_appendall(pOut, zTxt); - break; - } - } - if( p->spec.eEsc!=QRF_ESC_Off ){ - qrfEscape(p->spec.eEsc, pOut, iStart); - } -} - -/* -** Do a quick sanity check to see aBlob[0..nBlob-1] is valid JSONB -** return true if it is and false if it is not. -** -** False positives are possible, but not false negatives. -*/ -static int qrfJsonbQuickCheck(unsigned char *aBlob, int nBlob){ - unsigned char x; /* Payload size half-byte */ - int i; /* Loop counter */ - int n; /* Bytes in the payload size integer */ - sqlite3_uint64 sz; /* value of the payload size integer */ - - if( nBlob==0 ) return 0; - x = aBlob[0]>>4; - if( x<=11 ) return nBlob==(1+x); - n = x<14 ? x-11 : 4*(x-13); - if( nBlob<1+n ) return 0; - sz = aBlob[1]; - for(i=1; ipStmt is known to be a BLOB. Check -** to see if that BLOB is really a JSONB blob. If it is, then translate -** it into a text JSON representation and return a pointer to that text JSON. -** If the BLOB is not JSONB, then return a NULL pointer. -** -** The memory used to hold the JSON text is managed internally by the -** "p" object and is overwritten and/or deallocated upon the next call -** to this routine (with the same p argument) or when the p object is -** finailized. -*/ -static const char *qrfJsonbToJson(Qrf *p, int iCol){ - int nByte; - const void *pBlob; - int rc; - nByte = sqlite3_column_bytes(p->pStmt, iCol); - pBlob = sqlite3_column_blob(p->pStmt, iCol); - if( qrfJsonbQuickCheck((unsigned char*)pBlob, nByte)==0 ){ - return 0; - } - if( p->pJTrans==0 ){ - sqlite3 *db; - rc = sqlite3_open(":memory:",&db); - if( rc ){ - sqlite3_close(db); - return 0; - } - rc = sqlite3_prepare_v2(db, "SELECT json(?1)", -1, &p->pJTrans, 0); - if( rc ){ - sqlite3_finalize(p->pJTrans); - p->pJTrans = 0; - sqlite3_close(db); - return 0; - } - }else{ - sqlite3_reset(p->pJTrans); - } - sqlite3_bind_blob(p->pJTrans, 1, (void*)pBlob, nByte, SQLITE_STATIC); - rc = sqlite3_step(p->pJTrans); - if( rc==SQLITE_ROW ){ - return (const char*)sqlite3_column_text(p->pJTrans, 0); - }else{ - return 0; - } -} - -/* -** Adjust the input string zIn[] such that it is no more than N display -** characters wide. If it is wider than that, then truncate and add -** ellipsis. Or if zIn[] contains a \r or \n, truncate at that point, -** adding ellipsis. Embedded tabs in zIn[] are converted into ordinary -** spaces. -** -** Return this display width of the modified title string. -*/ -static int qrfTitleLimit(char *zIn, int N){ - unsigned char *z = (unsigned char*)zIn; - int n = 0; - unsigned char *zEllipsis = 0; - while( 1 /*exit-by-break*/ ){ - if( z[0]<' ' ){ - int k; - if( z[0]==0 ){ - zEllipsis = 0; - break; - }else if( z[0]=='\033' && (k = qrfIsVt100(z))>0 ){ - z += k; - }else if( z[0]=='\t' ){ - z[0] = ' '; - }else if( z[0]=='\n' || z[0]=='\r' ){ - z[0] = ' '; - }else{ - z++; - } - }else if( (0x80&z[0])==0 ){ - if( n>=(N-3) && zEllipsis==0 ) zEllipsis = z; - if( n==N ){ z[0] = 0; break; } - n++; - z++; - }else{ - int u = 0; - int len = sqlite3_qrf_decode_utf8(z, &u); - if( n+len>(N-3) && zEllipsis==0 ) zEllipsis = z; - if( n+len>N ){ z[0] = 0; break; } - z += len; - n += sqlite3_qrf_wcwidth(u); - } - } - if( zEllipsis && N>=3 ) memcpy(zEllipsis,"...",4); - return n; -} - - -/* -** Render value pVal into pOut -*/ -static void qrfRenderValue(Qrf *p, sqlite3_str *pOut, int iCol){ -#if SQLITE_VERSION_NUMBER>=3052000 - int iStartLen = sqlite3_str_length(pOut); -#endif - if( p->spec.xRender ){ - sqlite3_value *pVal; - char *z; - pVal = sqlite3_value_dup(sqlite3_column_value(p->pStmt,iCol)); - z = p->spec.xRender(p->spec.pRenderArg, pVal); - sqlite3_value_free(pVal); - if( z ){ - sqlite3_str_appendall(pOut, z); - sqlite3_free(z); - return; - } - } - switch( sqlite3_column_type(p->pStmt,iCol) ){ - case SQLITE_INTEGER: { - sqlite3_str_appendf(pOut, "%lld", sqlite3_column_int64(p->pStmt,iCol)); - break; - } - case SQLITE_FLOAT: { - const char *zTxt = (const char*)sqlite3_column_text(p->pStmt,iCol); - sqlite3_str_appendall(pOut, zTxt); - break; - } - case SQLITE_BLOB: { - if( p->spec.bTextJsonb==QRF_Yes ){ - const char *zJson = qrfJsonbToJson(p, iCol); - if( zJson ){ - if( p->spec.eText==QRF_TEXT_Sql ){ - sqlite3_str_append(pOut,"jsonb(",6); - qrfEncodeText(p, pOut, zJson); - sqlite3_str_append(pOut,")",1); - }else{ - qrfEncodeText(p, pOut, zJson); - } - break; - } - } - switch( p->spec.eBlob ){ - case QRF_BLOB_Hex: - case QRF_BLOB_Sql: { - int iStart; - int nBlob = sqlite3_column_bytes(p->pStmt,iCol); - int i, j; - char *zVal; - const unsigned char *a = sqlite3_column_blob(p->pStmt,iCol); - if( p->spec.eBlob==QRF_BLOB_Sql ){ - sqlite3_str_append(pOut, "x'", 2); - } - iStart = sqlite3_str_length(pOut); - sqlite3_str_appendchar(pOut, nBlob, ' '); - sqlite3_str_appendchar(pOut, nBlob, ' '); - if( p->spec.eBlob==QRF_BLOB_Sql ){ - sqlite3_str_appendchar(pOut, 1, '\''); - } - if( sqlite3_str_errcode(pOut) ) return; - zVal = sqlite3_str_value(pOut); - for(i=0, j=iStart; i>4)&0xf]; - zVal[j+1] = "0123456789abcdef"[(c)&0xf]; - } - break; - } - case QRF_BLOB_Tcl: - case QRF_BLOB_Json: { - int iStart; - int nBlob = sqlite3_column_bytes(p->pStmt,iCol); - int i, j; - char *zVal; - const unsigned char *a = sqlite3_column_blob(p->pStmt,iCol); - int szC = p->spec.eBlob==QRF_BLOB_Json ? 6 : 4; - sqlite3_str_append(pOut, "\"", 1); - iStart = sqlite3_str_length(pOut); - for(i=szC; i>0; i--){ - sqlite3_str_appendchar(pOut, nBlob, ' '); - } - sqlite3_str_appendchar(pOut, 1, '"'); - if( sqlite3_str_errcode(pOut) ) return; - zVal = sqlite3_str_value(pOut); - for(i=0, j=iStart; i>6)&3); - zVal[j+2] = '0' + ((c>>3)&7); - zVal[j+3] = '0' + (c&7); - }else{ - zVal[j+1] = 'u'; - zVal[j+2] = '0'; - zVal[j+3] = '0'; - zVal[j+4] = "0123456789abcdef"[(c>>4)&0xf]; - zVal[j+5] = "0123456789abcdef"[(c)&0xf]; - } - } - break; - } - case QRF_BLOB_Size: { - int nBlob = sqlite3_column_bytes(p->pStmt,iCol); - sqlite3_str_appendf(pOut, "(%d-byte blob)", nBlob); - break; - } - default: { - const char *zTxt = (const char*)sqlite3_column_text(p->pStmt,iCol); - qrfEncodeText(p, pOut, zTxt); - } - } - break; - } - case SQLITE_NULL: { - sqlite3_str_appendall(pOut, p->spec.zNull); - break; - } - case SQLITE_TEXT: { - const char *zTxt = (const char*)sqlite3_column_text(p->pStmt,iCol); - qrfEncodeText(p, pOut, zTxt); - break; - } - } -#if SQLITE_VERSION_NUMBER>=3052000 - if( p->spec.nCharLimit>0 - && (sqlite3_str_length(pOut) - iStartLen) > p->spec.nCharLimit - ){ - const unsigned char *z; - int ii = 0, w = 0, limit = p->spec.nCharLimit; - z = (const unsigned char*)sqlite3_str_value(pOut) + iStartLen; - if( limit<4 ) limit = 4; - while( 1 ){ - if( z[ii]<' ' ){ - int k; - if( z[ii]=='\033' && (k = qrfIsVt100(z+ii))>0 ){ - ii += k; - }else if( z[ii]==0 ){ - break; - }else{ - ii++; - } - }else if( (0x80&z[ii])==0 ){ - w++; - if( w>limit ) break; - ii++; - }else{ - int u = 0; - int len = sqlite3_qrf_decode_utf8(&z[ii], &u); - w += sqlite3_qrf_wcwidth(u); - if( w>limit ) break; - ii += len; - } - } - if( w>limit ){ - sqlite3_str_truncate(pOut, iStartLen+ii); - sqlite3_str_append(pOut, "...", 3); - } - } -#endif -} - -/* Trim spaces of the end if pOut -*/ -static void qrfRTrim(sqlite3_str *pOut){ -#if SQLITE_VERSION_NUMBER>=3052000 - int nByte = sqlite3_str_length(pOut); - const char *zOut = sqlite3_str_value(pOut); - while( nByte>0 && zOut[nByte-1]==' ' ){ nByte--; } - sqlite3_str_truncate(pOut, nByte); -#endif -} - -/* -** Store string zUtf to pOut as w characters. If w is negative, -** then right-justify the text. W is the width in display characters, not -** in bytes. Double-width unicode characters count as two characters. -** VT100 escape sequences count as zero. And so forth. -*/ -static void qrfWidthPrint(Qrf *p, sqlite3_str *pOut, int w, const char *zUtf){ - const unsigned char *a = (const unsigned char*)zUtf; - static const int mxW = 10000000; - unsigned char c; - int i = 0; - int n = 0; - int k; - int aw; - (void)p; - if( w<-mxW ){ - w = -mxW; - }else if( w>mxW ){ - w= mxW; - } - aw = w<0 ? -w : w; - if( a==0 ) a = (const unsigned char*)""; - while( (c = a[i])!=0 ){ - if( (c&0xc0)==0xc0 ){ - int u; - int len = sqlite3_qrf_decode_utf8(a+i, &u); - int x = sqlite3_qrf_wcwidth(u); - if( x+n>aw ){ - break; - } - i += len; - n += x; - }else if( c==0x1b && (k = qrfIsVt100(&a[i]))>0 ){ - i += k; - }else if( n>=aw ){ - break; - }else{ - n++; - i++; - } - } - if( n>=aw ){ - sqlite3_str_append(pOut, zUtf, i); - }else if( w<0 ){ - if( aw>n ) sqlite3_str_appendchar(pOut, aw-n, ' '); - sqlite3_str_append(pOut, zUtf, i); - }else{ - sqlite3_str_append(pOut, zUtf, i); - if( aw>n ) sqlite3_str_appendchar(pOut, aw-n, ' '); - } -} - -/* -** (*pz)[] is a line of text that is to be displayed the box or table or -** similar tabular formats. z[] contain newlines or might be too wide -** to fit in the columns so will need to be split into multiple line. -** -** This routine determines: -** -** * How many bytes of z[] should be shown on the current line. -** * How many character positions those bytes will cover. -** * The byte offset to the start of the next line. -*/ -static void qrfWrapLine( - const char *zIn, /* Input text to be displayed */ - int w, /* Column width in characters (not bytes) */ - int bWrap, /* True if we should do word-wrapping */ - int *pnThis, /* OUT: How many bytes of z[] for the current line */ - int *pnWide, /* OUT: How wide is the text of this line */ - int *piNext /* OUT: Offset into z[] to start of the next line */ -){ - int i; /* Input bytes consumed */ - int k; /* Bytes in a VT100 code */ - int n; /* Output column number */ - const unsigned char *z = (const unsigned char*)zIn; - unsigned char c = 0; - - if( z[0]==0 ){ - *pnThis = 0; - *pnWide = 0; - *piNext = 0; - return; - } - n = 0; - for(i=0; n<=w; i++){ - c = z[i]; - if( c>=0xc0 ){ - int u; - int len = sqlite3_qrf_decode_utf8(&z[i], &u); - int wcw = sqlite3_qrf_wcwidth(u); - if( wcw+n>w ) break; - i += len-1; - n += wcw; - continue; - } - if( c>=' ' ){ - if( n==w ) break; - n++; - continue; - } - if( c==0 || c=='\n' ) break; - if( c=='\r' && z[i+1]=='\n' ){ c = z[++i]; break; } - if( c=='\t' ){ - int wcw = 8 - (n&7); - if( n+wcw>w ) break; - n += wcw; - continue; - } - if( c==0x1b && (k = qrfIsVt100(&z[i]))>0 ){ - i += k-1; - }else if( n==w ){ - break; - }else{ - n++; - } - } - if( c==0 ){ - *pnThis = i; - *pnWide = n; - *piNext = i; - return; - } - if( c=='\n' ){ - *pnThis = i; - *pnWide = n; - *piNext = i+1; - return; - } - - /* If we get this far, that means the current line will end at some - ** point that is neither a "\n" or a 0x00. Figure out where that - ** split should occur - */ - if( bWrap && z[i]!=0 && !qrfSpace(z[i]) && qrfAlnum(c)==qrfAlnum(z[i]) ){ - /* Perhaps try to back up to a better place to break the line */ - for(k=i-1; k>=i/2; k--){ - if( qrfSpace(z[k]) ) break; - } - if( k=i/2; k--){ - if( qrfAlnum(z[k-1])!=qrfAlnum(z[k]) && (z[k]&0xc0)!=0x80 ) break; - } - } - if( k>=i/2 ){ - i = k; - n = qrfDisplayWidth((const char*)z, k, 0); - } - } - *pnThis = i; - *pnWide = n; - while( zIn[i]==' ' || zIn[i]=='\t' || zIn[i]=='\r' ){ i++; } - *piNext = i; -} - -/* -** Append nVal bytes of text from zVal onto the end of pOut. -** Convert tab characters in zVal to the appropriate number of -** spaces. -*/ -static void qrfAppendWithTabs( - sqlite3_str *pOut, /* Append text here */ - const char *zVal, /* Text to append */ - int nVal /* Use only the first nVal bytes of zVal[] */ -){ - int i = 0; - unsigned int col = 0; - unsigned char *z = (unsigned char *)zVal; - while( i0 ){ - sqlite3_str_append(pOut, (const char*)z, k); - z += k; - nVal -= k; - }else if( c=='\t' ){ - k = 8 - (col&7); - sqlite3_str_appendchar(pOut, k, ' '); - col += k; - z++; - nVal--; - }else if( c=='\r' && nVal==1 ){ - z++; - nVal--; - }else{ - char zCtrlPik[4]; - col++; - zCtrlPik[0] = 0xe2; - zCtrlPik[1] = 0x90; - zCtrlPik[2] = 0x80+c; - sqlite3_str_append(pOut, zCtrlPik, 3); - z++; - nVal--; - } - }else if( (0x80&c)==0 ){ - i++; - col++; - }else{ - int u = 0; - int len = sqlite3_qrf_decode_utf8(&z[i], &u); - i += len; - col += sqlite3_qrf_wcwidth(u); - } - } - sqlite3_str_append(pOut, (const char*)z, i); -} - -/* -** GCC does not define the offsetof() macro so we'll have to do it -** ourselves. -*/ -#ifndef offsetof -# define offsetof(ST,M) ((size_t)((char*)&((ST*)0)->M - (char*)0)) -#endif - -/* -** Data for columnar layout, collected into a single object so -** that it can be more easily passed into subroutines. -*/ -typedef struct qrfColData qrfColData; -struct qrfColData { - Qrf *p; /* The QRF instance */ - int nCol; /* Number of columns in the table */ - unsigned char bMultiRow; /* One or more cells will span multiple lines */ - unsigned char nMargin; /* Width of column margins */ - sqlite3_int64 nRow; /* Number of rows */ - sqlite3_int64 nAlloc; /* Number of cells allocated */ - sqlite3_int64 n; /* Number of cells. nCol*nRow */ - char **az; /* Content of all cells */ - int *aiWth; /* Width of each cell */ - unsigned char *abNum; /* True for each numeric cell */ - struct qrfPerCol { /* Per-column data */ - char *z; /* Cache of text for current row */ - int w; /* Computed width of this column */ - int mxW; /* Maximum natural (unwrapped) width */ - unsigned char e; /* Alignment */ - unsigned char fx; /* Width is fixed */ - unsigned char bNum; /* True if is numeric */ - } *a; /* One per column */ -}; - -/* -** Output horizontally justified text into pOut. The text is the -** first nVal bytes of zVal. Include nWS bytes of whitespace, either -** split between both sides, or on the left, or on the right, depending -** on eAlign. -*/ -static void qrfPrintAligned( - sqlite3_str *pOut, /* Append text here */ - struct qrfPerCol *pCol, /* Information about the text to print */ - int nVal, /* Use only the first nVal bytes of zVal[] */ - int nWS /* Whitespace for horizonal alignment */ -){ - unsigned char eAlign = pCol->e & QRF_ALIGN_HMASK; - if( eAlign==QRF_Auto && pCol->bNum ) eAlign = QRF_ALIGN_Right; - if( eAlign==QRF_ALIGN_Center ){ - /* Center the text */ - sqlite3_str_appendchar(pOut, nWS/2, ' '); - qrfAppendWithTabs(pOut, pCol->z, nVal); - sqlite3_str_appendchar(pOut, nWS - nWS/2, ' '); - }else if( eAlign==QRF_ALIGN_Right ){ - /* Right justify the text */ - sqlite3_str_appendchar(pOut, nWS, ' '); - qrfAppendWithTabs(pOut, pCol->z, nVal); - }else{ - /* Left justify the text */ - qrfAppendWithTabs(pOut, pCol->z, nVal); - sqlite3_str_appendchar(pOut, nWS, ' '); - } -} - -/* -** Free all the memory allocates in the qrfColData object -*/ -static void qrfColDataFree(qrfColData *p){ - sqlite3_int64 i; - for(i=0; in; i++) sqlite3_free(p->az[i]); - sqlite3_free(p->az); - sqlite3_free(p->aiWth); - sqlite3_free(p->abNum); - sqlite3_free(p->a); - memset(p, 0, sizeof(*p)); -} - -/* -** Allocate space for more cells in the qrfColData object. -** Return non-zero if a memory allocation fails. -*/ -static int qrfColDataEnlarge(qrfColData *p){ - char **azData; - int *aiWth; - unsigned char *abNum; - p->nAlloc = 2*p->nAlloc + 10*p->nCol; - azData = sqlite3_realloc64(p->az, p->nAlloc*sizeof(char*)); - if( azData==0 ){ - qrfOom(p->p); - qrfColDataFree(p); - return 1; - } - p->az = azData; - aiWth = sqlite3_realloc64(p->aiWth, p->nAlloc*sizeof(int)); - if( aiWth==0 ){ - qrfOom(p->p); - qrfColDataFree(p); - return 1; - } - p->aiWth = aiWth; - abNum = sqlite3_realloc64(p->abNum, p->nAlloc); - if( abNum==0 ){ - qrfOom(p->p); - qrfColDataFree(p); - return 1; - } - p->abNum = abNum; - return 0; -} - -/* -** Print a markdown or table-style row separator using ascii-art -*/ -static void qrfRowSeparator(sqlite3_str *pOut, qrfColData *p, char cSep){ - int i; - if( p->nCol>0 ){ - int useBorder = p->p->spec.bBorder!=QRF_No; - if( useBorder ){ - sqlite3_str_append(pOut, &cSep, 1); - } - sqlite3_str_appendchar(pOut, p->a[0].w+p->nMargin, '-'); - for(i=1; inCol; i++){ - sqlite3_str_append(pOut, &cSep, 1); - sqlite3_str_appendchar(pOut, p->a[i].w+p->nMargin, '-'); - } - if( useBorder ){ - sqlite3_str_append(pOut, &cSep, 1); - } - } - sqlite3_str_append(pOut, "\n", 1); -} - -/* -** UTF8 box-drawing characters. Imagine box lines like this: -** -** 1 -** | -** 4 --+-- 2 -** | -** 3 -** -** Each box characters has between 2 and 4 of the lines leading from -** the center. The characters are here identified by the numbers of -** their corresponding lines. -*/ -#define BOX_24 "\342\224\200" /* U+2500 --- */ -#define BOX_13 "\342\224\202" /* U+2502 | */ -#define BOX_23 "\342\224\214" /* U+250c ,- */ -#define BOX_34 "\342\224\220" /* U+2510 -, */ -#define BOX_12 "\342\224\224" /* U+2514 '- */ -#define BOX_14 "\342\224\230" /* U+2518 -' */ -#define BOX_123 "\342\224\234" /* U+251c |- */ -#define BOX_134 "\342\224\244" /* U+2524 -| */ -#define BOX_234 "\342\224\254" /* U+252c -,- */ -#define BOX_124 "\342\224\264" /* U+2534 -'- */ -#define BOX_1234 "\342\224\274" /* U+253c -|- */ - -/* Rounded corners: */ -#define BOX_R12 "\342\225\260" /* U+2570 '- */ -#define BOX_R23 "\342\225\255" /* U+256d ,- */ -#define BOX_R34 "\342\225\256" /* U+256e -, */ -#define BOX_R14 "\342\225\257" /* U+256f -' */ - -/* Doubled horizontal lines: */ -#define DBL_24 "\342\225\220" /* U+2550 === */ -#define DBL_123 "\342\225\236" /* U+255e |= */ -#define DBL_134 "\342\225\241" /* U+2561 =| */ -#define DBL_1234 "\342\225\252" /* U+256a =|= */ - -/* Draw horizontal line N characters long using unicode box -** characters -*/ -static void qrfBoxLine(sqlite3_str *pOut, int N, int bDbl){ - const char *azDash[2] = { - BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24 BOX_24, - DBL_24 DBL_24 DBL_24 DBL_24 DBL_24 DBL_24 DBL_24 DBL_24 DBL_24 DBL_24 - };/* 0 1 2 3 4 5 6 7 8 9 */ - const int nDash = 30; - N *= 3; - while( N>nDash ){ - sqlite3_str_append(pOut, azDash[bDbl], nDash); - N -= nDash; - } - sqlite3_str_append(pOut, azDash[bDbl], N); -} - -/* -** Draw a horizontal separator for a QRF_STYLE_Box table. -*/ -static void qrfBoxSeparator( - sqlite3_str *pOut, - qrfColData *p, - const char *zSep1, - const char *zSep2, - const char *zSep3, - int bDbl -){ - int i; - if( p->nCol>0 ){ - int useBorder = p->p->spec.bBorder!=QRF_No; - if( useBorder ){ - sqlite3_str_appendall(pOut, zSep1); - } - qrfBoxLine(pOut, p->a[0].w+p->nMargin, bDbl); - for(i=1; inCol; i++){ - sqlite3_str_appendall(pOut, zSep2); - qrfBoxLine(pOut, p->a[i].w+p->nMargin, bDbl); - } - if( useBorder ){ - sqlite3_str_appendall(pOut, zSep3); - } - } - sqlite3_str_append(pOut, "\n", 1); -} - -/* -** Load into pData the default alignment for the body of a table. -*/ -static void qrfLoadAlignment(qrfColData *pData, Qrf *p){ - sqlite3_int64 i; - for(i=0; inCol; i++){ - pData->a[i].e = p->spec.eDfltAlign; - if( ispec.nAlign ){ - unsigned char ax = p->spec.aAlign[i]; - if( (ax & QRF_ALIGN_HMASK)!=0 ){ - pData->a[i].e = (ax & QRF_ALIGN_HMASK) | - (pData->a[i].e & QRF_ALIGN_VMASK); - } - }else if( ispec.nWidth ){ - if( p->spec.aWidth[i]<0 ){ - pData->a[i].e = QRF_ALIGN_Right | - (pData->a[i].e & QRF_ALIGN_VMASK); - } - } - } -} - -/* -** If the single column in pData->a[] with pData->n entries can be -** laid out as nCol columns with a 2-space gap between each such -** that all columns fit within nSW, then return a pointer to an array -** of integers which is the width of each column from left to right. -** -** If the layout is not possible, return a NULL pointer. -** -** Space to hold the returned array is from sqlite_malloc64(). -*/ -static int *qrfValidLayout( - qrfColData *pData, /* Collected query results */ - Qrf *p, /* On which to report an OOM */ - int nCol, /* Attempt this many columns */ - int nSW /* Screen width */ -){ - int i; /* Loop counter */ - int nr; /* Number of rows */ - int w = 0; /* Width of the current column */ - int t; /* Total width of all columns */ - int *aw; /* Array of individual column widths */ - - aw = sqlite3_malloc64( sizeof(int)*nCol ); - if( aw==0 ){ - qrfOom(p); - return 0; - } - nr = (pData->n + nCol - 1)/nCol; - for(i=0; in; i++){ - if( (i%nr)==0 ){ - if( i>0 ) aw[i/nr-1] = w; - w = pData->aiWth[i]; - }else if( pData->aiWth[i]>w ){ - w = pData->aiWth[i]; - } - } - aw[nCol-1] = w; - for(t=i=0; inSW ){ - sqlite3_free(aw); - return 0; - } - return aw; -} - -/* -** The output is single-column and the bSplitColumn flag is set. -** Check to see if the single-column output can be split into multiple -** columns that appear side-by-side. Adjust pData appropriately. -*/ -static void qrfSplitColumn(qrfColData *pData, Qrf *p){ - int nCol = 1; - int *aw = 0; - char **az = 0; - int *aiWth = 0; - unsigned char *abNum = 0; - int nColNext = 2; - int w; - struct qrfPerCol *a = 0; - sqlite3_int64 nRow = 1; - sqlite3_int64 i; - while( 1/*exit-by-break*/ ){ - int *awNew = qrfValidLayout(pData, p, nColNext, p->spec.nScreenWidth); - if( awNew==0 ) break; - sqlite3_free(aw); - aw = awNew; - nCol = nColNext; - nRow = (pData->n + nCol - 1)/nCol; - if( nRow==1 ) break; - nColNext++; - while( (pData->n + nColNext - 1)/nColNext == nRow ) nColNext++; - } - if( nCol==1 ){ - sqlite3_free(aw); - return; /* Cannot do better than 1 column */ - } - az = sqlite3_malloc64( nRow*nCol*sizeof(char*) ); - if( az==0 ){ - qrfOom(p); - return; - } - aiWth = sqlite3_malloc64( nRow*nCol*sizeof(int) ); - if( aiWth==0 ){ - sqlite3_free(az); - qrfOom(p); - return; - } - a = sqlite3_malloc64( nCol*sizeof(struct qrfPerCol) ); - if( a==0 ){ - sqlite3_free(az); - sqlite3_free(aiWth); - qrfOom(p); - return; - } - abNum = sqlite3_malloc64( nRow*nCol ); - if( abNum==0 ){ - sqlite3_free(az); - sqlite3_free(aiWth); - sqlite3_free(a); - qrfOom(p); - return; - } - for(i=0; in; i++){ - sqlite3_int64 j = (i%nRow)*nCol + (i/nRow); - az[j] = pData->az[i]; - abNum[j]= pData->abNum[i]; - pData->az[i] = 0; - aiWth[j] = pData->aiWth[i]; - } - while( ia[0].e; - } - sqlite3_free(pData->az); - sqlite3_free(pData->aiWth); - sqlite3_free(pData->a); - sqlite3_free(pData->abNum); - sqlite3_free(aw); - pData->az = az; - pData->aiWth = aiWth; - pData->a = a; - pData->abNum = abNum; - pData->nCol = nCol; - pData->n = pData->nAlloc = nRow*nCol; - for(i=w=0; inMargin = (p->spec.nScreenWidth - w)/(nCol - 1); - if( pData->nMargin>5 ) pData->nMargin = 5; -} - -/* -** Adjust the layout for the screen width restriction -*/ -static void qrfRestrictScreenWidth(qrfColData *pData, Qrf *p){ - int sepW; /* Width of all box separators and margins */ - int sumW; /* Total width of data area over all columns */ - int targetW; /* Desired total data area */ - int i; /* Loop counters */ - int nCol; /* Number of columns */ - - pData->nMargin = 2; /* Default to normal margins */ - if( p->spec.nScreenWidth==0 ) return; - if( p->spec.eStyle==QRF_STYLE_Column ){ - sepW = pData->nCol*2 - 2; - }else{ - sepW = pData->nCol*3 + 1; - if( p->spec.bBorder==QRF_No ) sepW -= 2; - } - nCol = pData->nCol; - for(i=sumW=0; ia[i].w; - if( p->spec.nScreenWidth >= sumW+sepW ) return; - - /* First thing to do is reduce the separation between columns */ - pData->nMargin = 0; - if( p->spec.eStyle==QRF_STYLE_Column ){ - sepW = pData->nCol - 1; - }else{ - sepW = pData->nCol + 1; - if( p->spec.bBorder==QRF_No ) sepW -= 2; - } - targetW = p->spec.nScreenWidth - sepW; - -#define MIN_SQUOZE 8 -#define MIN_EX_SQUOZE 16 - /* Reduce the width of the widest eligible column. A column is - ** eligible for narrowing if: - ** - ** * It is not a fixed-width column (a[0].fx is false) - ** * The current width is more than MIN_SQUOZE - ** * Either: - ** + The current width is more then MIN_EX_SQUOZE, or - ** + The current width is more than half the max width (a[].mxW) - ** - ** Keep making reductions until either no more reductions are - ** possible or until the size target is reached. - */ - while( sumW > targetW ){ - int gain, w; - int ix = -1; - int mx = 0; - for(i=0; ia[i].fx==0 - && (w = pData->a[i].w)>mx - && w>MIN_SQUOZE - && (w>MIN_EX_SQUOZE || w*2>pData->a[i].mxW) - ){ - ix = i; - mx = w; - } - } - if( ix<0 ) break; - if( mx>=MIN_SQUOZE*2 ){ - gain = mx/2; - }else{ - gain = mx - MIN_SQUOZE; - } - if( sumW - gain < targetW ){ - gain = sumW - targetW; - } - sumW -= gain; - pData->a[ix].w -= gain; - pData->bMultiRow = 1; - } -} - -/* -** Columnar modes require that the entire query be evaluated first, with -** results written into memory, so that we can compute appropriate column -** widths. -*/ -static void qrfColumnar(Qrf *p){ - sqlite3_int64 i, j; /* Loop counters */ - const char *colSep = 0; /* Column separator text */ - const char *rowSep = 0; /* Row terminator text */ - const char *rowStart = 0; /* Row start text */ - int szColSep, szRowSep, szRowStart; /* Size in bytes of previous 3 */ - int rc; /* Result code */ - int nColumn = p->nCol; /* Number of columns */ - int bWW; /* True to do word-wrap */ - sqlite3_str *pStr; /* Temporary rendering */ - qrfColData data; /* Columnar layout data */ - int bRTrim; /* Trim trailing space */ - - rc = sqlite3_step(p->pStmt); - if( rc!=SQLITE_ROW || nColumn==0 ){ - return; /* No output */ - } - - /* Initialize the data container */ - memset(&data, 0, sizeof(data)); - data.nCol = p->nCol; - data.p = p; - data.a = sqlite3_malloc64( nColumn*sizeof(struct qrfPerCol) ); - if( data.a==0 ){ - qrfOom(p); - return; - } - memset(data.a, 0, nColumn*sizeof(struct qrfPerCol) ); - if( qrfColDataEnlarge(&data) ) return; - assert( data.az!=0 ); - - /* Load the column header names and all cell content into data */ - if( p->spec.bTitles==QRF_Yes ){ - unsigned char saved_eText = p->spec.eText; - p->spec.eText = p->spec.eTitle; - memset(data.abNum, 0, nColumn); - for(i=0; ipStmt,i); - int nNL = 0; - int n, w; - pStr = sqlite3_str_new(p->db); - qrfEncodeText(p, pStr, z ? z : ""); - n = sqlite3_str_length(pStr); - qrfStrErr(p, pStr); - z = data.az[data.n] = sqlite3_str_finish(pStr); - if( p->spec.nTitleLimit ){ - nNL = 0; - data.aiWth[data.n] = w = qrfTitleLimit(data.az[data.n], - p->spec.nTitleLimit ); - }else{ - data.aiWth[data.n] = w = qrfDisplayWidth(z, n, &nNL); - } - data.n++; - if( w>data.a[i].mxW ) data.a[i].mxW = w; - if( nNL ) data.bMultiRow = 1; - } - p->spec.eText = saved_eText; - p->nRow++; - } - do{ - if( data.n+nColumn > data.nAlloc ){ - if( qrfColDataEnlarge(&data) ) return; - } - for(i=0; ipStmt,i); - pStr = sqlite3_str_new(p->db); - qrfRenderValue(p, pStr, i); - n = sqlite3_str_length(pStr); - qrfStrErr(p, pStr); - z = data.az[data.n] = sqlite3_str_finish(pStr); - data.abNum[data.n] = eType==SQLITE_INTEGER || eType==SQLITE_FLOAT; - data.aiWth[data.n] = w = qrfDisplayWidth(z, n, &nNL); - data.n++; - if( w>data.a[i].mxW ) data.a[i].mxW = w; - if( nNL ) data.bMultiRow = 1; - } - p->nRow++; - }while( sqlite3_step(p->pStmt)==SQLITE_ROW && p->iErr==SQLITE_OK ); - if( p->iErr ){ - qrfColDataFree(&data); - return; - } - - /* Compute the width and alignment of every column */ - if( p->spec.bTitles==QRF_No ){ - qrfLoadAlignment(&data, p); - }else{ - unsigned char e; - if( p->spec.eTitleAlign==QRF_Auto ){ - e = QRF_ALIGN_Center; - }else{ - e = p->spec.eTitleAlign; - } - for(i=0; ispec.nWidth ){ - w = p->spec.aWidth[i]; - if( w==(-32768) ){ - w = 0; - if( p->spec.nAlign>i && (p->spec.aAlign[i] & QRF_ALIGN_HMASK)==0 ){ - data.a[i].e |= QRF_ALIGN_Right; - } - }else if( w<0 ){ - w = -w; - if( p->spec.nAlign>i && (p->spec.aAlign[i] & QRF_ALIGN_HMASK)==0 ){ - data.a[i].e |= QRF_ALIGN_Right; - } - } - if( w ) data.a[i].fx = 1; - } - if( w==0 ){ - w = data.a[i].mxW; - if( p->spec.nWrap>0 && w>p->spec.nWrap ){ - w = p->spec.nWrap; - data.bMultiRow = 1; - } - }else if( (data.bMultiRow==0 || w==1) && data.a[i].mxW>w ){ - data.bMultiRow = 1; - if( w==1 ){ - /* If aiWth[j] is 2 or more, then there might be a double-wide - ** character somewhere. So make the column width at least 2. */ - w = 2; - } - } - data.a[i].w = w; - } - - if( nColumn==1 - && data.n>1 - && p->spec.bSplitColumn==QRF_Yes - && p->spec.eStyle==QRF_STYLE_Column - && p->spec.bTitles==QRF_No - && p->spec.nScreenWidth>data.a[0].w+3 - ){ - /* Attempt to convert single-column tables into multi-column by - ** verticle wrapping, if the screen is wide enough and if the - ** bSplitColumn flag is set. */ - qrfSplitColumn(&data, p); - nColumn = data.nCol; - }else{ - /* Adjust the column widths due to screen width restrictions */ - qrfRestrictScreenWidth(&data, p); - } - - /* Draw the line across the top of the table. Also initialize - ** the row boundary and column separator texts. */ - switch( p->spec.eStyle ){ - case QRF_STYLE_Box: - if( data.nMargin ){ - rowStart = BOX_13 " "; - colSep = " " BOX_13 " "; - rowSep = " " BOX_13 "\n"; - }else{ - rowStart = BOX_13; - colSep = BOX_13; - rowSep = BOX_13 "\n"; - } - if( p->spec.bBorder==QRF_No){ - rowStart += 3; - rowSep = "\n"; - }else{ - qrfBoxSeparator(p->pOut, &data, BOX_R23, BOX_234, BOX_R34, 0); - } - break; - case QRF_STYLE_Table: - if( data.nMargin ){ - rowStart = "| "; - colSep = " | "; - rowSep = " |\n"; - }else{ - rowStart = "|"; - colSep = "|"; - rowSep = "|\n"; - } - if( p->spec.bBorder==QRF_No ){ - rowStart += 1; - rowSep = "\n"; - }else{ - qrfRowSeparator(p->pOut, &data, '+'); - } - break; - case QRF_STYLE_Column: { - static const char zSpace[] = " "; - rowStart = ""; - if( data.nMargin<2 ){ - colSep = " "; - }else if( data.nMargin<=5 ){ - colSep = &zSpace[5-data.nMargin]; - }else{ - colSep = zSpace; - } - rowSep = "\n"; - break; - } - default: /*case QRF_STYLE_Markdown:*/ - if( data.nMargin ){ - rowStart = "| "; - colSep = " | "; - rowSep = " |\n"; - }else{ - rowStart = "|"; - colSep = "|"; - rowSep = "|\n"; - } - break; - } - szRowStart = (int)strlen(rowStart); - szRowSep = (int)strlen(rowSep); - szColSep = (int)strlen(colSep); - - bWW = (p->spec.bWordWrap==QRF_Yes && data.bMultiRow); - if( p->spec.eStyle==QRF_STYLE_Column - || (p->spec.bBorder==QRF_No - && (p->spec.eStyle==QRF_STYLE_Box || p->spec.eStyle==QRF_STYLE_Table) - ) - ){ - bRTrim = 1; - }else{ - bRTrim = 0; - } - for(i=0; ipOut)==SQLITE_OK; i+=nColumn){ - int bMore; - int nRow = 0; - - /* Draw a single row of the table. This might be the title line - ** (if there is a title line) or a row in the body of the table. - ** The column number will be j. The row number is i/nColumn. - */ - for(j=0; jpOut, rowStart, szRowStart); - bMore = 0; - for(j=0; jpOut, &data.a[j], nThis, nWS); - data.a[j].z += iNext; - if( data.a[j].z[0]!=0 ){ - bMore = 1; - } - if( jpOut, colSep, szColSep); - }else{ - if( bRTrim ) qrfRTrim(p->pOut); - sqlite3_str_append(p->pOut, rowSep, szRowSep); - } - } - }while( bMore && ++nRow < p->mxHeight ); - if( bMore ){ - /* This row was terminated by nLineLimit. Show ellipsis. */ - sqlite3_str_append(p->pOut, rowStart, szRowStart); - for(j=0; jpOut, data.a[j].w, ' '); - }else{ - int nE = 3; - if( nE>data.a[j].w ) nE = data.a[j].w; - data.a[j].z = "..."; - qrfPrintAligned(p->pOut, &data.a[j], nE, data.a[j].w-nE); - } - if( jpOut, colSep, szColSep); - }else{ - if( bRTrim ) qrfRTrim(p->pOut); - sqlite3_str_append(p->pOut, rowSep, szRowSep); - } - } - } - - /* Draw either (1) the separator between the title line and the body - ** of the table, or (2) separators between individual rows of the table - ** body. isTitleDataSeparator will be true if we are doing (1). - */ - if( (i==0 || data.bMultiRow) && i+nColumnspec.bTitles==QRF_Yes); - if( isTitleDataSeparator ){ - qrfLoadAlignment(&data, p); - } - switch( p->spec.eStyle ){ - case QRF_STYLE_Table: { - if( isTitleDataSeparator || data.bMultiRow ){ - qrfRowSeparator(p->pOut, &data, '+'); - } - break; - } - case QRF_STYLE_Box: { - if( isTitleDataSeparator ){ - qrfBoxSeparator(p->pOut, &data, DBL_123, DBL_1234, DBL_134, 1); - }else if( data.bMultiRow ){ - qrfBoxSeparator(p->pOut, &data, BOX_123, BOX_1234, BOX_134, 0); - } - break; - } - case QRF_STYLE_Markdown: { - if( isTitleDataSeparator ){ - qrfRowSeparator(p->pOut, &data, '|'); - } - break; - } - case QRF_STYLE_Column: { - if( isTitleDataSeparator ){ - for(j=0; jpOut, data.a[j].w, '-'); - if( jpOut, colSep, szColSep); - }else{ - qrfRTrim(p->pOut); - sqlite3_str_append(p->pOut, rowSep, szRowSep); - } - } - }else if( data.bMultiRow ){ - qrfRTrim(p->pOut); - sqlite3_str_append(p->pOut, "\n", 1); - } - break; - } - } - } - } - - /* Draw the line across the bottom of the table */ - if( p->spec.bBorder!=QRF_No ){ - switch( p->spec.eStyle ){ - case QRF_STYLE_Box: - qrfBoxSeparator(p->pOut, &data, BOX_R12, BOX_124, BOX_R14, 0); - break; - case QRF_STYLE_Table: - qrfRowSeparator(p->pOut, &data, '+'); - break; - } - } - qrfWrite(p); - - qrfColDataFree(&data); - return; -} - -/* -** Parameter azArray points to a zero-terminated array of strings. zStr -** points to a single nul-terminated string. Return non-zero if zStr -** is equal, according to strcmp(), to any of the strings in the array. -** Otherwise, return zero. -*/ -static int qrfStringInArray(const char *zStr, const char **azArray){ - int i; - if( zStr==0 ) return 0; - for(i=0; azArray[i]; i++){ - if( 0==strcmp(zStr, azArray[i]) ) return 1; - } - return 0; -} - -/* -** Print out an EXPLAIN with indentation. This is a two-pass algorithm. -** -** On the first pass, we compute aiIndent[iOp] which is the amount of -** indentation to apply to the iOp-th opcode. The output actually occurs -** on the second pass. -** -** The indenting rules are: -** -** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent -** all opcodes that occur between the p2 jump destination and the opcode -** itself by 2 spaces. -** -** * Do the previous for "Return" instructions for when P2 is positive. -** See tag-20220407a in wherecode.c and vdbe.c. -** -** * For each "Goto", if the jump destination is earlier in the program -** and ends on one of: -** Yield SeekGt SeekLt RowSetRead Rewind -** or if the P1 parameter is one instead of zero, -** then indent all opcodes between the earlier instruction -** and "Goto" by 2 spaces. -*/ -static void qrfExplain(Qrf *p){ - int *abYield = 0; /* abYield[iOp] is rue if opcode iOp is an OP_Yield */ - int *aiIndent = 0; /* Indent the iOp-th opcode by aiIndent[iOp] */ - i64 nAlloc = 0; /* Allocated size of aiIndent[], abYield */ - int nIndent = 0; /* Number of entries in aiIndent[] */ - int iOp; /* Opcode number */ - int i; /* Column loop counter */ - - const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", - "Return", 0 }; - const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead", - "Rewind", 0 }; - const char *azGoto[] = { "Goto", 0 }; - - /* The caller guarantees that the leftmost 4 columns of the statement - ** passed to this function are equivalent to the leftmost 4 columns - ** of EXPLAIN statement output. In practice the statement may be - ** an EXPLAIN, or it may be a query on the bytecode() virtual table. */ - assert( sqlite3_column_count(p->pStmt)>=4 ); - assert( 0==sqlite3_stricmp( sqlite3_column_name(p->pStmt, 0), "addr" ) ); - assert( 0==sqlite3_stricmp( sqlite3_column_name(p->pStmt, 1), "opcode" ) ); - assert( 0==sqlite3_stricmp( sqlite3_column_name(p->pStmt, 2), "p1" ) ); - assert( 0==sqlite3_stricmp( sqlite3_column_name(p->pStmt, 3), "p2" ) ); - - for(iOp=0; SQLITE_ROW==sqlite3_step(p->pStmt) && !p->iErr; iOp++){ - int iAddr = sqlite3_column_int(p->pStmt, 0); - const char *zOp = (const char*)sqlite3_column_text(p->pStmt, 1); - int p1 = sqlite3_column_int(p->pStmt, 2); - int p2 = sqlite3_column_int(p->pStmt, 3); - - /* Assuming that p2 is an instruction address, set variable p2op to the - ** index of that instruction in the aiIndent[] array. p2 and p2op may be - ** different if the current instruction is part of a sub-program generated - ** by an SQL trigger or foreign key. */ - int p2op = (p2 + (iOp-iAddr)); - - /* Grow the aiIndent array as required */ - if( iOp>=nAlloc ){ - nAlloc += 100; - aiIndent = (int*)sqlite3_realloc64(aiIndent, nAlloc*sizeof(int)); - abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int)); - if( aiIndent==0 || abYield==0 ){ - qrfOom(p); - sqlite3_free(aiIndent); - sqlite3_free(abYield); - return; - } - } - - abYield[iOp] = qrfStringInArray(zOp, azYield); - aiIndent[iOp] = 0; - nIndent = iOp+1; - if( qrfStringInArray(zOp, azNext) && p2op>0 ){ - for(i=p2op; ipStmt); - if( p->iErr==SQLITE_OK ){ - static const int aExplainWidth[] = {4, 13, 4, 4, 4, 13, 2, 13}; - static const int aExplainMap[] = {0, 1, 2, 3, 4, 5, 6, 7 }; - static const int aScanExpWidth[] = {4,15, 6, 13, 4, 4, 4, 13, 2, 13}; - static const int aScanExpMap[] = {0, 9, 8, 1, 2, 3, 4, 5, 6, 7 }; - const int *aWidth = aExplainWidth; - const int *aMap = aExplainMap; - int nWidth = sizeof(aExplainWidth)/sizeof(int); - int iIndent = 1; - int nArg = p->nCol; - if( p->spec.eStyle==QRF_STYLE_StatsVm ){ - aWidth = aScanExpWidth; - aMap = aScanExpMap; - nWidth = sizeof(aScanExpWidth)/sizeof(int); - iIndent = 3; - } - if( nArg>nWidth ) nArg = nWidth; - - for(iOp=0; sqlite3_step(p->pStmt)==SQLITE_ROW && !p->iErr; iOp++){ - /* If this is the first row seen, print out the headers */ - if( iOp==0 ){ - for(i=0; ipStmt, aMap[i]); - qrfWidthPrint(p,p->pOut, aWidth[i], zCol); - if( i==nArg-1 ){ - sqlite3_str_append(p->pOut, "\n", 1); - }else{ - sqlite3_str_append(p->pOut, " ", 2); - } - } - for(i=0; ipOut, "%.*c", aWidth[i], '-'); - if( i==nArg-1 ){ - sqlite3_str_append(p->pOut, "\n", 1); - }else{ - sqlite3_str_append(p->pOut, " ", 2); - } - } - } - - for(i=0; ipStmt, aMap[i]); - int len; - if( i==nArg-1 ) w = 0; - if( zVal==0 ) zVal = ""; - len = (int)sqlite3_qrf_wcswidth(zVal); - if( len>w ){ - w = len; - zSep = " "; - } - if( i==iIndent && aiIndent && iOppOut, aiIndent[iOp], ' '); - } - qrfWidthPrint(p, p->pOut, w, zVal); - if( i==nArg-1 ){ - sqlite3_str_append(p->pOut, "\n", 1); - }else{ - sqlite3_str_appendall(p->pOut, zSep); - } - } - p->nRow++; - } - qrfWrite(p); - } - sqlite3_free(aiIndent); -} - -/* -** Do a "scanstatus vm" style EXPLAIN listing on p->pStmt. -** -** p->pStmt is probably not an EXPLAIN query. Instead, construct a -** new query that is a bytecode() rendering of p->pStmt with extra -** columns for the "scanstatus vm" outputs, and run the results of -** that new query through the normal EXPLAIN formatting. -*/ -static void qrfScanStatusVm(Qrf *p){ - sqlite3_stmt *pOrigStmt = p->pStmt; - sqlite3_stmt *pExplain; - int rc; - static const char *zSql = - " SELECT addr, opcode, p1, p2, p3, p4, p5, comment, nexec," - " format('% 6s (%.2f%%)'," - " CASE WHEN ncycle<100_000 THEN ncycle || ' '" - " WHEN ncycle<100_000_000 THEN (ncycle/1_000) || 'K'" - " WHEN ncycle<100_000_000_000 THEN (ncycle/1_000_000) || 'M'" - " ELSE (ncycle/1000_000_000) || 'G' END," - " ncycle*100.0/(sum(ncycle) OVER ())" - " ) AS cycles" - " FROM bytecode(?1)"; - rc = sqlite3_prepare_v2(p->db, zSql, -1, &pExplain, 0); - if( rc ){ - qrfError(p, rc, "%s", sqlite3_errmsg(p->db)); - sqlite3_finalize(pExplain); - return; - } - sqlite3_bind_pointer(pExplain, 1, pOrigStmt, "stmt-pointer", 0); - p->pStmt = pExplain; - p->nCol = 10; - qrfExplain(p); - sqlite3_finalize(pExplain); - p->pStmt = pOrigStmt; -} - -/* -** Attempt to determine if identifier zName needs to be quoted, either -** because it contains non-alphanumeric characters, or because it is an -** SQLite keyword. Be conservative in this estimate: When in doubt assume -** that quoting is required. -** -** Return 1 if quoting is required. Return 0 if no quoting is required. -*/ - -static int qrf_need_quote(const char *zName){ - int i; - const unsigned char *z = (const unsigned char*)zName; - if( z==0 ) return 1; - if( !qrfAlpha(z[0]) ) return 1; - for(i=0; z[i]; i++){ - if( !qrfAlnum(z[i]) ) return 1; - } - return sqlite3_keyword_check(zName, i)!=0; -} - -/* -** Helper function for QRF_STYLE_Json and QRF_STYLE_JObject. -** The initial "{" for a JSON object that will contain row content -** has been output. Now output all the content. -*/ -static void qrfOneJsonRow(Qrf *p){ - int i, nItem; - for(nItem=i=0; inCol; i++){ - const char *zCName; - zCName = sqlite3_column_name(p->pStmt, i); - if( nItem>0 ) sqlite3_str_append(p->pOut, ",", 1); - nItem++; - qrfEncodeText(p, p->pOut, zCName); - sqlite3_str_append(p->pOut, ":", 1); - qrfRenderValue(p, p->pOut, i); - } - qrfWrite(p); -} - -/* -** Render a single row of output for non-columnar styles - any -** style that lets us render row by row as the content is received -** from the query. -*/ -static void qrfOneSimpleRow(Qrf *p){ - int i; - switch( p->spec.eStyle ){ - case QRF_STYLE_Off: - case QRF_STYLE_Count: { - /* No-op */ - break; - } - case QRF_STYLE_Json: { - if( p->nRow==0 ){ - sqlite3_str_append(p->pOut, "[{", 2); - }else{ - sqlite3_str_append(p->pOut, "},\n{", 4); - } - qrfOneJsonRow(p); - break; - } - case QRF_STYLE_JObject: { - if( p->nRow==0 ){ - sqlite3_str_append(p->pOut, "{", 1); - }else{ - sqlite3_str_append(p->pOut, "}\n{", 3); - } - qrfOneJsonRow(p); - break; - } - case QRF_STYLE_Html: { - if( p->nRow==0 && p->spec.bTitles==QRF_Yes ){ - sqlite3_str_append(p->pOut, "", 4); - for(i=0; inCol; i++){ - const char *zCName = sqlite3_column_name(p->pStmt, i); - sqlite3_str_append(p->pOut, "\n", 5); - qrfEncodeText(p, p->pOut, zCName); - } - sqlite3_str_append(p->pOut, "\n\n", 7); - } - sqlite3_str_append(p->pOut, "", 4); - for(i=0; inCol; i++){ - sqlite3_str_append(p->pOut, "\n", 5); - qrfRenderValue(p, p->pOut, i); - } - sqlite3_str_append(p->pOut, "\n\n", 7); - qrfWrite(p); - break; - } - case QRF_STYLE_Insert: { - unsigned int mxIns = p->spec.nMultiInsert; - int szStart = sqlite3_str_length(p->pOut); - if( p->u.nIns==0 || p->u.nIns>=mxIns ){ - if( p->u.nIns ){ - sqlite3_str_append(p->pOut, ";\n", 2); - p->u.nIns = 0; - } - if( qrf_need_quote(p->spec.zTableName) ){ - sqlite3_str_appendf(p->pOut,"INSERT INTO \"%w\"",p->spec.zTableName); - }else{ - sqlite3_str_appendf(p->pOut,"INSERT INTO %s",p->spec.zTableName); - } - if( p->spec.bTitles==QRF_Yes ){ - for(i=0; inCol; i++){ - const char *zCName = sqlite3_column_name(p->pStmt, i); - if( qrf_need_quote(zCName) ){ - sqlite3_str_appendf(p->pOut, "%c\"%w\"", - i==0 ? '(' : ',', zCName); - }else{ - sqlite3_str_appendf(p->pOut, "%c%s", - i==0 ? '(' : ',', zCName); - } - } - sqlite3_str_append(p->pOut, ")", 1); - } - sqlite3_str_append(p->pOut," VALUES(", 8); - }else{ - sqlite3_str_append(p->pOut,",\n (", 5); - } - for(i=0; inCol; i++){ - if( i>0 ) sqlite3_str_append(p->pOut, ",", 1); - qrfRenderValue(p, p->pOut, i); - } - p->u.nIns += sqlite3_str_length(p->pOut) + 2 - szStart; - if( p->u.nIns>=mxIns ){ - sqlite3_str_append(p->pOut, ");\n", 3); - p->u.nIns = 0; - }else{ - sqlite3_str_append(p->pOut, ")", 1); - } - qrfWrite(p); - break; - } - case QRF_STYLE_Line: { - sqlite3_str *pVal; - int mxW; - int bWW; - int nSep; - if( p->u.sLine.azCol==0 ){ - p->u.sLine.azCol = sqlite3_malloc64( p->nCol*sizeof(char*) ); - if( p->u.sLine.azCol==0 ){ - qrfOom(p); - break; - } - p->u.sLine.mxColWth = 0; - for(i=0; inCol; i++){ - int sz; - const char *zCName = sqlite3_column_name(p->pStmt, i); - if( zCName==0 ) zCName = "unknown"; - p->u.sLine.azCol[i] = sqlite3_mprintf("%s", zCName); - if( p->spec.nTitleLimit>0 ){ - (void)qrfTitleLimit(p->u.sLine.azCol[i], p->spec.nTitleLimit); - } - sz = (int)sqlite3_qrf_wcswidth(p->u.sLine.azCol[i]); - if( sz > p->u.sLine.mxColWth ) p->u.sLine.mxColWth = sz; - } - } - if( p->nRow ) sqlite3_str_append(p->pOut, "\n", 1); - pVal = sqlite3_str_new(p->db); - nSep = (int)strlen(p->spec.zColumnSep); - mxW = p->mxWidth - (nSep + p->u.sLine.mxColWth); - bWW = p->spec.bWordWrap==QRF_Yes; - for(i=0; inCol; i++){ - const char *zVal; - int cnt = 0; - qrfWidthPrint(p, p->pOut, -p->u.sLine.mxColWth, p->u.sLine.azCol[i]); - sqlite3_str_append(p->pOut, p->spec.zColumnSep, nSep); - qrfRenderValue(p, pVal, i); - zVal = sqlite3_str_value(pVal); - if( zVal==0 ) zVal = ""; - do{ - int nThis, nWide, iNext; - qrfWrapLine(zVal, mxW, bWW, &nThis, &nWide, &iNext); - if( cnt ){ - sqlite3_str_appendchar(p->pOut,p->u.sLine.mxColWth+nSep,' '); - } - cnt++; - if( cnt>p->mxHeight ){ - zVal = "..."; - nThis = iNext = 3; - } - sqlite3_str_append(p->pOut, zVal, nThis); - sqlite3_str_append(p->pOut, "\n", 1); - zVal += iNext; - }while( zVal[0] ); - sqlite3_str_reset(pVal); - } - qrfStrErr(p, pVal); - sqlite3_free(sqlite3_str_finish(pVal)); - qrfWrite(p); - break; - } - case QRF_STYLE_Eqp: { - const char *zEqpLine = (const char*)sqlite3_column_text(p->pStmt,3); - int iEqpId = sqlite3_column_int(p->pStmt, 0); - int iParentId = sqlite3_column_int(p->pStmt, 1); - if( zEqpLine==0 ) zEqpLine = ""; - if( zEqpLine[0]=='-' ) qrfEqpRender(p, 0); - qrfEqpAppend(p, iEqpId, iParentId, zEqpLine); - break; - } - default: { /* QRF_STYLE_List */ - if( p->nRow==0 && p->spec.bTitles==QRF_Yes ){ - int saved_eText = p->spec.eText; - p->spec.eText = p->spec.eTitle; - for(i=0; inCol; i++){ - const char *zCName = sqlite3_column_name(p->pStmt, i); - if( i>0 ) sqlite3_str_appendall(p->pOut, p->spec.zColumnSep); - qrfEncodeText(p, p->pOut, zCName); - } - sqlite3_str_appendall(p->pOut, p->spec.zRowSep); - qrfWrite(p); - p->spec.eText = saved_eText; - } - for(i=0; inCol; i++){ - if( i>0 ) sqlite3_str_appendall(p->pOut, p->spec.zColumnSep); - qrfRenderValue(p, p->pOut, i); - } - sqlite3_str_appendall(p->pOut, p->spec.zRowSep); - qrfWrite(p); - break; - } - } - p->nRow++; -} - -/* -** Initialize the internal Qrf object. -*/ -static void qrfInitialize( - Qrf *p, /* State object to be initialized */ - sqlite3_stmt *pStmt, /* Query whose output to be formatted */ - const sqlite3_qrf_spec *pSpec, /* Format specification */ - char **pzErr /* Write errors here */ -){ - size_t sz; /* Size of pSpec[], based on pSpec->iVersion */ - memset(p, 0, sizeof(*p)); - p->pzErr = pzErr; - if( pSpec->iVersion>1 ){ - qrfError(p, SQLITE_ERROR, - "unusable sqlite3_qrf_spec.iVersion (%d)", - pSpec->iVersion); - return; - } - p->pStmt = pStmt; - p->db = sqlite3_db_handle(pStmt); - p->pOut = sqlite3_str_new(p->db); - if( p->pOut==0 ){ - qrfOom(p); - return; - } - p->iErr = SQLITE_OK; - p->nCol = sqlite3_column_count(p->pStmt); - p->nRow = 0; - sz = sizeof(sqlite3_qrf_spec); - memcpy(&p->spec, pSpec, sz); - if( p->spec.zNull==0 ) p->spec.zNull = ""; - p->mxWidth = p->spec.nScreenWidth; - if( p->mxWidth<=0 ) p->mxWidth = QRF_MAX_WIDTH; - p->mxHeight = p->spec.nLineLimit; - if( p->mxHeight<=0 ) p->mxHeight = 2147483647; - if( p->spec.eStyle>QRF_STYLE_Table ) p->spec.eStyle = QRF_Auto; - if( p->spec.eEsc>QRF_ESC_Symbol ) p->spec.eEsc = QRF_Auto; - if( p->spec.eText>QRF_TEXT_Relaxed ) p->spec.eText = QRF_Auto; - if( p->spec.eTitle>QRF_TEXT_Relaxed ) p->spec.eTitle = QRF_Auto; - if( p->spec.eBlob>QRF_BLOB_Size ) p->spec.eBlob = QRF_Auto; -qrf_reinit: - switch( p->spec.eStyle ){ - case QRF_Auto: { - switch( sqlite3_stmt_isexplain(pStmt) ){ - case 0: p->spec.eStyle = QRF_STYLE_Box; break; - case 1: p->spec.eStyle = QRF_STYLE_Explain; break; - default: p->spec.eStyle = QRF_STYLE_Eqp; break; - } - goto qrf_reinit; - } - case QRF_STYLE_List: { - if( p->spec.zColumnSep==0 ) p->spec.zColumnSep = "|"; - if( p->spec.zRowSep==0 ) p->spec.zRowSep = "\n"; - break; - } - case QRF_STYLE_JObject: - case QRF_STYLE_Json: { - p->spec.eText = QRF_TEXT_Json; - p->spec.zNull = "null"; - break; - } - case QRF_STYLE_Html: { - p->spec.eText = QRF_TEXT_Html; - p->spec.zNull = "null"; - break; - } - case QRF_STYLE_Insert: { - p->spec.eText = QRF_TEXT_Sql; - p->spec.zNull = "NULL"; - if( p->spec.zTableName==0 || p->spec.zTableName[0]==0 ){ - p->spec.zTableName = "tab"; - } - p->u.nIns = 0; - break; - } - case QRF_STYLE_Line: { - if( p->spec.zColumnSep==0 ){ - p->spec.zColumnSep = ": "; - } - break; - } - case QRF_STYLE_Csv: { - p->spec.eStyle = QRF_STYLE_List; - p->spec.eText = QRF_TEXT_Csv; - p->spec.zColumnSep = ","; - p->spec.zRowSep = "\r\n"; - p->spec.zNull = ""; - break; - } - case QRF_STYLE_Quote: { - p->spec.eText = QRF_TEXT_Sql; - p->spec.zNull = "NULL"; - p->spec.zColumnSep = ","; - p->spec.zRowSep = "\n"; - break; - } - case QRF_STYLE_Eqp: { - int expMode = sqlite3_stmt_isexplain(p->pStmt); - if( expMode!=2 ){ - sqlite3_stmt_explain(p->pStmt, 2); - p->expMode = expMode+1; - } - break; - } - case QRF_STYLE_Explain: { - int expMode = sqlite3_stmt_isexplain(p->pStmt); - if( expMode!=1 ){ - sqlite3_stmt_explain(p->pStmt, 1); - p->expMode = expMode+1; - } - break; - } - } - if( p->spec.eEsc==QRF_Auto ){ - p->spec.eEsc = QRF_ESC_Ascii; - } - if( p->spec.eText==QRF_Auto ){ - p->spec.eText = QRF_TEXT_Plain; - } - if( p->spec.eTitle==QRF_Auto ){ - switch( p->spec.eStyle ){ - case QRF_STYLE_Box: - case QRF_STYLE_Column: - case QRF_STYLE_Table: - p->spec.eTitle = QRF_TEXT_Plain; - break; - default: - p->spec.eTitle = p->spec.eText; - break; - } - } - if( p->spec.eBlob==QRF_Auto ){ - switch( p->spec.eText ){ - case QRF_TEXT_Sql: p->spec.eBlob = QRF_BLOB_Sql; break; - case QRF_TEXT_Csv: p->spec.eBlob = QRF_BLOB_Tcl; break; - case QRF_TEXT_Tcl: p->spec.eBlob = QRF_BLOB_Tcl; break; - case QRF_TEXT_Json: p->spec.eBlob = QRF_BLOB_Json; break; - default: p->spec.eBlob = QRF_BLOB_Text; break; - } - } - if( p->spec.bTitles==QRF_Auto ){ - switch( p->spec.eStyle ){ - case QRF_STYLE_Box: - case QRF_STYLE_Csv: - case QRF_STYLE_Column: - case QRF_STYLE_Table: - case QRF_STYLE_Markdown: - p->spec.bTitles = QRF_Yes; - break; - default: - p->spec.bTitles = QRF_No; - break; - } - } - if( p->spec.bWordWrap==QRF_Auto ){ - p->spec.bWordWrap = QRF_Yes; - } - if( p->spec.bTextJsonb==QRF_Auto ){ - p->spec.bTextJsonb = QRF_No; - } - if( p->spec.zColumnSep==0 ) p->spec.zColumnSep = ","; - if( p->spec.zRowSep==0 ) p->spec.zRowSep = "\n"; -} - -/* -** Finish rendering the results -*/ -static void qrfFinalize(Qrf *p){ - switch( p->spec.eStyle ){ - case QRF_STYLE_Count: { - sqlite3_str_appendf(p->pOut, "%lld\n", p->nRow); - break; - } - case QRF_STYLE_Json: { - if( p->nRow>0 ){ - sqlite3_str_append(p->pOut, "}]\n", 3); - } - break; - } - case QRF_STYLE_JObject: { - if( p->nRow>0 ){ - sqlite3_str_append(p->pOut, "}\n", 2); - } - break; - } - case QRF_STYLE_Insert: { - if( p->u.nIns ){ - sqlite3_str_append(p->pOut, ";\n", 2); - } - break; - } - case QRF_STYLE_Line: { - if( p->u.sLine.azCol ){ - int i; - for(i=0; inCol; i++) sqlite3_free(p->u.sLine.azCol[i]); - sqlite3_free(p->u.sLine.azCol); - } - break; - } - case QRF_STYLE_Stats: - case QRF_STYLE_StatsEst: { - i64 nCycle = 0; -#ifdef SQLITE_ENABLE_STMT_SCANSTATUS - sqlite3_stmt_scanstatus_v2(p->pStmt, -1, SQLITE_SCANSTAT_NCYCLE, - SQLITE_SCANSTAT_COMPLEX, (void*)&nCycle); -#endif - qrfEqpRender(p, nCycle); - break; - } - case QRF_STYLE_Eqp: { - qrfEqpRender(p, 0); - break; - } - } - qrfWrite(p); - qrfStrErr(p, p->pOut); - if( p->spec.pzOutput ){ - if( p->spec.pzOutput[0] ){ - sqlite3_int64 n, sz; - char *zCombined; - sz = strlen(p->spec.pzOutput[0]); - n = sqlite3_str_length(p->pOut); - zCombined = sqlite3_realloc64(p->spec.pzOutput[0], sz+n+1); - if( zCombined==0 ){ - sqlite3_free(p->spec.pzOutput[0]); - p->spec.pzOutput[0] = 0; - qrfOom(p); - }else{ - p->spec.pzOutput[0] = zCombined; - memcpy(zCombined+sz, sqlite3_str_value(p->pOut), n+1); - } - sqlite3_free(sqlite3_str_finish(p->pOut)); - }else{ - p->spec.pzOutput[0] = sqlite3_str_finish(p->pOut); - } - }else if( p->pOut ){ - sqlite3_free(sqlite3_str_finish(p->pOut)); - } - if( p->expMode>0 ){ - sqlite3_stmt_explain(p->pStmt, p->expMode-1); - } - if( p->actualWidth ){ - sqlite3_free(p->actualWidth); - } - if( p->pJTrans ){ - sqlite3 *db = sqlite3_db_handle(p->pJTrans); - sqlite3_finalize(p->pJTrans); - sqlite3_close(db); - } -} - -/* -** Run the prepared statement pStmt and format the results according -** to the specification provided in pSpec. Return an error code. -** If pzErr is not NULL and if an error occurs, write an error message -** into *pzErr. -*/ -int sqlite3_format_query_result( - sqlite3_stmt *pStmt, /* Statement to evaluate */ - const sqlite3_qrf_spec *pSpec, /* Format specification */ - char **pzErr /* Write error message here */ -){ - Qrf qrf; /* The new Qrf being created */ - - if( pStmt==0 ) return SQLITE_OK; /* No-op */ - if( pSpec==0 ) return SQLITE_MISUSE; - qrfInitialize(&qrf, pStmt, pSpec, pzErr); - switch( qrf.spec.eStyle ){ - case QRF_STYLE_Box: - case QRF_STYLE_Column: - case QRF_STYLE_Markdown: - case QRF_STYLE_Table: { - /* Columnar modes require that the entire query be evaluated and the - ** results stored in memory, so that we can compute column widths */ - qrfColumnar(&qrf); - break; - } - case QRF_STYLE_Explain: { - qrfExplain(&qrf); - break; - } - case QRF_STYLE_StatsVm: { - qrfScanStatusVm(&qrf); - break; - } - case QRF_STYLE_Stats: - case QRF_STYLE_StatsEst: { - qrfEqpStats(&qrf); - break; - } - default: { - /* Non-columnar modes where the output can occur after each row - ** of result is received */ - while( qrf.iErr==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){ - qrfOneSimpleRow(&qrf); - } - break; - } - } - qrfResetStmt(&qrf); - qrfFinalize(&qrf); - return qrf.iErr; -} - -/************************* End ext/qrf/qrf.c ********************/ - -/* Use console I/O package as a direct INCLUDE. */ -#define SQLITE_INTERNAL_LINKAGE static - -#ifdef SQLITE_SHELL_FIDDLE -/* Deselect most features from the console I/O package for Fiddle. */ -# define SQLITE_CIO_NO_REDIRECT -# define SQLITE_CIO_NO_CLASSIFY -# define SQLITE_CIO_NO_TRANSLATE -# define SQLITE_CIO_NO_SETMODE -# define SQLITE_CIO_NO_FLUSH -#endif - -/* -** The source code for several run-time loadable extensions is inserted -** below by the ../tool/mkshellc.tcl script. Before processing that included -** code, we need to override some macros to make the included program code -** work here in the middle of this regular program. -*/ -#define SQLITE_EXTENSION_INIT1 -#define SQLITE_EXTENSION_INIT2(X) (void)(X) - -/************************* Begin ext/misc/windirent.h ******************/ -/* -** 2025-06-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. -** -************************************************************************* -** -** An implementation of opendir(), readdir(), and closedir() for Windows, -** based on the FindFirstFile(), FindNextFile(), and FindClose() APIs -** of Win32. -** -** #include this file inside any C-code module that needs to use -** opendir()/readdir()/closedir(). This file is a no-op on non-Windows -** machines. On Windows, static functions are defined that implement -** those standard interfaces. -*/ -#if defined(_WIN32) && defined(_MSC_VER) && !defined(SQLITE_WINDIRENT_H) -#define SQLITE_WINDIRENT_H - -#ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#endif -#include -#include -#include -#include -#include -#include -#include -#include -#include -#ifndef FILENAME_MAX -# define FILENAME_MAX (260) -#endif -#ifndef S_ISREG -#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) -#endif -#ifndef S_ISDIR -#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) -#endif -#ifndef S_ISLNK -#define S_ISLNK(m) (0) -#endif -typedef unsigned short mode_t; - -/* The dirent object for Windows is abbreviated. The only field really -** usable by applications is d_name[]. -*/ -struct dirent { - int d_ino; /* Inode number (synthesized) */ - unsigned d_attributes; /* File attributes */ - char d_name[FILENAME_MAX]; /* Null-terminated filename */ -}; - -/* The internals of DIR are opaque according to standards. So it -** does not matter what we put here. */ -typedef struct DIR DIR; -struct DIR { - intptr_t d_handle; /* Handle for findfirst()/findnext() */ - struct dirent cur; /* Current entry */ -}; - -/* Ignore hidden and system files */ -#define WindowsFileToIgnore(a) \ - ((((a).attrib)&_A_HIDDEN) || (((a).attrib)&_A_SYSTEM)) - -/* -** Close a previously opened directory -*/ -static int closedir(DIR *pDir){ - int rc = 0; - if( pDir==0 ){ - return EINVAL; - } - if( pDir->d_handle!=0 && pDir->d_handle!=(-1) ){ - rc = _findclose(pDir->d_handle); - } - sqlite3_free(pDir); - return rc; -} - -/* -** Open a new directory. The directory name should be UTF-8 encoded. -** appropriate translations happen automatically. -*/ -static DIR *opendir(const char *zDirName){ - DIR *pDir; - wchar_t *b1; - sqlite3_int64 sz; - struct _wfinddata_t data; - - pDir = sqlite3_malloc64( sizeof(DIR) ); - if( pDir==0 ) return 0; - memset(pDir, 0, sizeof(DIR)); - memset(&data, 0, sizeof(data)); - sz = strlen(zDirName); - b1 = sqlite3_malloc64( (sz+3)*sizeof(b1[0]) ); - if( b1==0 ){ - closedir(pDir); - return NULL; - } - sz = MultiByteToWideChar(CP_UTF8, 0, zDirName, sz, b1, sz); - b1[sz++] = '\\'; - b1[sz++] = '*'; - b1[sz] = 0; - if( sz+1>sizeof(data.name)/sizeof(data.name[0]) ){ - closedir(pDir); - sqlite3_free(b1); - return NULL; - } - memcpy(data.name, b1, (sz+1)*sizeof(b1[0])); - sqlite3_free(b1); - pDir->d_handle = _wfindfirst(data.name, &data); - if( pDir->d_handle<0 ){ - closedir(pDir); - return NULL; - } - while( WindowsFileToIgnore(data) ){ - memset(&data, 0, sizeof(data)); - if( _wfindnext(pDir->d_handle, &data)==-1 ){ - closedir(pDir); - return NULL; - } - } - pDir->cur.d_ino = 0; - pDir->cur.d_attributes = data.attrib; - WideCharToMultiByte(CP_UTF8, 0, data.name, -1, - pDir->cur.d_name, FILENAME_MAX, 0, 0); - return pDir; -} - -/* -** Read the next entry from a directory. -** -** The returned struct-dirent object is managed by DIR. It is only -** valid until the next readdir() or closedir() call. Only the -** d_name[] field is meaningful. The d_name[] value has been -** translated into UTF8. -*/ -static struct dirent *readdir(DIR *pDir){ - struct _wfinddata_t data; - if( pDir==0 ) return 0; - if( (pDir->cur.d_ino++)==0 ){ - return &pDir->cur; - } - do{ - memset(&data, 0, sizeof(data)); - if( _wfindnext(pDir->d_handle, &data)==-1 ){ - return NULL; - } - }while( WindowsFileToIgnore(data) ); - pDir->cur.d_attributes = data.attrib; - WideCharToMultiByte(CP_UTF8, 0, data.name, -1, - pDir->cur.d_name, FILENAME_MAX, 0, 0); - return &pDir->cur; -} - -#endif /* defined(_WIN32) && defined(_MSC_VER) */ - -/************************* End ext/misc/windirent.h ********************/ -/************************* Begin ext/misc/memtrace.c ******************/ -/* -** 2019-01-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 implements an extension that uses the SQLITE_CONFIG_MALLOC -** mechanism to add a tracing layer on top of SQLite. If this extension -** is registered prior to sqlite3_initialize(), it will cause all memory -** allocation activities to be logged on standard output, or to some other -** FILE specified by the initializer. -** -** This file needs to be compiled into the application that uses it. -** -** This extension is used to implement the --memtrace option of the -** command-line shell. -*/ -#include -#include -#include - -/* The original memory allocation routines */ -static sqlite3_mem_methods memtraceBase; -static FILE *memtraceOut; - -/* Methods that trace memory allocations */ -static void *memtraceMalloc(int n){ - if( memtraceOut ){ - fprintf(memtraceOut, "MEMTRACE: allocate %d bytes\n", - memtraceBase.xRoundup(n)); - } - return memtraceBase.xMalloc(n); -} -static void memtraceFree(void *p){ - if( p==0 ) return; - if( memtraceOut ){ - fprintf(memtraceOut, "MEMTRACE: free %d bytes\n", memtraceBase.xSize(p)); - } - memtraceBase.xFree(p); -} -static void *memtraceRealloc(void *p, int n){ - if( p==0 ) return memtraceMalloc(n); - if( n==0 ){ - memtraceFree(p); - return 0; - } - if( memtraceOut ){ - fprintf(memtraceOut, "MEMTRACE: resize %d -> %d bytes\n", - memtraceBase.xSize(p), memtraceBase.xRoundup(n)); - } - return memtraceBase.xRealloc(p, n); -} -static int memtraceSize(void *p){ - return memtraceBase.xSize(p); -} -static int memtraceRoundup(int n){ - return memtraceBase.xRoundup(n); -} -static int memtraceInit(void *p){ - return memtraceBase.xInit(p); -} -static void memtraceShutdown(void *p){ - memtraceBase.xShutdown(p); -} - -/* The substitute memory allocator */ -static sqlite3_mem_methods ersaztMethods = { - memtraceMalloc, - memtraceFree, - memtraceRealloc, - memtraceSize, - memtraceRoundup, - memtraceInit, - memtraceShutdown, - 0 -}; - -/* Begin tracing memory allocations to out. */ -int sqlite3MemTraceActivate(FILE *out){ - int rc = SQLITE_OK; - if( memtraceBase.xMalloc==0 ){ - rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memtraceBase); - if( rc==SQLITE_OK ){ - rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &ersaztMethods); - } - } - memtraceOut = out; - return rc; -} - -/* Deactivate memory tracing */ -int sqlite3MemTraceDeactivate(void){ - int rc = SQLITE_OK; - if( memtraceBase.xMalloc!=0 ){ - rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memtraceBase); - if( rc==SQLITE_OK ){ - memset(&memtraceBase, 0, sizeof(memtraceBase)); - } - } - memtraceOut = 0; - return rc; -} - -/************************* End ext/misc/memtrace.c ********************/ -/************************* Begin ext/misc/pcachetrace.c ******************/ -/* -** 2023-06-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 implements an extension that uses the SQLITE_CONFIG_PCACHE2 -** mechanism to add a tracing layer on top of pluggable page cache of -** SQLite. If this extension is registered prior to sqlite3_initialize(), -** it will cause all page cache activities to be logged on standard output, -** or to some other FILE specified by the initializer. -** -** This file needs to be compiled into the application that uses it. -** -** This extension is used to implement the --pcachetrace option of the -** command-line shell. -*/ -#include -#include -#include - -/* The original page cache routines */ -static sqlite3_pcache_methods2 pcacheBase; -static FILE *pcachetraceOut; - -/* Methods that trace pcache activity */ -static int pcachetraceInit(void *pArg){ - int nRes; - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xInit(%p)\n", pArg); - } - nRes = pcacheBase.xInit(pArg); - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xInit(%p) -> %d\n", pArg, nRes); - } - return nRes; -} -static void pcachetraceShutdown(void *pArg){ - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xShutdown(%p)\n", pArg); - } - pcacheBase.xShutdown(pArg); -} -static sqlite3_pcache *pcachetraceCreate(int szPage, int szExtra, int bPurge){ - sqlite3_pcache *pRes; - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xCreate(%d,%d,%d)\n", - szPage, szExtra, bPurge); - } - pRes = pcacheBase.xCreate(szPage, szExtra, bPurge); - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xCreate(%d,%d,%d) -> %p\n", - szPage, szExtra, bPurge, pRes); - } - return pRes; -} -static void pcachetraceCachesize(sqlite3_pcache *p, int nCachesize){ - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xCachesize(%p, %d)\n", p, nCachesize); - } - pcacheBase.xCachesize(p, nCachesize); -} -static int pcachetracePagecount(sqlite3_pcache *p){ - int nRes; - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xPagecount(%p)\n", p); - } - nRes = pcacheBase.xPagecount(p); - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xPagecount(%p) -> %d\n", p, nRes); - } - return nRes; -} -static sqlite3_pcache_page *pcachetraceFetch( - sqlite3_pcache *p, - unsigned key, - int crFg -){ - sqlite3_pcache_page *pRes; - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xFetch(%p,%u,%d)\n", p, key, crFg); - } - pRes = pcacheBase.xFetch(p, key, crFg); - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xFetch(%p,%u,%d) -> %p\n", - p, key, crFg, pRes); - } - return pRes; -} -static void pcachetraceUnpin( - sqlite3_pcache *p, - sqlite3_pcache_page *pPg, - int bDiscard -){ - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xUnpin(%p, %p, %d)\n", - p, pPg, bDiscard); - } - pcacheBase.xUnpin(p, pPg, bDiscard); -} -static void pcachetraceRekey( - sqlite3_pcache *p, - sqlite3_pcache_page *pPg, - unsigned oldKey, - unsigned newKey -){ - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xRekey(%p, %p, %u, %u)\n", - p, pPg, oldKey, newKey); - } - pcacheBase.xRekey(p, pPg, oldKey, newKey); -} -static void pcachetraceTruncate(sqlite3_pcache *p, unsigned n){ - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xTruncate(%p, %u)\n", p, n); - } - pcacheBase.xTruncate(p, n); -} -static void pcachetraceDestroy(sqlite3_pcache *p){ - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xDestroy(%p)\n", p); - } - pcacheBase.xDestroy(p); -} -static void pcachetraceShrink(sqlite3_pcache *p){ - if( pcachetraceOut ){ - fprintf(pcachetraceOut, "PCACHETRACE: xShrink(%p)\n", p); - } - pcacheBase.xShrink(p); -} - -/* The substitute pcache methods */ -static sqlite3_pcache_methods2 ersaztPcacheMethods = { - 0, - 0, - pcachetraceInit, - pcachetraceShutdown, - pcachetraceCreate, - pcachetraceCachesize, - pcachetracePagecount, - pcachetraceFetch, - pcachetraceUnpin, - pcachetraceRekey, - pcachetraceTruncate, - pcachetraceDestroy, - pcachetraceShrink -}; - -/* Begin tracing memory allocations to out. */ -int sqlite3PcacheTraceActivate(FILE *out){ - int rc = SQLITE_OK; - if( pcacheBase.xFetch==0 ){ - rc = sqlite3_config(SQLITE_CONFIG_GETPCACHE2, &pcacheBase); - if( rc==SQLITE_OK ){ - rc = sqlite3_config(SQLITE_CONFIG_PCACHE2, &ersaztPcacheMethods); - } - } - pcachetraceOut = out; - return rc; -} - -/* Deactivate memory tracing */ -int sqlite3PcacheTraceDeactivate(void){ - int rc = SQLITE_OK; - if( pcacheBase.xFetch!=0 ){ - rc = sqlite3_config(SQLITE_CONFIG_PCACHE2, &pcacheBase); - if( rc==SQLITE_OK ){ - memset(&pcacheBase, 0, sizeof(pcacheBase)); - } - } - pcachetraceOut = 0; - return rc; -} - -/************************* End ext/misc/pcachetrace.c ********************/ -/************************* Begin ext/misc/shathree.c ******************/ -/* -** 2017-03-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 SQLite extension implements functions that compute SHA3 hashes -** in the way described by the (U.S.) NIST FIPS 202 SHA-3 Standard. -** Three SQL functions are implemented: -** -** sha3(X,SIZE) -** sha3_agg(Y,SIZE) -** sha3_query(Z,SIZE) -** -** The sha3(X) function computes the SHA3 hash of the input X, or NULL if -** X is NULL. If inputs X is text, the UTF-8 rendering of that text is -** used to compute the hash. If X is a BLOB, then the binary data of the -** blob is used to compute the hash. If X is an integer or real number, -** then that number if converted into UTF-8 text and the hash is computed -** over the text. -** -** The sha3_agg(Y) function computes the SHA3 hash of all Y inputs. Since -** order is important for the hash, it is recommended that the Y expression -** by followed by an ORDER BY clause to guarantee that the inputs occur -** in the desired order. -** -** The sha3_query(Y) function evaluates all queries in the SQL statements of Y -** and returns a hash of their results. -** -** The SIZE argument is optional. If omitted, the SHA3-256 hash algorithm -** is used. If SIZE is included it must be one of the integers 224, 256, -** 384, or 512, to determine SHA3 hash variant that is computed. -** -** Because the sha3_agg() and sha3_query() functions compute a hash over -** multiple values, the values are encode to use include type information. -** -** In sha3_agg(), the sequence of bytes that gets hashed for each input -** Y depends on the datatype of Y: -** -** typeof(Y)='null' A single "N" is hashed. (One byte) -** -** typeof(Y)='integer' The data hash is the character "I" followed -** by an 8-byte big-endian binary of the -** 64-bit signed integer. (Nine bytes total.) -** -** typeof(Y)='real' The character "F" followed by an 8-byte -** big-ending binary of the double. (Nine -** bytes total.) -** -** typeof(Y)='text' The hash is over prefix "Tnnn:" followed -** by the UTF8 encoding of the text. The "nnn" -** in the prefix is the minimum-length decimal -** representation of the octet_length of the text. -** Notice the ":" at the end of the prefix, which -** is needed to separate the prefix from the -** content in cases where the content starts -** with a digit. -** -** typeof(Y)='blob' The hash is taken over prefix "Bnnn:" followed -** by the binary content of the blob. The "nnn" -** in the prefix is the minimum-length decimal -** representation of the byte-length of the blob. -** -** According to the rules above, all of the following SELECT statements -** should return TRUE: -** -** SELECT sha3(1) = sha3('1'); -** -** SELECT sha3('hello') = sha3(x'68656c6c6f'); -** -** WITH a(x) AS (VALUES('xyzzy')) -** SELECT sha3_agg(x) = sha3('T5:xyzzy') FROM a; -** -** WITH a(x) AS (VALUES(x'010203')) -** SELECT sha3_agg(x) = sha3(x'42333a010203') FROM a; -** -** WITH a(x) AS (VALUES(0x123456)) -** SELECT sha3_agg(x) = sha3(x'490000000000123456') FROM a; -** -** WITH a(x) AS (VALUES(100.015625)) -** SELECT sha3_agg(x) = sha3(x'464059010000000000') FROM a; -** -** WITH a(x) AS (VALUES(NULL)) -** SELECT sha3_agg(x) = sha3('N') FROM a; -** -** -** In sha3_query(), individual column values are encoded as with -** sha3_agg(), but with the addition that a single "R" character is -** inserted at the start of each row. -** -** Note that sha3_agg() hashes rows for which Y is NULL. Add a FILTER -** clause if NULL rows should be excluded: -** -** SELECT sha3_agg(x ORDER BY rowid) FILTER(WHERE x NOT NULL) FROM t1; -*/ -/* #include "sqlite3ext.h" */ -SQLITE_EXTENSION_INIT1 -#include -#include -#include - -#ifndef SQLITE_AMALGAMATION -/* typedef sqlite3_uint64 u64; */ -#endif /* SQLITE_AMALGAMATION */ - -/****************************************************************************** -** The Hash Engine -*/ -/* -** 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 -** -DSHA3_BYTEORDER=0 is set, then byte-order is determined -** at run-time. -*/ -#ifndef SHA3_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(__arm__) -# define SHA3_BYTEORDER 1234 -# elif defined(sparc) || defined(__ppc__) -# define SHA3_BYTEORDER 4321 -# else -# define SHA3_BYTEORDER 0 -# endif -#endif - - -/* -** State structure for a SHA3 hash in progress -*/ -typedef struct SHA3Context SHA3Context; -struct SHA3Context { - union { - u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */ - unsigned char x[1600]; /* ... or 1600 bytes */ - } u; - unsigned nRate; /* Bytes of input accepted per Keccak iteration */ - unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */ - unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */ - unsigned iSize; /* 224, 256, 358, or 512 */ -}; - -/* -** A single step of the Keccak mixing function for a 1600-bit state -*/ -static void KeccakF1600Step(SHA3Context *p){ - int i; - u64 b0, b1, b2, b3, b4; - u64 c0, c1, c2, c3, c4; - u64 d0, d1, d2, d3, d4; - static const u64 RC[] = { - 0x0000000000000001ULL, 0x0000000000008082ULL, - 0x800000000000808aULL, 0x8000000080008000ULL, - 0x000000000000808bULL, 0x0000000080000001ULL, - 0x8000000080008081ULL, 0x8000000000008009ULL, - 0x000000000000008aULL, 0x0000000000000088ULL, - 0x0000000080008009ULL, 0x000000008000000aULL, - 0x000000008000808bULL, 0x800000000000008bULL, - 0x8000000000008089ULL, 0x8000000000008003ULL, - 0x8000000000008002ULL, 0x8000000000000080ULL, - 0x000000000000800aULL, 0x800000008000000aULL, - 0x8000000080008081ULL, 0x8000000000008080ULL, - 0x0000000080000001ULL, 0x8000000080008008ULL - }; -# define a00 (p->u.s[0]) -# define a01 (p->u.s[1]) -# define a02 (p->u.s[2]) -# define a03 (p->u.s[3]) -# define a04 (p->u.s[4]) -# define a10 (p->u.s[5]) -# define a11 (p->u.s[6]) -# define a12 (p->u.s[7]) -# define a13 (p->u.s[8]) -# define a14 (p->u.s[9]) -# define a20 (p->u.s[10]) -# define a21 (p->u.s[11]) -# define a22 (p->u.s[12]) -# define a23 (p->u.s[13]) -# define a24 (p->u.s[14]) -# define a30 (p->u.s[15]) -# define a31 (p->u.s[16]) -# define a32 (p->u.s[17]) -# define a33 (p->u.s[18]) -# define a34 (p->u.s[19]) -# define a40 (p->u.s[20]) -# define a41 (p->u.s[21]) -# define a42 (p->u.s[22]) -# define a43 (p->u.s[23]) -# define a44 (p->u.s[24]) -# define ROL64(a,x) ((a<>(64-x))) - - for(i=0; i<24; i+=4){ - c0 = a00^a10^a20^a30^a40; - c1 = a01^a11^a21^a31^a41; - c2 = a02^a12^a22^a32^a42; - c3 = a03^a13^a23^a33^a43; - c4 = a04^a14^a24^a34^a44; - d0 = c4^ROL64(c1, 1); - d1 = c0^ROL64(c2, 1); - d2 = c1^ROL64(c3, 1); - d3 = c2^ROL64(c4, 1); - d4 = c3^ROL64(c0, 1); - - b0 = (a00^d0); - b1 = ROL64((a11^d1), 44); - b2 = ROL64((a22^d2), 43); - b3 = ROL64((a33^d3), 21); - b4 = ROL64((a44^d4), 14); - a00 = b0 ^((~b1)& b2 ); - a00 ^= RC[i]; - a11 = b1 ^((~b2)& b3 ); - a22 = b2 ^((~b3)& b4 ); - a33 = b3 ^((~b4)& b0 ); - a44 = b4 ^((~b0)& b1 ); - - b2 = ROL64((a20^d0), 3); - b3 = ROL64((a31^d1), 45); - b4 = ROL64((a42^d2), 61); - b0 = ROL64((a03^d3), 28); - b1 = ROL64((a14^d4), 20); - a20 = b0 ^((~b1)& b2 ); - a31 = b1 ^((~b2)& b3 ); - a42 = b2 ^((~b3)& b4 ); - a03 = b3 ^((~b4)& b0 ); - a14 = b4 ^((~b0)& b1 ); - - b4 = ROL64((a40^d0), 18); - b0 = ROL64((a01^d1), 1); - b1 = ROL64((a12^d2), 6); - b2 = ROL64((a23^d3), 25); - b3 = ROL64((a34^d4), 8); - a40 = b0 ^((~b1)& b2 ); - a01 = b1 ^((~b2)& b3 ); - a12 = b2 ^((~b3)& b4 ); - a23 = b3 ^((~b4)& b0 ); - a34 = b4 ^((~b0)& b1 ); - - b1 = ROL64((a10^d0), 36); - b2 = ROL64((a21^d1), 10); - b3 = ROL64((a32^d2), 15); - b4 = ROL64((a43^d3), 56); - b0 = ROL64((a04^d4), 27); - a10 = b0 ^((~b1)& b2 ); - a21 = b1 ^((~b2)& b3 ); - a32 = b2 ^((~b3)& b4 ); - a43 = b3 ^((~b4)& b0 ); - a04 = b4 ^((~b0)& b1 ); - - b3 = ROL64((a30^d0), 41); - b4 = ROL64((a41^d1), 2); - b0 = ROL64((a02^d2), 62); - b1 = ROL64((a13^d3), 55); - b2 = ROL64((a24^d4), 39); - a30 = b0 ^((~b1)& b2 ); - a41 = b1 ^((~b2)& b3 ); - a02 = b2 ^((~b3)& b4 ); - a13 = b3 ^((~b4)& b0 ); - a24 = b4 ^((~b0)& b1 ); - - c0 = a00^a20^a40^a10^a30; - c1 = a11^a31^a01^a21^a41; - c2 = a22^a42^a12^a32^a02; - c3 = a33^a03^a23^a43^a13; - c4 = a44^a14^a34^a04^a24; - d0 = c4^ROL64(c1, 1); - d1 = c0^ROL64(c2, 1); - d2 = c1^ROL64(c3, 1); - d3 = c2^ROL64(c4, 1); - d4 = c3^ROL64(c0, 1); - - b0 = (a00^d0); - b1 = ROL64((a31^d1), 44); - b2 = ROL64((a12^d2), 43); - b3 = ROL64((a43^d3), 21); - b4 = ROL64((a24^d4), 14); - a00 = b0 ^((~b1)& b2 ); - a00 ^= RC[i+1]; - a31 = b1 ^((~b2)& b3 ); - a12 = b2 ^((~b3)& b4 ); - a43 = b3 ^((~b4)& b0 ); - a24 = b4 ^((~b0)& b1 ); - - b2 = ROL64((a40^d0), 3); - b3 = ROL64((a21^d1), 45); - b4 = ROL64((a02^d2), 61); - b0 = ROL64((a33^d3), 28); - b1 = ROL64((a14^d4), 20); - a40 = b0 ^((~b1)& b2 ); - a21 = b1 ^((~b2)& b3 ); - a02 = b2 ^((~b3)& b4 ); - a33 = b3 ^((~b4)& b0 ); - a14 = b4 ^((~b0)& b1 ); - - b4 = ROL64((a30^d0), 18); - b0 = ROL64((a11^d1), 1); - b1 = ROL64((a42^d2), 6); - b2 = ROL64((a23^d3), 25); - b3 = ROL64((a04^d4), 8); - a30 = b0 ^((~b1)& b2 ); - a11 = b1 ^((~b2)& b3 ); - a42 = b2 ^((~b3)& b4 ); - a23 = b3 ^((~b4)& b0 ); - a04 = b4 ^((~b0)& b1 ); - - b1 = ROL64((a20^d0), 36); - b2 = ROL64((a01^d1), 10); - b3 = ROL64((a32^d2), 15); - b4 = ROL64((a13^d3), 56); - b0 = ROL64((a44^d4), 27); - a20 = b0 ^((~b1)& b2 ); - a01 = b1 ^((~b2)& b3 ); - a32 = b2 ^((~b3)& b4 ); - a13 = b3 ^((~b4)& b0 ); - a44 = b4 ^((~b0)& b1 ); - - b3 = ROL64((a10^d0), 41); - b4 = ROL64((a41^d1), 2); - b0 = ROL64((a22^d2), 62); - b1 = ROL64((a03^d3), 55); - b2 = ROL64((a34^d4), 39); - a10 = b0 ^((~b1)& b2 ); - a41 = b1 ^((~b2)& b3 ); - a22 = b2 ^((~b3)& b4 ); - a03 = b3 ^((~b4)& b0 ); - a34 = b4 ^((~b0)& b1 ); - - c0 = a00^a40^a30^a20^a10; - c1 = a31^a21^a11^a01^a41; - c2 = a12^a02^a42^a32^a22; - c3 = a43^a33^a23^a13^a03; - c4 = a24^a14^a04^a44^a34; - d0 = c4^ROL64(c1, 1); - d1 = c0^ROL64(c2, 1); - d2 = c1^ROL64(c3, 1); - d3 = c2^ROL64(c4, 1); - d4 = c3^ROL64(c0, 1); - - b0 = (a00^d0); - b1 = ROL64((a21^d1), 44); - b2 = ROL64((a42^d2), 43); - b3 = ROL64((a13^d3), 21); - b4 = ROL64((a34^d4), 14); - a00 = b0 ^((~b1)& b2 ); - a00 ^= RC[i+2]; - a21 = b1 ^((~b2)& b3 ); - a42 = b2 ^((~b3)& b4 ); - a13 = b3 ^((~b4)& b0 ); - a34 = b4 ^((~b0)& b1 ); - - b2 = ROL64((a30^d0), 3); - b3 = ROL64((a01^d1), 45); - b4 = ROL64((a22^d2), 61); - b0 = ROL64((a43^d3), 28); - b1 = ROL64((a14^d4), 20); - a30 = b0 ^((~b1)& b2 ); - a01 = b1 ^((~b2)& b3 ); - a22 = b2 ^((~b3)& b4 ); - a43 = b3 ^((~b4)& b0 ); - a14 = b4 ^((~b0)& b1 ); - - b4 = ROL64((a10^d0), 18); - b0 = ROL64((a31^d1), 1); - b1 = ROL64((a02^d2), 6); - b2 = ROL64((a23^d3), 25); - b3 = ROL64((a44^d4), 8); - a10 = b0 ^((~b1)& b2 ); - a31 = b1 ^((~b2)& b3 ); - a02 = b2 ^((~b3)& b4 ); - a23 = b3 ^((~b4)& b0 ); - a44 = b4 ^((~b0)& b1 ); - - b1 = ROL64((a40^d0), 36); - b2 = ROL64((a11^d1), 10); - b3 = ROL64((a32^d2), 15); - b4 = ROL64((a03^d3), 56); - b0 = ROL64((a24^d4), 27); - a40 = b0 ^((~b1)& b2 ); - a11 = b1 ^((~b2)& b3 ); - a32 = b2 ^((~b3)& b4 ); - a03 = b3 ^((~b4)& b0 ); - a24 = b4 ^((~b0)& b1 ); - - b3 = ROL64((a20^d0), 41); - b4 = ROL64((a41^d1), 2); - b0 = ROL64((a12^d2), 62); - b1 = ROL64((a33^d3), 55); - b2 = ROL64((a04^d4), 39); - a20 = b0 ^((~b1)& b2 ); - a41 = b1 ^((~b2)& b3 ); - a12 = b2 ^((~b3)& b4 ); - a33 = b3 ^((~b4)& b0 ); - a04 = b4 ^((~b0)& b1 ); - - c0 = a00^a30^a10^a40^a20; - c1 = a21^a01^a31^a11^a41; - c2 = a42^a22^a02^a32^a12; - c3 = a13^a43^a23^a03^a33; - c4 = a34^a14^a44^a24^a04; - d0 = c4^ROL64(c1, 1); - d1 = c0^ROL64(c2, 1); - d2 = c1^ROL64(c3, 1); - d3 = c2^ROL64(c4, 1); - d4 = c3^ROL64(c0, 1); - - b0 = (a00^d0); - b1 = ROL64((a01^d1), 44); - b2 = ROL64((a02^d2), 43); - b3 = ROL64((a03^d3), 21); - b4 = ROL64((a04^d4), 14); - a00 = b0 ^((~b1)& b2 ); - a00 ^= RC[i+3]; - a01 = b1 ^((~b2)& b3 ); - a02 = b2 ^((~b3)& b4 ); - a03 = b3 ^((~b4)& b0 ); - a04 = b4 ^((~b0)& b1 ); - - b2 = ROL64((a10^d0), 3); - b3 = ROL64((a11^d1), 45); - b4 = ROL64((a12^d2), 61); - b0 = ROL64((a13^d3), 28); - b1 = ROL64((a14^d4), 20); - a10 = b0 ^((~b1)& b2 ); - a11 = b1 ^((~b2)& b3 ); - a12 = b2 ^((~b3)& b4 ); - a13 = b3 ^((~b4)& b0 ); - a14 = b4 ^((~b0)& b1 ); - - b4 = ROL64((a20^d0), 18); - b0 = ROL64((a21^d1), 1); - b1 = ROL64((a22^d2), 6); - b2 = ROL64((a23^d3), 25); - b3 = ROL64((a24^d4), 8); - a20 = b0 ^((~b1)& b2 ); - a21 = b1 ^((~b2)& b3 ); - a22 = b2 ^((~b3)& b4 ); - a23 = b3 ^((~b4)& b0 ); - a24 = b4 ^((~b0)& b1 ); - - b1 = ROL64((a30^d0), 36); - b2 = ROL64((a31^d1), 10); - b3 = ROL64((a32^d2), 15); - b4 = ROL64((a33^d3), 56); - b0 = ROL64((a34^d4), 27); - a30 = b0 ^((~b1)& b2 ); - a31 = b1 ^((~b2)& b3 ); - a32 = b2 ^((~b3)& b4 ); - a33 = b3 ^((~b4)& b0 ); - a34 = b4 ^((~b0)& b1 ); - - b3 = ROL64((a40^d0), 41); - b4 = ROL64((a41^d1), 2); - b0 = ROL64((a42^d2), 62); - b1 = ROL64((a43^d3), 55); - b2 = ROL64((a44^d4), 39); - a40 = b0 ^((~b1)& b2 ); - a41 = b1 ^((~b2)& b3 ); - a42 = b2 ^((~b3)& b4 ); - a43 = b3 ^((~b4)& b0 ); - a44 = b4 ^((~b0)& b1 ); - } -} - -/* -** Initialize a new hash. iSize determines the size of the hash -** in bits and should be one of 224, 256, 384, or 512. Or iSize -** can be zero to use the default hash size of 256 bits. -*/ -static void SHA3Init(SHA3Context *p, int iSize){ - memset(p, 0, sizeof(*p)); - p->iSize = iSize; - if( iSize>=128 && iSize<=512 ){ - p->nRate = (1600 - ((iSize + 31)&~31)*2)/8; - }else{ - p->nRate = (1600 - 2*256)/8; - } -#if SHA3_BYTEORDER==1234 - /* Known to be little-endian at compile-time. No-op */ -#elif SHA3_BYTEORDER==4321 - p->ixMask = 7; /* Big-endian */ -#else - { - static unsigned int one = 1; - if( 1==*(unsigned char*)&one ){ - /* Little endian. No byte swapping. */ - p->ixMask = 0; - }else{ - /* Big endian. Byte swap. */ - p->ixMask = 7; - } - } -#endif -} - -/* -** Make consecutive calls to the SHA3Update function to add new content -** to the hash -*/ -static void SHA3Update( - SHA3Context *p, - const unsigned char *aData, - unsigned int nData -){ - unsigned int i = 0; - if( aData==0 ) return; -#if SHA3_BYTEORDER==1234 - if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){ - for(; i+7u.s[p->nLoaded/8] ^= *(u64*)&aData[i]; - p->nLoaded += 8; - if( p->nLoaded>=p->nRate ){ - KeccakF1600Step(p); - p->nLoaded = 0; - } - } - } -#endif - for(; iu.x[p->nLoaded] ^= aData[i]; -#elif SHA3_BYTEORDER==4321 - p->u.x[p->nLoaded^0x07] ^= aData[i]; -#else - p->u.x[p->nLoaded^p->ixMask] ^= aData[i]; -#endif - p->nLoaded++; - if( p->nLoaded==p->nRate ){ - KeccakF1600Step(p); - p->nLoaded = 0; - } - } -} - -/* -** After all content has been added, invoke SHA3Final() to compute -** the final hash. The function returns a pointer to the binary -** hash value. -*/ -static unsigned char *SHA3Final(SHA3Context *p){ - unsigned int i; - if( p->nLoaded==p->nRate-1 ){ - const unsigned char c1 = 0x86; - SHA3Update(p, &c1, 1); - }else{ - const unsigned char c2 = 0x06; - const unsigned char c3 = 0x80; - SHA3Update(p, &c2, 1); - p->nLoaded = p->nRate - 1; - SHA3Update(p, &c3, 1); - } - for(i=0; inRate; i++){ - p->u.x[i+p->nRate] = p->u.x[i^p->ixMask]; - } - return &p->u.x[p->nRate]; -} -/* End of the hashing logic -*****************************************************************************/ - -/* -** Implementation of the sha3(X,SIZE) function. -** -** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default -** size is 256. If X is a BLOB, it is hashed as is. -** For all other non-NULL types of input, X is converted into a UTF-8 string -** and the string is hashed without the trailing 0x00 terminator. The hash -** of a NULL value is NULL. -*/ -static void sha3Func( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - SHA3Context cx; - int eType = sqlite3_value_type(argv[0]); - int nByte = sqlite3_value_bytes(argv[0]); - int iSize; - if( argc==1 ){ - iSize = 256; - }else{ - iSize = sqlite3_value_int(argv[1]); - if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ - sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " - "384 512", -1); - return; - } - } - if( eType==SQLITE_NULL ) return; - SHA3Init(&cx, iSize); - if( eType==SQLITE_BLOB ){ - SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte); - }else{ - SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte); - } - sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT); -} - -/* Compute a string using sqlite3_vsnprintf() with a maximum length -** of 50 bytes and add it to the hash. -*/ -static void sha3_step_vformat( - SHA3Context *p, /* Add content to this context */ - const char *zFormat, - ... -){ - va_list ap; - int n; - char zBuf[50]; - va_start(ap, zFormat); - sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap); - va_end(ap); - n = (int)strlen(zBuf); - SHA3Update(p, (unsigned char*)zBuf, n); -} - -/* -** Update a SHA3Context using a single sqlite3_value. -*/ -static void sha3UpdateFromValue(SHA3Context *p, sqlite3_value *pVal){ - switch( sqlite3_value_type(pVal) ){ - case SQLITE_NULL: { - SHA3Update(p, (const unsigned char*)"N",1); - break; - } - case SQLITE_INTEGER: { - sqlite3_uint64 u; - int j; - unsigned char x[9]; - sqlite3_int64 v = sqlite3_value_int64(pVal); - memcpy(&u, &v, 8); - for(j=8; j>=1; j--){ - x[j] = u & 0xff; - u >>= 8; - } - x[0] = 'I'; - SHA3Update(p, x, 9); - break; - } - case SQLITE_FLOAT: { - sqlite3_uint64 u; - int j; - unsigned char x[9]; - double r = sqlite3_value_double(pVal); - memcpy(&u, &r, 8); - for(j=8; j>=1; j--){ - x[j] = u & 0xff; - u >>= 8; - } - x[0] = 'F'; - SHA3Update(p,x,9); - break; - } - case SQLITE_TEXT: { - int n2 = sqlite3_value_bytes(pVal); - const unsigned char *z2 = sqlite3_value_text(pVal); - sha3_step_vformat(p,"T%d:",n2); - SHA3Update(p, z2, n2); - break; - } - case SQLITE_BLOB: { - int n2 = sqlite3_value_bytes(pVal); - const unsigned char *z2 = sqlite3_value_blob(pVal); - sha3_step_vformat(p,"B%d:",n2); - SHA3Update(p, z2, n2); - break; - } - } -} - -/* -** Implementation of the sha3_query(SQL,SIZE) function. -** -** This function compiles and runs the SQL statement(s) given in the -** argument. The results are hashed using a SIZE-bit SHA3. The default -** size is 256. -** -** The format of the byte stream that is hashed is summarized as follows: -** -** S: -** R -** N -** I -** F -** B: -** T: -** -** is the original SQL text for each statement run and is -** the size of that text. The SQL text is UTF-8. A single R character -** occurs before the start of each row. N means a NULL value. -** I mean an 8-byte little-endian integer . F is a floating point -** number with an 8-byte little-endian IEEE floating point value . -** B means blobs of bytes. T means text rendered as -** bytes of UTF-8. The and values are expressed as an ASCII -** text integers. -** -** For each SQL statement in the X input, there is one S segment. Each -** S segment is followed by zero or more R segments, one for each row in the -** result set. After each R, there are one or more N, I, F, B, or T segments, -** one for each column in the result set. Segments are concatentated directly -** with no delimiters of any kind. -*/ -static void sha3QueryFunc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - sqlite3 *db = sqlite3_context_db_handle(context); - const char *zSql = (const char*)sqlite3_value_text(argv[0]); - sqlite3_stmt *pStmt = 0; - int nCol; /* Number of columns in the result set */ - int i; /* Loop counter */ - int rc; - int n; - const char *z; - SHA3Context cx; - int iSize; - - if( argc==1 ){ - iSize = 256; - }else{ - iSize = sqlite3_value_int(argv[1]); - if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ - sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " - "384 512", -1); - return; - } - } - if( zSql==0 ) return; - SHA3Init(&cx, iSize); - while( zSql[0] ){ - rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql); - if( rc ){ - char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s", - zSql, sqlite3_errmsg(db)); - sqlite3_finalize(pStmt); - sqlite3_result_error(context, zMsg, -1); - sqlite3_free(zMsg); - return; - } - if( !sqlite3_stmt_readonly(pStmt) ){ - char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt)); - sqlite3_finalize(pStmt); - sqlite3_result_error(context, zMsg, -1); - sqlite3_free(zMsg); - return; - } - nCol = sqlite3_column_count(pStmt); - z = sqlite3_sql(pStmt); - if( z ){ - n = (int)strlen(z); - sha3_step_vformat(&cx,"S%d:",n); - SHA3Update(&cx,(unsigned char*)z,n); - } - - /* Compute a hash over the result of the query */ - while( SQLITE_ROW==sqlite3_step(pStmt) ){ - SHA3Update(&cx,(const unsigned char*)"R",1); - for(i=0; inRate==0 ){ - int sz = 256; - if( argc==2 ){ - sz = sqlite3_value_int(argv[1]); - if( sz!=224 && sz!=384 && sz!=512 ){ - sz = 256; - } - } - SHA3Init(p, sz); - } - sha3UpdateFromValue(p, argv[0]); -} - - -/* -** xFinal function for sha3_agg(). -*/ -static void sha3AggFinal(sqlite3_context *context){ - SHA3Context *p; - p = (SHA3Context*)sqlite3_aggregate_context(context, sizeof(*p)); - if( p==0 ) return; - if( p->iSize ){ - sqlite3_result_blob(context, SHA3Final(p), p->iSize/8, SQLITE_TRANSIENT); - } -} - - - -#ifdef _WIN32 - -#endif -int sqlite3_shathree_init( - sqlite3 *db, - char **pzErrMsg, - const sqlite3_api_routines *pApi -){ - int rc = SQLITE_OK; - SQLITE_EXTENSION_INIT2(pApi); - (void)pzErrMsg; /* Unused parameter */ - rc = sqlite3_create_function(db, "sha3", 1, - SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, - 0, sha3Func, 0, 0); - if( rc==SQLITE_OK ){ - rc = sqlite3_create_function(db, "sha3", 2, - SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, - 0, sha3Func, 0, 0); - } - if( rc==SQLITE_OK ){ - rc = sqlite3_create_function(db, "sha3_agg", 1, - SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, - 0, 0, sha3AggStep, sha3AggFinal); - } - if( rc==SQLITE_OK ){ - rc = sqlite3_create_function(db, "sha3_agg", 2, - SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, - 0, 0, sha3AggStep, sha3AggFinal); - } - if( rc==SQLITE_OK ){ - rc = sqlite3_create_function(db, "sha3_query", 1, - SQLITE_UTF8 | SQLITE_DIRECTONLY, - 0, sha3QueryFunc, 0, 0); - } - if( rc==SQLITE_OK ){ - rc = sqlite3_create_function(db, "sha3_query", 2, - SQLITE_UTF8 | SQLITE_DIRECTONLY, - 0, sha3QueryFunc, 0, 0); - } - return rc; -} - -/************************* End ext/misc/shathree.c ********************/ -/************************* Begin ext/misc/sha1.c ******************/ -/* -** 2017-01-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 SQLite extension implements functions that compute SHA1 hashes. -** Two SQL functions are implemented: -** -** sha1(X) -** sha1_query(Y) -** -** The sha1(X) function computes the SHA1 hash of the input X, or NULL if -** X is NULL. -** -** The sha1_query(Y) function evalutes all queries in the SQL statements of Y -** and returns a hash of their results. -*/ -/* #include "sqlite3ext.h" */ -SQLITE_EXTENSION_INIT1 -#include -#include -#include - -/****************************************************************************** -** The Hash Engine -*/ -/* Context for the SHA1 hash */ -typedef struct SHA1Context SHA1Context; -struct SHA1Context { - unsigned int state[5]; - unsigned int count[2]; - unsigned char buffer[64]; -}; - -#define SHA_ROT(x,l,r) ((x) << (l) | (x) >> (r)) -#define rol(x,k) SHA_ROT(x,k,32-(k)) -#define ror(x,k) SHA_ROT(x,32-(k),k) - -#define blk0le(i) (block[i] = (ror(block[i],8)&0xFF00FF00) \ - |(rol(block[i],8)&0x00FF00FF)) -#define blk0be(i) block[i] -#define blk(i) (block[i&15] = rol(block[(i+13)&15]^block[(i+8)&15] \ - ^block[(i+2)&15]^block[i&15],1)) - -/* - * (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1 - * - * Rl0() for little-endian and Rb0() for big-endian. Endianness is - * determined at run-time. - */ -#define Rl0(v,w,x,y,z,i) \ - z+=((w&(x^y))^y)+blk0le(i)+0x5A827999+rol(v,5);w=ror(w,2); -#define Rb0(v,w,x,y,z,i) \ - z+=((w&(x^y))^y)+blk0be(i)+0x5A827999+rol(v,5);w=ror(w,2); -#define R1(v,w,x,y,z,i) \ - z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=ror(w,2); -#define R2(v,w,x,y,z,i) \ - z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=ror(w,2); -#define R3(v,w,x,y,z,i) \ - z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=ror(w,2); -#define R4(v,w,x,y,z,i) \ - z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=ror(w,2); - -/* - * Hash a single 512-bit block. This is the core of the algorithm. - */ -static void SHA1Transform(unsigned int state[5], const unsigned char buffer[64]){ - unsigned int qq[5]; /* a, b, c, d, e; */ - static int one = 1; - unsigned int block[16]; - memcpy(block, buffer, 64); - memcpy(qq,state,5*sizeof(unsigned int)); - -#define a qq[0] -#define b qq[1] -#define c qq[2] -#define d qq[3] -#define e qq[4] - - /* Copy p->state[] to working vars */ - /* - a = state[0]; - b = state[1]; - c = state[2]; - d = state[3]; - e = state[4]; - */ - - /* 4 rounds of 20 operations each. Loop unrolled. */ - if( 1 == *(unsigned char*)&one ){ - Rl0(a,b,c,d,e, 0); Rl0(e,a,b,c,d, 1); Rl0(d,e,a,b,c, 2); Rl0(c,d,e,a,b, 3); - Rl0(b,c,d,e,a, 4); Rl0(a,b,c,d,e, 5); Rl0(e,a,b,c,d, 6); Rl0(d,e,a,b,c, 7); - Rl0(c,d,e,a,b, 8); Rl0(b,c,d,e,a, 9); Rl0(a,b,c,d,e,10); Rl0(e,a,b,c,d,11); - Rl0(d,e,a,b,c,12); Rl0(c,d,e,a,b,13); Rl0(b,c,d,e,a,14); Rl0(a,b,c,d,e,15); - }else{ - Rb0(a,b,c,d,e, 0); Rb0(e,a,b,c,d, 1); Rb0(d,e,a,b,c, 2); Rb0(c,d,e,a,b, 3); - Rb0(b,c,d,e,a, 4); Rb0(a,b,c,d,e, 5); Rb0(e,a,b,c,d, 6); Rb0(d,e,a,b,c, 7); - Rb0(c,d,e,a,b, 8); Rb0(b,c,d,e,a, 9); Rb0(a,b,c,d,e,10); Rb0(e,a,b,c,d,11); - Rb0(d,e,a,b,c,12); Rb0(c,d,e,a,b,13); Rb0(b,c,d,e,a,14); Rb0(a,b,c,d,e,15); - } - R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); - R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23); - R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27); - R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); - R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35); - R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39); - R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); - R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47); - R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51); - R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); - R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59); - R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63); - R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); - R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71); - R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75); - R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79); - - /* Add the working vars back into context.state[] */ - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; - state[4] += e; - -#undef a -#undef b -#undef c -#undef d -#undef e -} - - -/* Initialize a SHA1 context */ -static void hash_init(SHA1Context *p){ - /* SHA1 initialization constants */ - p->state[0] = 0x67452301; - p->state[1] = 0xEFCDAB89; - p->state[2] = 0x98BADCFE; - p->state[3] = 0x10325476; - p->state[4] = 0xC3D2E1F0; - p->count[0] = p->count[1] = 0; -} - -/* Add new content to the SHA1 hash */ -static void hash_step( - SHA1Context *p, /* Add content to this context */ - const unsigned char *data, /* Data to be added */ - unsigned int len /* Number of bytes in data */ -){ - unsigned int i, j; - - j = p->count[0]; - if( (p->count[0] += len << 3) < j ){ - p->count[1] += (len>>29)+1; - } - j = (j >> 3) & 63; - if( (j + len) > 63 ){ - (void)memcpy(&p->buffer[j], data, (i = 64-j)); - SHA1Transform(p->state, p->buffer); - for(; i + 63 < len; i += 64){ - SHA1Transform(p->state, &data[i]); - } - j = 0; - }else{ - i = 0; - } - (void)memcpy(&p->buffer[j], &data[i], len - i); -} - -/* Compute a string using sqlite3_vsnprintf() and hash it */ -static void hash_step_vformat( - SHA1Context *p, /* Add content to this context */ - const char *zFormat, - ... -){ - va_list ap; - int n; - char zBuf[50]; - va_start(ap, zFormat); - sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap); - va_end(ap); - n = (int)strlen(zBuf); - hash_step(p, (unsigned char*)zBuf, n); -} - - -/* Add padding and compute the message digest. Render the -** message digest as lower-case hexadecimal and put it into -** zOut[]. zOut[] must be at least 41 bytes long. */ -static void hash_finish( - SHA1Context *p, /* The SHA1 context to finish and render */ - char *zOut, /* Store hex or binary hash here */ - int bAsBinary /* 1 for binary hash, 0 for hex hash */ -){ - unsigned int i; - unsigned char finalcount[8]; - unsigned char digest[20]; - static const char zEncode[] = "0123456789abcdef"; - - for (i = 0; i < 8; i++){ - finalcount[i] = (unsigned char)((p->count[(i >= 4 ? 0 : 1)] - >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */ - } - hash_step(p, (const unsigned char *)"\200", 1); - while ((p->count[0] & 504) != 448){ - hash_step(p, (const unsigned char *)"\0", 1); - } - hash_step(p, finalcount, 8); /* Should cause a SHA1Transform() */ - for (i = 0; i < 20; i++){ - digest[i] = (unsigned char)((p->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255); - } - if( bAsBinary ){ - memcpy(zOut, digest, 20); - }else{ - for(i=0; i<20; i++){ - zOut[i*2] = zEncode[(digest[i]>>4)&0xf]; - zOut[i*2+1] = zEncode[digest[i] & 0xf]; - } - zOut[i*2]= 0; - } -} -/* End of the hashing logic -*****************************************************************************/ - -/* -** Two SQL functions: sha1(X) and sha1b(X). -** -** sha1(X) returns a lower-case hexadecimal rendering of the SHA1 hash -** of the argument X. If X is a BLOB, it is hashed as is. For all other -** types of input, X is converted into a UTF-8 string and the string -** is hashed without the trailing 0x00 terminator. The hash of a NULL -** value is NULL. -** -** sha1b(X) is the same except that it returns a 20-byte BLOB containing -** the binary hash instead of a hexadecimal string. -*/ -static void sha1Func( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - SHA1Context cx; - int eType = sqlite3_value_type(argv[0]); - int nByte = sqlite3_value_bytes(argv[0]); - const unsigned char *pData; - char zOut[44]; - - assert( argc==1 ); - if( eType==SQLITE_NULL ) return; - hash_init(&cx); - if( eType==SQLITE_BLOB ){ - pData = (const unsigned char*)sqlite3_value_blob(argv[0]); - }else{ - pData = (const unsigned char*)sqlite3_value_text(argv[0]); - } - if( pData==0 ) return; - hash_step(&cx, pData, nByte); - if( sqlite3_user_data(context)!=0 ){ - /* sha1b() - binary result */ - hash_finish(&cx, zOut, 1); - sqlite3_result_blob(context, zOut, 20, SQLITE_TRANSIENT); - }else{ - /* sha1() - hexadecimal text result */ - hash_finish(&cx, zOut, 0); - sqlite3_result_text(context, zOut, 40, SQLITE_TRANSIENT); - } -} - -/* -** Implementation of the sha1_query(SQL) function. -** -** This function compiles and runs the SQL statement(s) given in the -** argument. The results are hashed using SHA1 and that hash is returned. -** -** The original SQL text is included as part of the hash. -** -** The hash is not just a concatenation of the outputs. Each query -** is delimited and each row and value within the query is delimited, -** with all values being marked with their datatypes. -*/ -static void sha1QueryFunc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - sqlite3 *db = sqlite3_context_db_handle(context); - const char *zSql = (const char*)sqlite3_value_text(argv[0]); - sqlite3_stmt *pStmt = 0; - int nCol; /* Number of columns in the result set */ - int i; /* Loop counter */ - int rc; - int n; - const char *z; - SHA1Context cx; - char zOut[44]; - - assert( argc==1 ); - if( zSql==0 ) return; - hash_init(&cx); - while( zSql[0] ){ - rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql); - if( rc ){ - char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s", - zSql, sqlite3_errmsg(db)); - sqlite3_finalize(pStmt); - sqlite3_result_error(context, zMsg, -1); - sqlite3_free(zMsg); - return; - } - if( !sqlite3_stmt_readonly(pStmt) ){ - char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt)); - sqlite3_finalize(pStmt); - sqlite3_result_error(context, zMsg, -1); - sqlite3_free(zMsg); - return; - } - nCol = sqlite3_column_count(pStmt); - z = sqlite3_sql(pStmt); - if( z==0 ) z = ""; - n = (int)strlen(z); - hash_step_vformat(&cx,"S%d:",n); - hash_step(&cx,(unsigned char*)z,n); - - /* Compute a hash over the result of the query */ - while( SQLITE_ROW==sqlite3_step(pStmt) ){ - hash_step(&cx,(const unsigned char*)"R",1); - for(i=0; i=1; j--){ - x[j] = u & 0xff; - u >>= 8; - } - x[0] = 'I'; - hash_step(&cx, x, 9); - break; - } - case SQLITE_FLOAT: { - sqlite3_uint64 u; - int j; - unsigned char x[9]; - double r = sqlite3_column_double(pStmt,i); - memcpy(&u, &r, 8); - for(j=8; j>=1; j--){ - x[j] = u & 0xff; - u >>= 8; - } - x[0] = 'F'; - hash_step(&cx,x,9); - break; - } - case SQLITE_TEXT: { - int n2 = sqlite3_column_bytes(pStmt, i); - const unsigned char *z2 = sqlite3_column_text(pStmt, i); - hash_step_vformat(&cx,"T%d:",n2); - hash_step(&cx, z2, n2); - break; - } - case SQLITE_BLOB: { - int n2 = sqlite3_column_bytes(pStmt, i); - const unsigned char *z2 = sqlite3_column_blob(pStmt, i); - hash_step_vformat(&cx,"B%d:",n2); - hash_step(&cx, z2, n2); - break; - } - } - } - } - sqlite3_finalize(pStmt); - } - hash_finish(&cx, zOut, 0); - sqlite3_result_text(context, zOut, 40, SQLITE_TRANSIENT); -} - - -#ifdef _WIN32 - -#endif -int sqlite3_sha_init( - sqlite3 *db, - char **pzErrMsg, - const sqlite3_api_routines *pApi -){ - int rc = SQLITE_OK; - static int one = 1; - SQLITE_EXTENSION_INIT2(pApi); - (void)pzErrMsg; /* Unused parameter */ - rc = sqlite3_create_function(db, "sha1", 1, - SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, - 0, sha1Func, 0, 0); - if( rc==SQLITE_OK ){ - rc = sqlite3_create_function(db, "sha1b", 1, - SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, - (void*)&one, sha1Func, 0, 0); - } - if( rc==SQLITE_OK ){ - rc = sqlite3_create_function(db, "sha1_query", 1, - SQLITE_UTF8|SQLITE_DIRECTONLY, 0, - sha1QueryFunc, 0, 0); - } - return rc; -} - -/************************* End ext/misc/sha1.c ********************/ -/************************* Begin ext/misc/uint.c ******************/ -/* -** 2020-04-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 SQLite extension implements the UINT collating sequence. -** -** UINT works like BINARY for text, except that embedded strings -** of digits compare in numeric order. -** -** * Leading zeros are handled properly, in the sense that -** they do not mess of the magnitude comparison of embedded -** strings of digits. "x00123y" is equal to "x123y". -** -** * Only unsigned integers are recognized. Plus and minus -** signs are ignored. Decimal points and exponential notation -** are ignored. -** -** * Embedded integers can be of arbitrary length. Comparison -** is *not* limited integers that can be expressed as a -** 64-bit machine integer. -*/ -/* #include "sqlite3ext.h" */ -SQLITE_EXTENSION_INIT1 -#include -#include -#include - -/* -** Compare text in lexicographic order, except strings of digits -** compare in numeric order. -*/ -static int uintCollFunc( - void *notUsed, - int nKey1, const void *pKey1, - int nKey2, const void *pKey2 -){ - const unsigned char *zA = (const unsigned char*)pKey1; - const unsigned char *zB = (const unsigned char*)pKey2; - int i=0, j=0, x; - (void)notUsed; - while( i -#include -#include -#include - -/* Mark a function parameter as unused, to suppress nuisance compiler -** warnings. */ -#ifndef UNUSED_PARAMETER -# define UNUSED_PARAMETER(X) (void)(X) -#endif - -#ifndef IsSpace -#define IsSpace(X) isspace((unsigned char)X) -#endif - -#ifndef SQLITE_DECIMAL_MAX_DIGIT -# define SQLITE_DECIMAL_MAX_DIGIT 10000000 -#endif - -/* A decimal object */ -typedef struct Decimal Decimal; -struct Decimal { - char sign; /* 0 for positive, 1 for negative */ - char oom; /* True if an OOM is encountered */ - char isNull; /* True if holds a NULL rather than a number */ - char isInit; /* True upon initialization */ - int nDigit; /* Total number of digits */ - int nFrac; /* Number of digits to the right of the decimal point */ - signed char *a; /* Array of digits. Most significant first. */ -}; - -/* -** Release memory held by a Decimal, but do not free the object itself. -*/ -static void decimal_clear(Decimal *p){ - sqlite3_free(p->a); -} - -/* -** Destroy a Decimal object -*/ -static void decimal_free(Decimal *p){ - if( p ){ - decimal_clear(p); - sqlite3_free(p); - } -} - -/* -** Allocate a new Decimal object initialized to the text in zIn[]. -** Return NULL if any kind of error occurs. -*/ -static Decimal *decimalNewFromText(const char *zIn, int n){ - Decimal *p = 0; - int i; - int iExp = 0; - - if( zIn==0 ) goto new_from_text_failed; - p = sqlite3_malloc64( sizeof(*p) ); - if( p==0 ) goto new_from_text_failed; - p->sign = 0; - p->oom = 0; - p->isInit = 1; - p->isNull = 0; - p->nDigit = 0; - p->nFrac = 0; - p->a = sqlite3_malloc64( n+1 ); - if( p->a==0 ) goto new_from_text_failed; - for(i=0; IsSpace(zIn[i]); i++){} - if( zIn[i]=='-' ){ - p->sign = 1; - i++; - }else if( zIn[i]=='+' ){ - i++; - } - while( i='0' && c<='9' ){ - p->a[p->nDigit++] = c - '0'; - }else if( c=='.' ){ - p->nFrac = p->nDigit + 1; - }else if( c=='e' || c=='E' ){ - int j = i+1; - int neg = 0; - if( j>=n ) break; - if( zIn[j]=='-' ){ - neg = 1; - j++; - }else if( zIn[j]=='+' ){ - j++; - } - while( j='0' && zIn[j]<='9' ){ - iExp = iExp*10 + zIn[j] - '0'; - } - j++; - } - if( neg ) iExp = -iExp; - break; - } - i++; - } - if( p->nFrac ){ - p->nFrac = p->nDigit - (p->nFrac - 1); - } - if( iExp>0 ){ - if( p->nFrac>0 ){ - if( iExp<=p->nFrac ){ - p->nFrac -= iExp; - iExp = 0; - }else{ - iExp -= p->nFrac; - p->nFrac = 0; - } - } - if( iExp>0 ){ - signed char *a = sqlite3_realloc64(p->a, (sqlite3_int64)p->nDigit - + (sqlite3_int64)iExp + 1 ); - if( a==0 ) goto new_from_text_failed; - p->a = a; - memset(p->a+p->nDigit, 0, iExp); - p->nDigit += iExp; - } - }else if( iExp<0 ){ - int nExtra; - iExp = -iExp; - nExtra = p->nDigit - p->nFrac - 1; - if( nExtra ){ - if( nExtra>=iExp ){ - p->nFrac += iExp; - iExp = 0; - }else{ - iExp -= nExtra; - p->nFrac = p->nDigit - 1; - } - } - if( iExp>0 ){ - signed char *a = sqlite3_realloc64(p->a, (sqlite3_int64)p->nDigit - + (sqlite3_int64)iExp + 1 ); - if( a==0 ) goto new_from_text_failed; - p->a = a; - memmove(p->a+iExp, p->a, p->nDigit); - memset(p->a, 0, iExp); - p->nDigit += iExp; - p->nFrac += iExp; - } - } - if( p->sign ){ - for(i=0; inDigit && p->a[i]==0; i++){} - if( i>=p->nDigit ) p->sign = 0; - } - if( p->nDigit>SQLITE_DECIMAL_MAX_DIGIT ) goto new_from_text_failed; - return p; - -new_from_text_failed: - if( p ){ - if( p->a ) sqlite3_free(p->a); - sqlite3_free(p); - } - return 0; -} - -/* Forward reference */ -static Decimal *decimalFromDouble(double); - -/* -** Allocate a new Decimal object from an sqlite3_value. Return a pointer -** to the new object, or NULL if there is an error. If the pCtx argument -** is not NULL, then errors are reported on it as well. -** -** If the pIn argument is SQLITE_TEXT or SQLITE_INTEGER, it is converted -** directly into a Decimal. For SQLITE_FLOAT or for SQLITE_BLOB of length -** 8 bytes, the resulting double value is expanded into its decimal equivalent. -** If pIn is NULL or if it is a BLOB that is not exactly 8 bytes in length, -** then NULL is returned. -*/ -static Decimal *decimal_new( - sqlite3_context *pCtx, /* Report error here, if not null */ - sqlite3_value *pIn, /* Construct the decimal object from this */ - int bTextOnly /* Always interpret pIn as text if true */ -){ - Decimal *p = 0; - int eType = sqlite3_value_type(pIn); - if( bTextOnly && (eType==SQLITE_FLOAT || eType==SQLITE_BLOB) ){ - eType = SQLITE_TEXT; - } - switch( eType ){ - case SQLITE_TEXT: - case SQLITE_INTEGER: { - const char *zIn = (const char*)sqlite3_value_text(pIn); - int n = sqlite3_value_bytes(pIn); - p = decimalNewFromText(zIn, n); - if( p==0 ) goto new_failed; - break; - } - - case SQLITE_FLOAT: { - p = decimalFromDouble(sqlite3_value_double(pIn)); - break; - } - - case SQLITE_BLOB: { - const unsigned char *x; - unsigned int i; - sqlite3_uint64 v = 0; - double r; - - if( sqlite3_value_bytes(pIn)!=sizeof(r) ) break; - x = sqlite3_value_blob(pIn); - for(i=0; ioom ){ - sqlite3_result_error_nomem(pCtx); - return; - } - if( p->isNull ){ - sqlite3_result_null(pCtx); - return; - } - z = sqlite3_malloc64( (sqlite3_int64)p->nDigit+4 ); - if( z==0 ){ - sqlite3_result_error_nomem(pCtx); - return; - } - i = 0; - if( p->nDigit==0 || (p->nDigit==1 && p->a[0]==0) ){ - p->sign = 0; - } - if( p->sign ){ - z[0] = '-'; - i = 1; - } - n = p->nDigit - p->nFrac; - if( n<=0 ){ - z[i++] = '0'; - } - j = 0; - while( n>1 && p->a[j]==0 ){ - j++; - n--; - } - while( n>0 ){ - z[i++] = p->a[j] + '0'; - j++; - n--; - } - if( p->nFrac ){ - z[i++] = '.'; - do{ - z[i++] = p->a[j] + '0'; - j++; - }while( jnDigit ); - } - z[i] = 0; - sqlite3_result_text(pCtx, z, i, sqlite3_free); -} - -/* -** Round a decimal value to N significant digits. N must be positive. -*/ -static void decimal_round(Decimal *p, int N){ - int i; - int nZero; - if( N<1 ) return; - if( p==0 ) return; - if( p->nDigit<=N ) return; - for(nZero=0; nZeronDigit && p->a[nZero]==0; nZero++){} - N += nZero; - if( p->nDigit<=N ) return; - if( p->a[N]>4 ){ - p->a[N-1]++; - for(i=N-1; i>0 && p->a[i]>9; i--){ - p->a[i] = 0; - p->a[i-1]++; - } - if( p->a[0]>9 ){ - p->a[0] = 1; - p->nFrac--; - } - } - memset(&p->a[N], 0, p->nDigit - N); -} - -/* -** Make the given Decimal the result in an format similar to '%+#e'. -** In other words, show exponential notation with leading and trailing -** zeros omitted. -*/ -static void decimal_result_sci(sqlite3_context *pCtx, Decimal *p, int N){ - char *z; /* The output buffer */ - int i; /* Loop counter */ - int nZero; /* Number of leading zeros */ - int nDigit; /* Number of digits not counting trailing zeros */ - int nFrac; /* Digits to the right of the decimal point */ - int exp; /* Exponent value */ - signed char zero; /* Zero value */ - signed char *a; /* Array of digits */ - - if( p==0 || p->oom ){ - sqlite3_result_error_nomem(pCtx); - return; - } - if( p->isNull ){ - sqlite3_result_null(pCtx); - return; - } - if( N<1 ) N = 0; - for(nDigit=p->nDigit; nDigit>N && p->a[nDigit-1]==0; nDigit--){} - for(nZero=0; nZeroa[nZero]==0; nZero++){} - nFrac = p->nFrac + (nDigit - p->nDigit); - nDigit -= nZero; - z = sqlite3_malloc64( (sqlite3_int64)nDigit+20 ); - if( z==0 ){ - sqlite3_result_error_nomem(pCtx); - return; - } - if( nDigit==0 ){ - zero = 0; - a = &zero; - nDigit = 1; - nFrac = 0; - }else{ - a = &p->a[nZero]; - } - if( p->sign && nDigit>0 ){ - z[0] = '-'; - }else{ - z[0] = '+'; - } - z[1] = a[0]+'0'; - z[2] = '.'; - if( nDigit==1 ){ - z[3] = '0'; - i = 4; - }else{ - for(i=1; iisNull==0 -** pB!=0 -** pB->isNull==0 -*/ -static int decimal_cmp(Decimal *pA, Decimal *pB){ - int nASig, nBSig, rc, n; - while( pA->nFrac>0 && pA->a[pA->nDigit-1]==0 ){ - pA->nDigit--; - pA->nFrac--; - } - while( pB->nFrac>0 && pB->a[pB->nDigit-1]==0 ){ - pB->nDigit--; - pB->nFrac--; - } - if( pA->sign!=pB->sign ){ - return pA->sign ? -1 : +1; - } - if( pA->sign ){ - Decimal *pTemp = pA; - pA = pB; - pB = pTemp; - } - nASig = pA->nDigit - pA->nFrac; - nBSig = pB->nDigit - pB->nFrac; - if( nASig!=nBSig ){ - return nASig - nBSig; - } - n = pA->nDigit; - if( n>pB->nDigit ) n = pB->nDigit; - rc = memcmp(pA->a, pB->a, n); - if( rc==0 ){ - rc = pA->nDigit - pB->nDigit; - } - return rc; -} - -/* -** SQL Function: decimal_cmp(X, Y) -** -** Return negative, zero, or positive if X is less then, equal to, or -** greater than Y. -*/ -static void decimalCmpFunc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - Decimal *pA = 0, *pB = 0; - int rc; - - UNUSED_PARAMETER(argc); - pA = decimal_new(context, argv[0], 1); - if( pA==0 || pA->isNull ) goto cmp_done; - pB = decimal_new(context, argv[1], 1); - if( pB==0 || pB->isNull ) goto cmp_done; - rc = decimal_cmp(pA, pB); - if( rc<0 ) rc = -1; - else if( rc>0 ) rc = +1; - sqlite3_result_int(context, rc); -cmp_done: - decimal_free(pA); - decimal_free(pB); -} - -/* -** Expand the Decimal so that it has a least nDigit digits and nFrac -** digits to the right of the decimal point. -*/ -static void decimal_expand(Decimal *p, int nDigit, int nFrac){ - int nAddSig; - int nAddFrac; - signed char *a; - if( p==0 ) return; - nAddFrac = nFrac - p->nFrac; - nAddSig = (nDigit - p->nDigit) - nAddFrac; - if( nAddFrac==0 && nAddSig==0 ) return; - if( nDigit+1>SQLITE_DECIMAL_MAX_DIGIT ){ p->oom = 1; return; } - a = sqlite3_realloc64(p->a, nDigit+1); - if( a==0 ){ - p->oom = 1; - return; - } - p->a = a; - if( nAddSig ){ - memmove(p->a+nAddSig, p->a, p->nDigit); - memset(p->a, 0, nAddSig); - p->nDigit += nAddSig; - } - if( nAddFrac ){ - memset(p->a+p->nDigit, 0, nAddFrac); - p->nDigit += nAddFrac; - p->nFrac += nAddFrac; - } -} - -/* -** Add the value pB into pA. A := A + B. -** -** Both pA and pB might become denormalized by this routine. -*/ -static void decimal_add(Decimal *pA, Decimal *pB){ - int nSig, nFrac, nDigit; - int i, rc; - if( pA==0 ){ - return; - } - if( pA->oom || pB==0 || pB->oom ){ - pA->oom = 1; - return; - } - if( pA->isNull || pB->isNull ){ - pA->isNull = 1; - return; - } - nSig = pA->nDigit - pA->nFrac; - if( nSig && pA->a[0]==0 ) nSig--; - if( nSignDigit-pB->nFrac ){ - nSig = pB->nDigit - pB->nFrac; - } - nFrac = pA->nFrac; - if( nFracnFrac ) nFrac = pB->nFrac; - nDigit = nSig + nFrac + 1; - decimal_expand(pA, nDigit, nFrac); - decimal_expand(pB, nDigit, nFrac); - if( pA->oom || pB->oom ){ - pA->oom = 1; - }else{ - if( pA->sign==pB->sign ){ - int carry = 0; - for(i=nDigit-1; i>=0; i--){ - int x = pA->a[i] + pB->a[i] + carry; - if( x>=10 ){ - carry = 1; - pA->a[i] = x - 10; - }else{ - carry = 0; - pA->a[i] = x; - } - } - }else{ - signed char *aA, *aB; - int borrow = 0; - rc = memcmp(pA->a, pB->a, nDigit); - if( rc<0 ){ - aA = pB->a; - aB = pA->a; - pA->sign = !pA->sign; - }else{ - aA = pA->a; - aB = pB->a; - } - for(i=nDigit-1; i>=0; i--){ - int x = aA[i] - aB[i] - borrow; - if( x<0 ){ - pA->a[i] = x+10; - borrow = 1; - }else{ - pA->a[i] = x; - borrow = 0; - } - } - } - } -} - -/* -** Multiply A by B. A := A * B -** -** All significant digits after the decimal point are retained. -** Trailing zeros after the decimal point are omitted as long as -** the number of digits after the decimal point is no less than -** either the number of digits in either input. -*/ -static void decimalMul(Decimal *pA, Decimal *pB){ - signed char *acc = 0; - int i, j, k; - int minFrac; - sqlite3_int64 sumDigit; - - if( pA==0 || pA->oom || pA->isNull - || pB==0 || pB->oom || pB->isNull - ){ - goto mul_end; - } - sumDigit = pA->nDigit; - sumDigit += pB->nDigit; - sumDigit += 2; - if( sumDigit>SQLITE_DECIMAL_MAX_DIGIT ){ pA->oom = 1; return; } - acc = sqlite3_malloc64( sumDigit ); - if( acc==0 ){ - pA->oom = 1; - goto mul_end; - } - memset(acc, 0, pA->nDigit + pB->nDigit + 2); - minFrac = pA->nFrac; - if( pB->nFracnFrac; - for(i=pA->nDigit-1; i>=0; i--){ - signed char f = pA->a[i]; - int carry = 0, x; - for(j=pB->nDigit-1, k=i+j+3; j>=0; j--, k--){ - x = acc[k] + f*pB->a[j] + carry; - acc[k] = x%10; - carry = x/10; - } - x = acc[k] + carry; - acc[k] = x%10; - acc[k-1] += x/10; - } - sqlite3_free(pA->a); - pA->a = acc; - acc = 0; - pA->nDigit += pB->nDigit + 2; - pA->nFrac += pB->nFrac; - pA->sign ^= pB->sign; - while( pA->nFrac>minFrac && pA->a[pA->nDigit-1]==0 ){ - pA->nFrac--; - pA->nDigit--; - } - -mul_end: - sqlite3_free(acc); -} - -/* -** Create a new Decimal object that contains an integer power of 2. -*/ -static Decimal *decimalPow2(int N){ - Decimal *pA = 0; /* The result to be returned */ - Decimal *pX = 0; /* Multiplier */ - if( N<-20000 || N>20000 ) goto pow2_fault; - pA = decimalNewFromText("1.0", 3); - if( pA==0 || pA->oom ) goto pow2_fault; - if( N==0 ) return pA; - if( N>0 ){ - pX = decimalNewFromText("2.0", 3); - }else{ - N = -N; - pX = decimalNewFromText("0.5", 3); - } - if( pX==0 || pX->oom ) goto pow2_fault; - while( 1 /* Exit by break */ ){ - if( N & 1 ){ - decimalMul(pA, pX); - if( pA->oom ) goto pow2_fault; - } - N >>= 1; - if( N==0 ) break; - decimalMul(pX, pX); - } - decimal_free(pX); - return pA; - -pow2_fault: - decimal_free(pA); - decimal_free(pX); - return 0; -} - -/* -** Use an IEEE754 binary64 ("double") to generate a new Decimal object. -*/ -static Decimal *decimalFromDouble(double r){ - sqlite3_int64 m, a; - int e; - int isNeg; - Decimal *pA; - Decimal *pX; - char zNum[100]; - if( r<0.0 ){ - isNeg = 1; - r = -r; - }else{ - isNeg = 0; - } - memcpy(&a,&r,sizeof(a)); - if( a==0 || a==(sqlite3_int64)0x8000000000000000LL){ - e = 0; - m = 0; - }else{ - e = a>>52; - m = a & ((((sqlite3_int64)1)<<52)-1); - if( e==0 ){ - m <<= 1; - }else{ - m |= ((sqlite3_int64)1)<<52; - } - while( e<1075 && m>0 && (m&1)==0 ){ - m >>= 1; - e++; - } - if( isNeg ) m = -m; - e = e - 1075; - if( e>971 ){ - return 0; /* A NaN or an Infinity */ - } - } - - /* At this point m is the integer significand and e is the exponent */ - sqlite3_snprintf(sizeof(zNum), zNum, "%lld", m); - pA = decimalNewFromText(zNum, (int)strlen(zNum)); - pX = decimalPow2(e); - decimalMul(pA, pX); - decimal_free(pX); - return pA; -} - -/* -** SQL Function: decimal(X) -** OR: decimal_exp(X) -** -** Convert input X into decimal and then back into text. -** -** If X is originally a float, then a full decimal expansion of that floating -** point value is done. Or if X is an 8-byte blob, it is interpreted -** as a float and similarly expanded. -** -** The decimal_exp(X) function returns the result in exponential notation. -** decimal(X) returns a complete decimal, without the e+NNN at the end. -*/ -static void decimalFunc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - Decimal *p = decimal_new(context, argv[0], 0); - int N; - if( argc==2 ){ - N = sqlite3_value_int(argv[1]); - if( N>0 ) decimal_round(p, N); - }else{ - N = 0; - } - if( p ){ - if( sqlite3_user_data(context)!=0 ){ - decimal_result_sci(context, p, N); - }else{ - decimal_result(context, p); - } - decimal_free(p); - } -} - -/* -** Compare text in decimal order. -*/ -static int decimalCollFunc( - void *notUsed, - int nKey1, const void *pKey1, - int nKey2, const void *pKey2 -){ - const unsigned char *zA = (const unsigned char*)pKey1; - const unsigned char *zB = (const unsigned char*)pKey2; - Decimal *pA = decimalNewFromText((const char*)zA, nKey1); - Decimal *pB = decimalNewFromText((const char*)zB, nKey2); - int rc; - UNUSED_PARAMETER(notUsed); - if( pA==0 || pB==0 ){ - rc = 0; - }else{ - rc = decimal_cmp(pA, pB); - } - decimal_free(pA); - decimal_free(pB); - return rc; -} - - -/* -** SQL Function: decimal_add(X, Y) -** decimal_sub(X, Y) -** -** Return the sum or difference of X and Y. -*/ -static void decimalAddFunc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - Decimal *pA = decimal_new(context, argv[0], 1); - Decimal *pB = decimal_new(context, argv[1], 1); - UNUSED_PARAMETER(argc); - decimal_add(pA, pB); - decimal_result(context, pA); - decimal_free(pA); - decimal_free(pB); -} -static void decimalSubFunc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - Decimal *pA = decimal_new(context, argv[0], 1); - Decimal *pB = decimal_new(context, argv[1], 1); - UNUSED_PARAMETER(argc); - if( pB ){ - pB->sign = !pB->sign; - decimal_add(pA, pB); - decimal_result(context, pA); - } - decimal_free(pA); - decimal_free(pB); -} - -/* Aggregate function: decimal_sum(X) -** -** Works like sum() except that it uses decimal arithmetic for unlimited -** precision. -*/ -static void decimalSumStep( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - Decimal *p; - Decimal *pArg; - UNUSED_PARAMETER(argc); - p = sqlite3_aggregate_context(context, sizeof(*p)); - if( p==0 ) return; - if( !p->isInit ){ - p->isInit = 1; - p->a = sqlite3_malloc64(2); - if( p->a==0 ){ - p->oom = 1; - }else{ - p->a[0] = 0; - } - p->nDigit = 1; - p->nFrac = 0; - } - if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; - pArg = decimal_new(context, argv[0], 1); - decimal_add(p, pArg); - decimal_free(pArg); -} -static void decimalSumInverse( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - Decimal *p; - Decimal *pArg; - UNUSED_PARAMETER(argc); - p = sqlite3_aggregate_context(context, sizeof(*p)); - if( p==0 ) return; - if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; - pArg = decimal_new(context, argv[0], 1); - if( pArg ) pArg->sign = !pArg->sign; - decimal_add(p, pArg); - decimal_free(pArg); -} -static void decimalSumValue(sqlite3_context *context){ - Decimal *p = sqlite3_aggregate_context(context, 0); - if( p==0 ) return; - decimal_result(context, p); -} -static void decimalSumFinalize(sqlite3_context *context){ - Decimal *p = sqlite3_aggregate_context(context, 0); - if( p==0 ) return; - decimal_result(context, p); - decimal_clear(p); -} - -/* -** SQL Function: decimal_mul(X, Y) -** -** Return the product of X and Y. -*/ -static void decimalMulFunc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - Decimal *pA = decimal_new(context, argv[0], 1); - Decimal *pB = decimal_new(context, argv[1], 1); - UNUSED_PARAMETER(argc); - if( pA==0 || pA->oom || pA->isNull - || pB==0 || pB->oom || pB->isNull - ){ - goto mul_end; - } - decimalMul(pA, pB); - if( pA->oom ){ - goto mul_end; - } - decimal_result(context, pA); - -mul_end: - decimal_free(pA); - decimal_free(pB); -} - -/* -** SQL Function: decimal_pow2(N) -** -** Return the N-th power of 2. N must be an integer. -*/ -static void decimalPow2Func( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - UNUSED_PARAMETER(argc); - if( sqlite3_value_type(argv[0])==SQLITE_INTEGER ){ - Decimal *pA = decimalPow2(sqlite3_value_int(argv[0])); - decimal_result_sci(context, pA, 0); - decimal_free(pA); - } -} - -#ifdef _WIN32 - -#endif -int sqlite3_decimal_init( - sqlite3 *db, - char **pzErrMsg, - const sqlite3_api_routines *pApi -){ - int rc = SQLITE_OK; - static const struct { - const char *zFuncName; - int nArg; - int iArg; - void (*xFunc)(sqlite3_context*,int,sqlite3_value**); - } aFunc[] = { - { "decimal", 1, 0, decimalFunc }, - { "decimal", 2, 0, decimalFunc }, - { "decimal_exp", 1, 1, decimalFunc }, - { "decimal_exp", 2, 1, decimalFunc }, - { "decimal_cmp", 2, 0, decimalCmpFunc }, - { "decimal_add", 2, 0, decimalAddFunc }, - { "decimal_sub", 2, 0, decimalSubFunc }, - { "decimal_mul", 2, 0, decimalMulFunc }, - { "decimal_pow2", 1, 0, decimalPow2Func }, - }; - unsigned int i; - (void)pzErrMsg; /* Unused parameter */ - - SQLITE_EXTENSION_INIT2(pApi); - - for(i=0; i<(int)(sizeof(aFunc)/sizeof(aFunc[0])) && rc==SQLITE_OK; i++){ - rc = sqlite3_create_function(db, aFunc[i].zFuncName, aFunc[i].nArg, - SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC, - aFunc[i].iArg ? db : 0, aFunc[i].xFunc, 0, 0); - } - if( rc==SQLITE_OK ){ - rc = sqlite3_create_window_function(db, "decimal_sum", 1, - SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC, 0, - decimalSumStep, decimalSumFinalize, - decimalSumValue, decimalSumInverse, 0); - } - if( rc==SQLITE_OK ){ - rc = sqlite3_create_collation(db, "decimal", SQLITE_UTF8, - 0, decimalCollFunc); - } - return rc; -} - -/************************* End ext/misc/decimal.c ********************/ -/************************* Begin ext/misc/base64.c ******************/ -/* -** 2022-11-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 is a SQLite extension for converting in either direction -** between a (binary) blob and base64 text. Base64 can transit a -** sane USASCII channel unmolested. It also plays nicely in CSV or -** written as TCL brace-enclosed literals or SQL string literals, -** and can be used unmodified in XML-like documents. -** -** This is an independent implementation of conversions specified in -** RFC 4648, done on the above date by the author (Larry Brasfield) -** who thereby has the right to put this into the public domain. -** -** The conversions meet RFC 4648 requirements, provided that this -** C source specifies that line-feeds are included in the encoded -** data to limit visible line lengths to 72 characters and to -** terminate any encoded blob having non-zero length. -** -** Length limitations are not imposed except that the runtime -** SQLite string or blob length limits are respected. Otherwise, -** any length binary sequence can be represented and recovered. -** Generated base64 sequences, with their line-feeds included, -** can be concatenated; the result converted back to binary will -** be the concatenation of the represented binary sequences. -** -** This SQLite3 extension creates a function, base64(x), which -** either: converts text x containing base64 to a returned blob; -** or converts a blob x to returned text containing base64. An -** error will be thrown for other input argument types. -** -** This code relies on UTF-8 encoding only with respect to the -** meaning of the first 128 (7-bit) codes matching that of USASCII. -** It will fail miserably if somehow made to try to convert EBCDIC. -** Because it is table-driven, it could be enhanced to handle that, -** but the world and SQLite have moved on from that anachronism. -** -** To build the extension: -** Set shell variable SQDIR= -** *Nix: gcc -O2 -shared -I$SQDIR -fPIC -o base64.so base64.c -** OSX: gcc -O2 -dynamiclib -fPIC -I$SQDIR -o base64.dylib base64.c -** Win32: gcc -O2 -shared -I%SQDIR% -o base64.dll base64.c -** Win32: cl /Os -I%SQDIR% base64.c -link -dll -out:base64.dll -*/ - -#include - -/* #include "sqlite3ext.h" */ - -#ifndef deliberate_fall_through -/* Quiet some compilers about some of our intentional code. */ -# if GCC_VERSION>=7000000 -# define deliberate_fall_through __attribute__((fallthrough)); -# else -# define deliberate_fall_through -# endif -#endif - -SQLITE_EXTENSION_INIT1; - -#define PC 0x80 /* pad character */ -#define WS 0x81 /* whitespace */ -#define ND 0x82 /* Not above or digit-value */ -#define PAD_CHAR '=' - -#ifndef U8_TYPEDEF -/* typedef unsigned char u8; */ -#define U8_TYPEDEF -#endif - -/* Decoding table, ASCII (7-bit) value to base 64 digit value or other */ -static const u8 b64DigitValues[128] = { - /* HT LF VT FF CR */ - ND,ND,ND,ND, ND,ND,ND,ND, ND,WS,WS,WS, WS,WS,ND,ND, - /* US */ - ND,ND,ND,ND, ND,ND,ND,ND, ND,ND,ND,ND, ND,ND,ND,ND, - /*sp + / */ - WS,ND,ND,ND, ND,ND,ND,ND, ND,ND,ND,62, ND,ND,ND,63, - /* 0 1 5 9 = */ - 52,53,54,55, 56,57,58,59, 60,61,ND,ND, ND,PC,ND,ND, - /* A O */ - ND, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14, - /* P Z */ - 15,16,17,18, 19,20,21,22, 23,24,25,ND, ND,ND,ND,ND, - /* a o */ - ND,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40, - /* p z */ - 41,42,43,44, 45,46,47,48, 49,50,51,ND, ND,ND,ND,ND -}; - -static const char b64Numerals[64+1] -= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - -#define BX_DV_PROTO(c) \ - ((((u8)(c))<0x80)? (u8)(b64DigitValues[(u8)(c)]) : 0x80) -#define IS_BX_DIGIT(bdp) (((u8)(bdp))<0x80) -#define IS_BX_WS(bdp) ((bdp)==WS) -#define IS_BX_PAD(bdp) ((bdp)==PC) -#define BX_NUMERAL(dv) (b64Numerals[(u8)(dv)]) -/* Width of base64 lines. Should be an integer multiple of 4. */ -#define B64_DARK_MAX 72 - -/* Encode a byte buffer into base64 text with linefeeds appended to limit -** encoded group lengths to B64_DARK_MAX or to terminate the last group. -*/ -static char* toBase64( u8 *pIn, int nbIn, char *pOut ){ - int nCol = 0; - while( nbIn >= 3 ){ - /* Do the bit-shuffle, exploiting unsigned input to avoid masking. */ - pOut[0] = BX_NUMERAL(pIn[0]>>2); - pOut[1] = BX_NUMERAL(((pIn[0]<<4)|(pIn[1]>>4))&0x3f); - pOut[2] = BX_NUMERAL(((pIn[1]&0xf)<<2)|(pIn[2]>>6)); - pOut[3] = BX_NUMERAL(pIn[2]&0x3f); - pOut += 4; - nbIn -= 3; - pIn += 3; - if( (nCol += 4)>=B64_DARK_MAX || nbIn<=0 ){ - *pOut++ = '\n'; - nCol = 0; - } - } - if( nbIn > 0 ){ - signed char nco = nbIn+1; - int nbe; - unsigned long qv = *pIn++; - for( nbe=1; nbe<3; ++nbe ){ - qv <<= 8; - if( nbe=0; --nbe ){ - char ce = (nbe>= 6; - pOut[nbe] = ce; - } - pOut += 4; - *pOut++ = '\n'; - } - *pOut = 0; - return pOut; -} - -/* Skip over text which is not base64 numeral(s). */ -static char * skipNonB64( char *s, int nc ){ - char c; - while( nc-- > 0 && (c = *s) && !IS_BX_DIGIT(BX_DV_PROTO(c)) ) ++s; - return s; -} - -/* Decode base64 text into a byte buffer. */ -static u8* fromBase64( char *pIn, int ncIn, u8 *pOut ){ - if( ncIn>0 && pIn[ncIn-1]=='\n' ) --ncIn; - while( ncIn>0 && *pIn!=PAD_CHAR ){ - static signed char nboi[] = { 0, 0, 1, 2, 3 }; - char *pUse = skipNonB64(pIn, ncIn); - unsigned long qv = 0L; - int nti, nbo, nac; - ncIn -= (pUse - pIn); - pIn = pUse; - nti = (ncIn>4)? 4 : ncIn; - ncIn -= nti; - nbo = nboi[nti]; - if( nbo==0 ) break; - for( nac=0; nac<4; ++nac ){ - char c = (nac>8) & 0xff; - deliberate_fall_through; /* FALLTHRU */ - case 1: - pOut[0] = (qv>>16) & 0xff; - break; - } - pOut += nbo; - } - return pOut; -} - -/* This function does the work for the SQLite base64(x) UDF. */ -static void base64(sqlite3_context *context, int na, sqlite3_value *av[]){ - sqlite3_int64 nb; - sqlite3_int64 nv = sqlite3_value_bytes(av[0]); - sqlite3_int64 nc; - int nvMax = sqlite3_limit(sqlite3_context_db_handle(context), - SQLITE_LIMIT_LENGTH, -1); - char *cBuf; - u8 *bBuf; - assert(na==1); - switch( sqlite3_value_type(av[0]) ){ - case SQLITE_BLOB: - nb = nv; - nc = 4*((nv+2)/3); /* quads needed */ - nc += (nc+(B64_DARK_MAX-1))/B64_DARK_MAX + 1; /* LFs and a 0-terminator */ - if( nvMax < nc ){ - sqlite3_result_error(context, "blob expanded to base64 too big", -1); - return; - } - bBuf = (u8*)sqlite3_value_blob(av[0]); - if( !bBuf ){ - if( SQLITE_NOMEM==sqlite3_errcode(sqlite3_context_db_handle(context)) ){ - goto memFail; - } - sqlite3_result_text(context,"",-1,SQLITE_STATIC); - break; - } - cBuf = sqlite3_malloc64(nc); - if( !cBuf ) goto memFail; - nc = (int)(toBase64(bBuf, nb, cBuf) - cBuf); - sqlite3_result_text(context, cBuf, nc, sqlite3_free); - break; - case SQLITE_TEXT: - nc = nv; - nb = 3*((nv+3)/4); /* may overestimate due to LF and padding */ - if( nvMax < nb ){ - sqlite3_result_error(context, "blob from base64 may be too big", -1); - return; - }else if( nb<1 ){ - nb = 1; - } - cBuf = (char *)sqlite3_value_text(av[0]); - if( !cBuf ){ - if( SQLITE_NOMEM==sqlite3_errcode(sqlite3_context_db_handle(context)) ){ - goto memFail; - } - sqlite3_result_zeroblob(context, 0); - break; - } - bBuf = sqlite3_malloc64(nb); - if( !bBuf ) goto memFail; - nb = (int)(fromBase64(cBuf, nc, bBuf) - bBuf); - sqlite3_result_blob(context, bBuf, nb, sqlite3_free); - break; - default: - sqlite3_result_error(context, "base64 accepts only blob or text", -1); - return; - } - return; - memFail: - sqlite3_result_error(context, "base64 OOM", -1); -} - -/* -** Establish linkage to running SQLite library. -*/ -#ifndef SQLITE_SHELL_EXTFUNCS -#ifdef _WIN32 - -#endif -int sqlite3_base64_init -#else -static int sqlite3_base64_init -#endif -(sqlite3 *db, char **pzErr, const sqlite3_api_routines *pApi){ - SQLITE_EXTENSION_INIT2(pApi); - (void)pzErr; - return sqlite3_create_function - (db, "base64", 1, - SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS|SQLITE_DIRECTONLY|SQLITE_UTF8, - 0, base64, 0, 0); -} - -/* -** Define some macros to allow this extension to be built into the shell -** conveniently, in conjunction with use of SQLITE_SHELL_EXTFUNCS. This -** allows shell.c, as distributed, to have this extension built in. -*/ -#define BASE64_INIT(db) sqlite3_base64_init(db, 0, 0) -#define BASE64_EXPOSE(db, pzErr) /* Not needed, ..._init() does this. */ - -/************************* End ext/misc/base64.c ********************/ -/************************* Begin ext/misc/base85.c ******************/ -/* -** 2022-11-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 is a utility for converting binary to base85 or vice-versa. -** It can be built as a standalone program or an SQLite3 extension. -** -** Much like base64 representations, base85 can be sent through a -** sane USASCII channel unmolested. It also plays nicely in CSV or -** written as TCL brace-enclosed literals or SQL string literals. -** It is not suited for unmodified use in XML-like documents. -** -** The encoding used resembles Ascii85, but was devised by the author -** (Larry Brasfield) before Mozilla, Adobe, ZMODEM or other Ascii85 -** variant sources existed, in the 1984 timeframe on a VAX mainframe. -** Further, this is an independent implementation of a base85 system. -** Hence, the author has rightfully put this into the public domain. -** -** Base85 numerals are taken from the set of 7-bit USASCII codes, -** excluding control characters and Space ! " ' ( ) { | } ~ Del -** in code order representing digit values 0 to 84 (base 10.) -** -** Groups of 4 bytes, interpreted as big-endian 32-bit values, -** are represented as 5-digit base85 numbers with MS to LS digit -** order. Groups of 1-3 bytes are represented with 2-4 digits, -** still big-endian but 8-24 bit values. (Using big-endian yields -** the simplest transition to byte groups smaller than 4 bytes. -** These byte groups can also be considered base-256 numbers.) -** Groups of 0 bytes are represented with 0 digits and vice-versa. -** No pad characters are used; Encoded base85 numeral sequence -** (aka "group") length maps 1-to-1 to the decoded binary length. -** -** Any character not in the base85 numeral set delimits groups. -** When base85 is streamed or stored in containers of indefinite -** size, newline is used to separate it into sub-sequences of no -** more than 80 digits so that fgets() can be used to read it. -** -** Length limitations are not imposed except that the runtime -** SQLite string or blob length limits are respected. Otherwise, -** any length binary sequence can be represented and recovered. -** Base85 sequences can be concatenated by separating them with -** a non-base85 character; the conversion to binary will then -** be the concatenation of the represented binary sequences. - -** The standalone program either converts base85 on stdin to create -** a binary file or converts a binary file to base85 on stdout. -** Read or make it blurt its help for invocation details. -** -** The SQLite3 extension creates a function, base85(x), which will -** either convert text base85 to a blob or a blob to text base85 -** and return the result (or throw an error for other types.) -** Unless built with OMIT_BASE85_CHECKER defined, it also creates a -** function, is_base85(t), which returns 1 iff the text t contains -** nothing other than base85 numerals and whitespace, or 0 otherwise. -** -** To build the extension: -** Set shell variable SQDIR= -** and variable OPTS to -DOMIT_BASE85_CHECKER if is_base85() unwanted. -** *Nix: gcc -O2 -shared -I$SQDIR $OPTS -fPIC -o base85.so base85.c -** OSX: gcc -O2 -dynamiclib -fPIC -I$SQDIR $OPTS -o base85.dylib base85.c -** Win32: gcc -O2 -shared -I%SQDIR% %OPTS% -o base85.dll base85.c -** Win32: cl /Os -I%SQDIR% %OPTS% base85.c -link -dll -out:base85.dll -** -** To build the standalone program, define PP symbol BASE85_STANDALONE. Eg. -** *Nix or OSX: gcc -O2 -DBASE85_STANDALONE base85.c -o base85 -** Win32: gcc -O2 -DBASE85_STANDALONE -o base85.exe base85.c -** Win32: cl /Os /MD -DBASE85_STANDALONE base85.c -*/ - -#include -#include -#include -#include -#ifndef OMIT_BASE85_CHECKER -# include -#endif - -#ifndef BASE85_STANDALONE - -/* # include "sqlite3ext.h" */ - -SQLITE_EXTENSION_INIT1; - -#else - -# ifdef _WIN32 -# include -# include -# else -# define setmode(fd,m) -# endif - -static char *zHelp = - "Usage: base85 \n" - " is either -r to read or -w to write ,\n" - " content to be converted to/from base85 on stdout/stdin.\n" - " names a binary file to be rendered or created.\n" - " Or, the name '-' refers to the stdin or stdout stream.\n" - ; - -static void sayHelp(){ - printf("%s", zHelp); -} -#endif - -#ifndef U8_TYPEDEF -/* typedef unsigned char u8; */ -#define U8_TYPEDEF -#endif - -/* Classify c according to interval within USASCII set w.r.t. base85 - * Values of 1 and 3 are base85 numerals. Values of 0, 2, or 4 are not. - */ -#define B85_CLASS( c ) (((c)>='#')+((c)>'&')+((c)>='*')+((c)>'z')) - -/* Provide digitValue to b85Numeral offset as a function of above class. */ -static u8 b85_cOffset[] = { 0, '#', 0, '*'-4, 0 }; -#define B85_DNOS( c ) b85_cOffset[B85_CLASS(c)] - -/* Say whether c is a base85 numeral. */ -#define IS_B85( c ) (B85_CLASS(c) & 1) - -#if 0 /* Not used, */ -static u8 base85DigitValue( char c ){ - u8 dv = (u8)(c - '#'); - if( dv>87 ) return 0xff; - return (dv > 3)? dv-3 : dv; -} -#endif - -/* Width of base64 lines. Should be an integer multiple of 5. */ -#define B85_DARK_MAX 80 - - -static char * skipNonB85( char *s, int nc ){ - char c; - while( nc-- > 0 && (c = *s) && !IS_B85(c) ) ++s; - return s; -} - -/* Convert small integer, known to be in 0..84 inclusive, to base85 numeral. - * Do not use the macro form with argument expression having a side-effect.*/ -#if 0 -static char base85Numeral( u8 b ){ - return (b < 4)? (char)(b + '#') : (char)(b - 4 + '*'); -} -#else -# define base85Numeral( dn )\ - ((char)(((dn) < 4)? (char)((dn) + '#') : (char)((dn) - 4 + '*'))) -#endif - -static char *putcs(char *pc, char *s){ - char c; - while( (c = *s++)!=0 ) *pc++ = c; - return pc; -} - -/* Encode a byte buffer into base85 text. If pSep!=0, it's a C string -** to be appended to encoded groups to limit their length to B85_DARK_MAX -** or to terminate the last group (to aid concatenation.) -*/ -static char* toBase85( u8 *pIn, int nbIn, char *pOut, char *pSep ){ - int nCol = 0; - while( nbIn >= 4 ){ - int nco = 5; - unsigned long qbv = (((unsigned long)pIn[0])<<24) | - (pIn[1]<<16) | (pIn[2]<<8) | pIn[3]; - while( nco > 0 ){ - unsigned nqv = (unsigned)(qbv/85UL); - unsigned char dv = qbv - 85UL*nqv; - qbv = nqv; - pOut[--nco] = base85Numeral(dv); - } - nbIn -= 4; - pIn += 4; - pOut += 5; - if( pSep && (nCol += 5)>=B85_DARK_MAX ){ - pOut = putcs(pOut, pSep); - nCol = 0; - } - } - if( nbIn > 0 ){ - int nco = nbIn + 1; - unsigned long qv = *pIn++; - int nbe = 1; - while( nbe++ < nbIn ){ - qv = (qv<<8) | *pIn++; - } - nCol += nco; - while( nco > 0 ){ - u8 dv = (u8)(qv % 85); - qv /= 85; - pOut[--nco] = base85Numeral(dv); - } - pOut += (nbIn+1); - } - if( pSep && nCol>0 ) pOut = putcs(pOut, pSep); - *pOut = 0; - return pOut; -} - -/* Decode base85 text into a byte buffer. */ -static u8* fromBase85( char *pIn, int ncIn, u8 *pOut ){ - if( ncIn>0 && pIn[ncIn-1]=='\n' ) --ncIn; - while( ncIn>0 ){ - static signed char nboi[] = { 0, 0, 1, 2, 3, 4 }; - char *pUse = skipNonB85(pIn, ncIn); - unsigned long qv = 0L; - int nti, nbo; - ncIn -= (pUse - pIn); - pIn = pUse; - nti = (ncIn>5)? 5 : ncIn; - nbo = nboi[nti]; - if( nbo==0 ) break; - while( nti>0 ){ - char c = *pIn++; - u8 cdo = B85_DNOS(c); - --ncIn; - if( cdo==0 ) break; - qv = 85 * qv + (c - cdo); - --nti; - } - nbo -= nti; /* Adjust for early (non-digit) end of group. */ - switch( nbo ){ - case 4: - *pOut++ = (qv >> 24)&0xff; - /* FALLTHRU */ - case 3: - *pOut++ = (qv >> 16)&0xff; - /* FALLTHRU */ - case 2: - *pOut++ = (qv >> 8)&0xff; - /* FALLTHRU */ - case 1: - *pOut++ = qv&0xff; - /* FALLTHRU */ - case 0: - break; - } - } - return pOut; -} - -#ifndef OMIT_BASE85_CHECKER -/* Say whether input char sequence is all (base85 and/or whitespace).*/ -static int allBase85( char *p, int len ){ - char c; - while( len-- > 0 && (c = *p++) != 0 ){ - if( !IS_B85(c) && !isspace(c) ) return 0; - } - return 1; -} -#endif - -#ifndef BASE85_STANDALONE - -#ifndef OMIT_BASE85_CHECKER -/* This function does the work for the SQLite is_base85(t) UDF. */ -static void is_base85(sqlite3_context *context, int na, sqlite3_value *av[]){ - assert(na==1); - switch( sqlite3_value_type(av[0]) ){ - case SQLITE_TEXT: - { - int rv = allBase85( (char *)sqlite3_value_text(av[0]), - sqlite3_value_bytes(av[0]) ); - sqlite3_result_int(context, rv); - } - break; - case SQLITE_NULL: - sqlite3_result_null(context); - break; - default: - sqlite3_result_error(context, "is_base85 accepts only text or NULL", -1); - return; - } -} -#endif - -/* This function does the work for the SQLite base85(x) UDF. */ -static void base85(sqlite3_context *context, int na, sqlite3_value *av[]){ - sqlite3_int64 nb, nc, nv = sqlite3_value_bytes(av[0]); - int nvMax = sqlite3_limit(sqlite3_context_db_handle(context), - SQLITE_LIMIT_LENGTH, -1); - char *cBuf; - u8 *bBuf; - assert(na==1); - switch( sqlite3_value_type(av[0]) ){ - case SQLITE_BLOB: - nb = nv; - /* ulongs tail newlines tailenc+nul*/ - nc = 5*(nv/4) + nv%4 + nv/64+1 + 2; - if( nvMax < nc ){ - sqlite3_result_error(context, "blob expanded to base85 too big", -1); - return; - } - bBuf = (u8*)sqlite3_value_blob(av[0]); - if( !bBuf ){ - if( SQLITE_NOMEM==sqlite3_errcode(sqlite3_context_db_handle(context)) ){ - goto memFail; - } - sqlite3_result_text(context,"",-1,SQLITE_STATIC); - break; - } - cBuf = sqlite3_malloc64(nc); - if( !cBuf ) goto memFail; - nc = (int)(toBase85(bBuf, nb, cBuf, "\n") - cBuf); - sqlite3_result_text(context, cBuf, nc, sqlite3_free); - break; - case SQLITE_TEXT: - nc = nv; - nb = 4*(nv/5) + nv%5; /* may overestimate */ - if( nvMax < nb ){ - sqlite3_result_error(context, "blob from base85 may be too big", -1); - return; - }else if( nb<1 ){ - nb = 1; - } - cBuf = (char *)sqlite3_value_text(av[0]); - if( !cBuf ){ - if( SQLITE_NOMEM==sqlite3_errcode(sqlite3_context_db_handle(context)) ){ - goto memFail; - } - sqlite3_result_zeroblob(context, 0); - break; - } - bBuf = sqlite3_malloc64(nb); - if( !bBuf ) goto memFail; - nb = (int)(fromBase85(cBuf, nc, bBuf) - bBuf); - sqlite3_result_blob(context, bBuf, nb, sqlite3_free); - break; - default: - sqlite3_result_error(context, "base85 accepts only blob or text.", -1); - return; - } - return; - memFail: - sqlite3_result_error(context, "base85 OOM", -1); -} - -/* -** Establish linkage to running SQLite library. -*/ -#ifndef SQLITE_SHELL_EXTFUNCS -#ifdef _WIN32 - -#endif -int sqlite3_base85_init -#else -static int sqlite3_base85_init -#endif -(sqlite3 *db, char **pzErr, const sqlite3_api_routines *pApi){ - SQLITE_EXTENSION_INIT2(pApi); - (void)pzErr; -#ifndef OMIT_BASE85_CHECKER - { - int rc = sqlite3_create_function - (db, "is_base85", 1, - SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS|SQLITE_UTF8, - 0, is_base85, 0, 0); - if( rc!=SQLITE_OK ) return rc; - } -#endif - return sqlite3_create_function - (db, "base85", 1, - SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS|SQLITE_DIRECTONLY|SQLITE_UTF8, - 0, base85, 0, 0); -} - -/* -** Define some macros to allow this extension to be built into the shell -** conveniently, in conjunction with use of SQLITE_SHELL_EXTFUNCS. This -** allows shell.c, as distributed, to have this extension built in. -*/ -# define BASE85_INIT(db) sqlite3_base85_init(db, 0, 0) -# define BASE85_EXPOSE(db, pzErr) /* Not needed, ..._init() does this. */ - -#else /* standalone program */ - -int main(int na, char *av[]){ - int cin; - int rc = 0; - u8 bBuf[4*(B85_DARK_MAX/5)]; - char cBuf[5*(sizeof(bBuf)/4)+2]; - size_t nio; -# ifndef OMIT_BASE85_CHECKER - int b85Clean = 1; -# endif - char rw; - FILE *fb = 0, *foc = 0; - char fmode[3] = "xb"; - if( na < 3 || av[1][0]!='-' || (rw = av[1][1])==0 || (rw!='r' && rw!='w') ){ - sayHelp(); - return 0; - } - fmode[0] = rw; - if( av[2][0]=='-' && av[2][1]==0 ){ - switch( rw ){ - case 'r': - fb = stdin; - setmode(fileno(stdin), O_BINARY); - break; - case 'w': - fb = stdout; - setmode(fileno(stdout), O_BINARY); - break; - } - }else{ - fb = fopen(av[2], fmode); - foc = fb; - } - if( !fb ){ - fprintf(stderr, "Cannot open %s for %c\n", av[2], rw); - rc = 1; - }else{ - switch( rw ){ - case 'r': - while( (nio = fread( bBuf, 1, sizeof(bBuf), fb))>0 ){ - toBase85( bBuf, (int)nio, cBuf, 0 ); - fprintf(stdout, "%s\n", cBuf); - } - break; - case 'w': - while( 0 != fgets(cBuf, sizeof(cBuf), stdin) ){ - int nc = strlen(cBuf); - size_t nbo = fromBase85( cBuf, nc, bBuf ) - bBuf; - if( 1 != fwrite(bBuf, nbo, 1, fb) ) rc = 1; -#ifndef OMIT_BASE85_CHECKER - b85Clean &= allBase85( cBuf, nc ); -#endif - } - break; - default: - sayHelp(); - rc = 1; - } - if( foc ) fclose(foc); - } -# ifndef OMIT_BASE85_CHECKER - if( !b85Clean ){ - fprintf(stderr, "Base85 input had non-base85 dark or control content.\n"); - } -# endif - return rc; -} - -#endif - -/************************* End ext/misc/base85.c ********************/ -/************************* Begin ext/misc/ieee754.c ******************/ -/* -** 2013-04-17 -** -** 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 extension implements functions for the exact display -** and input of IEEE754 Binary64 floating-point numbers. -** -** ieee754(X) -** ieee754(Y,Z) -** -** In the first form, the value X should be a floating-point number. -** The function will return a string of the form 'ieee754(Y,Z)' where -** Y and Z are integers such that X==Y*pow(2,Z). -** -** In the second form, Y and Z are integers which are the mantissa and -** base-2 exponent of a new floating point number. The function returns -** a floating-point value equal to Y*pow(2,Z). -** -** Examples: -** -** ieee754(2.0) -> 'ieee754(2,0)' -** ieee754(45.25) -> 'ieee754(181,-2)' -** ieee754(2, 0) -> 2.0 -** ieee754(181, -2) -> 45.25 -** -** Two additional functions break apart the one-argument ieee754() -** result into separate integer values: -** -** ieee754_mantissa(45.25) -> 181 -** ieee754_exponent(45.25) -> -2 -** -** These functions convert binary64 numbers into blobs and back again. -** -** ieee754_from_blob(x'3ff0000000000000') -> 1.0 -** ieee754_to_blob(1.0) -> x'3ff0000000000000' -** -** In all single-argument functions, if the argument is an 8-byte blob -** then that blob is interpreted as a big-endian binary64 value. -** -** -** EXACT DECIMAL REPRESENTATION OF BINARY64 VALUES -** ----------------------------------------------- -** -** This extension in combination with the separate 'decimal' extension -** can be used to compute the exact decimal representation of binary64 -** values. To begin, first compute a table of exponent values: -** -** CREATE TABLE pow2(x INTEGER PRIMARY KEY, v TEXT); -** WITH RECURSIVE c(x,v) AS ( -** VALUES(0,'1') -** UNION ALL -** SELECT x+1, decimal_mul(v,'2') FROM c WHERE x+1<=971 -** ) INSERT INTO pow2(x,v) SELECT x, v FROM c; -** WITH RECURSIVE c(x,v) AS ( -** VALUES(-1,'0.5') -** UNION ALL -** SELECT x-1, decimal_mul(v,'0.5') FROM c WHERE x-1>=-1075 -** ) INSERT INTO pow2(x,v) SELECT x, v FROM c; -** -** Then, to compute the exact decimal representation of a floating -** point value (the value 47.49 is used in the example) do: -** -** WITH c(n) AS (VALUES(47.49)) -** ---------------^^^^^---- Replace with whatever you want -** SELECT decimal_mul(ieee754_mantissa(c.n),pow2.v) -** FROM pow2, c WHERE pow2.x=ieee754_exponent(c.n); -** -** Here is a query to show various boundry values for the binary64 -** number format: -** -** WITH c(name,bin) AS (VALUES -** ('minimum positive value', x'0000000000000001'), -** ('maximum subnormal value', x'000fffffffffffff'), -** ('minimum positive normal value', x'0010000000000000'), -** ('maximum value', x'7fefffffffffffff')) -** SELECT c.name, decimal_mul(ieee754_mantissa(c.bin),pow2.v) -** FROM pow2, c WHERE pow2.x=ieee754_exponent(c.bin); -** -*/ -/* #include "sqlite3ext.h" */ -SQLITE_EXTENSION_INIT1 -#include -#include - -/* Mark a function parameter as unused, to suppress nuisance compiler -** warnings. */ -#ifndef UNUSED_PARAMETER -# define UNUSED_PARAMETER(X) (void)(X) -#endif - -/* -** Implementation of the ieee754() function -*/ -static void ieee754func( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - if( argc==1 ){ - sqlite3_int64 m, a; - double r; - int e; - int isNeg; - char zResult[100]; - assert( sizeof(m)==sizeof(r) ); - if( sqlite3_value_type(argv[0])==SQLITE_BLOB - && sqlite3_value_bytes(argv[0])==sizeof(r) - ){ - const unsigned char *x = sqlite3_value_blob(argv[0]); - unsigned int i; - sqlite3_uint64 v = 0; - for(i=0; i>52; - m = a & ((((sqlite3_int64)1)<<52)-1); - if( e==0 ){ - m <<= 1; - }else{ - m |= ((sqlite3_int64)1)<<52; - } - while( e<1075 && m>0 && (m&1)==0 ){ - m >>= 1; - e++; - } - if( isNeg ) m = -m; - } - switch( *(int*)sqlite3_user_data(context) ){ - case 0: - sqlite3_snprintf(sizeof(zResult), zResult, "ieee754(%lld,%d)", - m, e-1075); - sqlite3_result_text(context, zResult, -1, SQLITE_TRANSIENT); - break; - case 1: - sqlite3_result_int64(context, m); - break; - case 2: - sqlite3_result_int(context, e-1075); - break; - } - }else{ - sqlite3_int64 m, e, a; - double r; - int isNeg = 0; - m = sqlite3_value_int64(argv[0]); - e = sqlite3_value_int64(argv[1]); - - /* Limit the range of e. Ticket 22dea1cfdb9151e4 2021-03-02 */ - if( e>10000 ){ - e = 10000; - }else if( e<-10000 ){ - e = -10000; - } - - if( m<0 ){ - if( m<(-9223372036854775807LL) ) return; - isNeg = 1; - m = -m; - }else if( m==0 && e>-1000 && e<1000 ){ - sqlite3_result_double(context, 0.0); - return; - } - while( (m>>32)&0xffe00000 ){ - m >>= 1; - e++; - } - while( m!=0 && ((m>>32)&0xfff00000)==0 ){ - m <<= 1; - e--; - } - e += 1075; - if( e<=0 ){ - /* Subnormal */ - if( 1-e >= 64 ){ - m = 0; - }else{ - m >>= 1-e; - } - e = 0; - }else if( e>0x7ff ){ - e = 0x7ff; - } - a = m & ((((sqlite3_int64)1)<<52)-1); - a |= e<<52; - if( isNeg ) a |= ((sqlite3_uint64)1)<<63; - memcpy(&r, &a, sizeof(r)); - sqlite3_result_double(context, r); - } -} - -/* -** Functions to convert between blobs and floats. -*/ -static void ieee754func_from_blob( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - UNUSED_PARAMETER(argc); - if( sqlite3_value_type(argv[0])==SQLITE_BLOB - && sqlite3_value_bytes(argv[0])==sizeof(double) - ){ - double r; - const unsigned char *x = sqlite3_value_blob(argv[0]); - unsigned int i; - sqlite3_uint64 v = 0; - for(i=0; i>= 8; - } - sqlite3_result_blob(context, a, sizeof(r), SQLITE_TRANSIENT); - } -} - -/* -** Functions to convert between 64-bit integers and floats. -** -** The bit patterns are copied. The numeric values are different. -*/ -static void ieee754func_from_int( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - UNUSED_PARAMETER(argc); - if( sqlite3_value_type(argv[0])==SQLITE_INTEGER ){ - double r; - sqlite3_int64 v = sqlite3_value_int64(argv[0]); - memcpy(&r, &v, sizeof(r)); - sqlite3_result_double(context, r); - } -} -static void ieee754func_to_int( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - UNUSED_PARAMETER(argc); - if( sqlite3_value_type(argv[0])==SQLITE_FLOAT ){ - double r = sqlite3_value_double(argv[0]); - sqlite3_uint64 v; - memcpy(&v, &r, sizeof(v)); - sqlite3_result_int64(context, v); - } -} - -/* -** SQL Function: ieee754_inc(r,N) -** -** Move the floating point value r by N quantums and return the new -** values. -** -** Behind the scenes: this routine merely casts r into a 64-bit unsigned -** integer, adds N, then casts the value back into float. -** -** Example: To find the smallest positive number: -** -** SELECT ieee754_inc(0.0,+1); -*/ -static void ieee754inc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - double r; - sqlite3_int64 N; - sqlite3_uint64 m1, m2; - double r2; - UNUSED_PARAMETER(argc); - r = sqlite3_value_double(argv[0]); - N = sqlite3_value_int64(argv[1]); - memcpy(&m1, &r, 8); - m2 = m1 + N; - memcpy(&r2, &m2, 8); - sqlite3_result_double(context, r2); -} - - -#ifdef _WIN32 - -#endif -int sqlite3_ieee_init( - sqlite3 *db, - char **pzErrMsg, - const sqlite3_api_routines *pApi -){ - static const struct { - char *zFName; - int nArg; - int iAux; - void (*xFunc)(sqlite3_context*,int,sqlite3_value**); - } aFunc[] = { - { "ieee754", 1, 0, ieee754func }, - { "ieee754", 2, 0, ieee754func }, - { "ieee754_mantissa", 1, 1, ieee754func }, - { "ieee754_exponent", 1, 2, ieee754func }, - { "ieee754_to_blob", 1, 0, ieee754func_to_blob }, - { "ieee754_from_blob", 1, 0, ieee754func_from_blob }, - { "ieee754_to_int", 1, 0, ieee754func_to_int }, - { "ieee754_from_int", 1, 0, ieee754func_from_int }, - { "ieee754_inc", 2, 0, ieee754inc }, - }; - unsigned int i; - int rc = SQLITE_OK; - SQLITE_EXTENSION_INIT2(pApi); - (void)pzErrMsg; /* Unused parameter */ - for(i=0; i= 0 ) -** for each produced value (independent of production time ordering.) -** -** All parameters must be either integer or convertable to integer. -** The start parameter is required. -** The stop parameter defaults to (1<<32)-1 (aka 4294967295 or 0xffffffff) -** The step parameter defaults to 1 and 0 is treated as 1. -** -** Examples: -** -** SELECT * FROM generate_series(0,100,5); -** -** The query above returns integers from 0 through 100 counting by steps -** of 5. In other words, 0, 5, 10, 15, ..., 90, 95, 100. There are a total -** of 21 rows. -** -** SELECT * FROM generate_series(0,100); -** -** Integers from 0 through 100 with a step size of 1. 101 rows. -** -** SELECT * FROM generate_series(20) LIMIT 10; -** -** Integers 20 through 29. 10 rows. -** -** SELECT * FROM generate_series(0,-100,-5); -** -** Integers 0 -5 -10 ... -100. 21 rows. -** -** SELECT * FROM generate_series(0,-1); -** -** Empty sequence. -** -** HOW IT WORKS -** -** The generate_series "function" is really a virtual table with the -** following schema: -** -** CREATE TABLE generate_series( -** value, -** start HIDDEN, -** stop HIDDEN, -** step HIDDEN -** ); -** -** The virtual table also has a rowid which is an alias for the value. -** -** Function arguments in queries against this virtual table are translated -** into equality constraints against successive hidden columns. In other -** words, the following pairs of queries are equivalent to each other: -** -** SELECT * FROM generate_series(0,100,5); -** SELECT * FROM generate_series WHERE start=0 AND stop=100 AND step=5; -** -** SELECT * FROM generate_series(0,100); -** SELECT * FROM generate_series WHERE start=0 AND stop=100; -** -** SELECT * FROM generate_series(20) LIMIT 10; -** SELECT * FROM generate_series WHERE start=20 LIMIT 10; -** -** The generate_series virtual table implementation leaves the xCreate method -** set to NULL. This means that it is not possible to do a CREATE VIRTUAL -** TABLE command with "generate_series" as the USING argument. Instead, there -** is a single generate_series virtual table that is always available without -** having to be created first. -** -** The xBestIndex method looks for equality constraints against the hidden -** start, stop, and step columns, and if present, it uses those constraints -** to bound the sequence of generated values. If the equality constraints -** are missing, it uses 0 for start, 4294967295 for stop, and 1 for step. -** xBestIndex returns a small cost when both start and stop are available, -** and a very large cost if either start or stop are unavailable. This -** encourages the query planner to order joins such that the bounds of the -** series are well-defined. -** -** Update on 2024-08-22: -** xBestIndex now also looks for equality and inequality constraints against -** the value column and uses those constraints as additional bounds against -** the sequence range. Thus, a query like this: -** -** SELECT value FROM generate_series($SA,$EA) -** WHERE value BETWEEN $SB AND $EB; -** -** Is logically the same as: -** -** SELECT value FROM generate_series(max($SA,$SB),min($EA,$EB)); -** -** Constraints on the value column can server as substitutes for constraints -** on the hidden start and stop columns. So, the following two queries -** are equivalent: -** -** SELECT value FROM generate_series($S,$E); -** SELECT value FROM generate_series WHERE value BETWEEN $S and $E; -** -*/ -/* #include "sqlite3ext.h" */ -SQLITE_EXTENSION_INIT1 -#include -#include -#include -#include - -#ifndef SQLITE_OMIT_VIRTUALTABLE - -/* series_cursor is a subclass of sqlite3_vtab_cursor which will -** serve as the underlying representation of a cursor that scans -** over rows of the result. -** -** iOBase, iOTerm, and iOStep are the original values of the -** start=, stop=, and step= constraints on the query. These are -** the values reported by the start, stop, and step columns of the -** virtual table. -** -** iBase, iTerm, iStep, and bDescp are the actual values used to generate -** the sequence. These might be different from the iOxxxx values. -** For example in -** -** SELECT value FROM generate_series(1,11,2) -** WHERE value BETWEEN 4 AND 8; -** -** The iOBase is 1, but the iBase is 5. iOTerm is 11 but iTerm is 7. -** Another example: -** -** SELECT value FROM generate_series(1,15,3) ORDER BY value DESC; -** -** The cursor initialization for the above query is: -** -** iOBase = 1 iBase = 13 -** iOTerm = 15 iTerm = 1 -** iOStep = 3 iStep = 3 bDesc = 1 -** -** The actual step size is unsigned so that can have a value of -** +9223372036854775808 which is needed for querys like this: -** -** SELECT value -** FROM generate_series(9223372036854775807, -** -9223372036854775808, -** -9223372036854775808) -** ORDER BY value ASC; -** -** The setup for the previous query will be: -** -** iOBase = 9223372036854775807 iBase = -1 -** iOTerm = -9223372036854775808 iTerm = 9223372036854775807 -** iOStep = -9223372036854775808 iStep = 9223372036854775808 bDesc = 0 -*/ -/* typedef unsigned char u8; */ -typedef struct series_cursor series_cursor; -struct series_cursor { - sqlite3_vtab_cursor base; /* Base class - must be first */ - sqlite3_int64 iOBase; /* Original starting value ("start") */ - sqlite3_int64 iOTerm; /* Original terminal value ("stop") */ - sqlite3_int64 iOStep; /* Original step value */ - sqlite3_int64 iBase; /* Starting value to actually use */ - sqlite3_int64 iTerm; /* Terminal value to actually use */ - sqlite3_uint64 iStep; /* The step size */ - sqlite3_int64 iValue; /* Current value */ - u8 bDesc; /* iStep is really negative */ - u8 bDone; /* True if stepped past last element */ -}; - -/* -** Computed the difference between two 64-bit signed integers using a -** convoluted computation designed to work around the silly restriction -** against signed integer overflow in C. -*/ -static sqlite3_uint64 span64(sqlite3_int64 a, sqlite3_int64 b){ - assert( a>=b ); - return (*(sqlite3_uint64*)&a) - (*(sqlite3_uint64*)&b); -} - -/* -** Add or substract an unsigned 64-bit integer from a signed 64-bit integer -** and return the new signed 64-bit integer. -*/ -static sqlite3_int64 add64(sqlite3_int64 a, sqlite3_uint64 b){ - sqlite3_uint64 x = *(sqlite3_uint64*)&a; - x += b; - return *(sqlite3_int64*)&x; -} -static sqlite3_int64 sub64(sqlite3_int64 a, sqlite3_uint64 b){ - sqlite3_uint64 x = *(sqlite3_uint64*)&a; - x -= b; - return *(sqlite3_int64*)&x; -} - -/* -** The seriesConnect() method is invoked to create a new -** series_vtab that describes the generate_series virtual table. -** -** Think of this routine as the constructor for series_vtab objects. -** -** All this routine needs to do is: -** -** (1) Allocate the series_vtab object and initialize all fields. -** -** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the -** result set of queries against generate_series will look like. -*/ -static int seriesConnect( - sqlite3 *db, - void *pUnused, - int argcUnused, const char *const*argvUnused, - sqlite3_vtab **ppVtab, - char **pzErrUnused -){ - sqlite3_vtab *pNew; - int rc; - -/* Column numbers */ -#define SERIES_COLUMN_ROWID (-1) -#define SERIES_COLUMN_VALUE 0 -#define SERIES_COLUMN_START 1 -#define SERIES_COLUMN_STOP 2 -#define SERIES_COLUMN_STEP 3 - - (void)pUnused; - (void)argcUnused; - (void)argvUnused; - (void)pzErrUnused; - rc = sqlite3_declare_vtab(db, - "CREATE TABLE x(value,start hidden,stop hidden,step hidden)"); - if( rc==SQLITE_OK ){ - pNew = *ppVtab = sqlite3_malloc64( sizeof(*pNew) ); - if( pNew==0 ) return SQLITE_NOMEM; - memset(pNew, 0, sizeof(*pNew)); - sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS); - } - return rc; -} - -/* -** This method is the destructor for series_cursor objects. -*/ -static int seriesDisconnect(sqlite3_vtab *pVtab){ - sqlite3_free(pVtab); - return SQLITE_OK; -} - -/* -** Constructor for a new series_cursor object. -*/ -static int seriesOpen(sqlite3_vtab *pUnused, sqlite3_vtab_cursor **ppCursor){ - series_cursor *pCur; - (void)pUnused; - pCur = sqlite3_malloc64( sizeof(*pCur) ); - if( pCur==0 ) return SQLITE_NOMEM; - memset(pCur, 0, sizeof(*pCur)); - *ppCursor = &pCur->base; - return SQLITE_OK; -} - -/* -** Destructor for a series_cursor. -*/ -static int seriesClose(sqlite3_vtab_cursor *cur){ - sqlite3_free(cur); - return SQLITE_OK; -} - - -/* -** Advance a series_cursor to its next row of output. -*/ -static int seriesNext(sqlite3_vtab_cursor *cur){ - series_cursor *pCur = (series_cursor*)cur; - if( pCur->iValue==pCur->iTerm ){ - pCur->bDone = 1; - }else if( pCur->bDesc ){ - pCur->iValue = sub64(pCur->iValue, pCur->iStep); - assert( pCur->iValue>=pCur->iTerm ); - }else{ - pCur->iValue = add64(pCur->iValue, pCur->iStep); - assert( pCur->iValue<=pCur->iTerm ); - } - return SQLITE_OK; -} - -/* -** Return values of columns for the row at which the series_cursor -** is currently pointing. -*/ -static int seriesColumn( - sqlite3_vtab_cursor *cur, /* The cursor */ - sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ - int i /* Which column to return */ -){ - series_cursor *pCur = (series_cursor*)cur; - sqlite3_int64 x = 0; - switch( i ){ - case SERIES_COLUMN_START: x = pCur->iOBase; break; - case SERIES_COLUMN_STOP: x = pCur->iOTerm; break; - case SERIES_COLUMN_STEP: x = pCur->iOStep; break; - default: x = pCur->iValue; break; - } - sqlite3_result_int64(ctx, x); - return SQLITE_OK; -} - -#ifndef LARGEST_UINT64 -#define LARGEST_INT64 ((sqlite3_int64)0x7fffffffffffffffLL) -#define LARGEST_UINT64 ((sqlite3_uint64)0xffffffffffffffffULL) -#define SMALLEST_INT64 ((sqlite3_int64)0x8000000000000000LL) -#endif - -/* -** The rowid is the same as the value. -*/ -static int seriesRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ - series_cursor *pCur = (series_cursor*)cur; - *pRowid = pCur->iValue; - return SQLITE_OK; -} - -/* -** Return TRUE if the cursor has been moved off of the last -** row of output. -*/ -static int seriesEof(sqlite3_vtab_cursor *cur){ - series_cursor *pCur = (series_cursor*)cur; - return pCur->bDone; -} - -/* True to cause run-time checking of the start=, stop=, and/or step= -** parameters. The only reason to do this is for testing the -** constraint checking logic for virtual tables in the SQLite core. -*/ -#ifndef SQLITE_SERIES_CONSTRAINT_VERIFY -# define SQLITE_SERIES_CONSTRAINT_VERIFY 0 -#endif - -/* -** Return the number of steps between pCur->iBase and pCur->iTerm if -** the step width is pCur->iStep. -*/ -static sqlite3_uint64 seriesSteps(series_cursor *pCur){ - if( pCur->bDesc ){ - assert( pCur->iBase >= pCur->iTerm ); - return span64(pCur->iBase, pCur->iTerm)/pCur->iStep; - }else{ - assert( pCur->iBase <= pCur->iTerm ); - return span64(pCur->iTerm, pCur->iBase)/pCur->iStep; - } -} - -#if defined(SQLITE_ENABLE_MATH_FUNCTIONS) || defined(_WIN32) -/* -** Case 1 (the most common case): -** The standard math library is available so use ceil() and floor() from there. -*/ -static double seriesCeil(double r){ return ceil(r); } -static double seriesFloor(double r){ return floor(r); } -#elif defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC) -/* -** Case 2 (2nd most common): Use GCC/Clang builtins -*/ -static double seriesCeil(double r){ return __builtin_ceil(r); } -static double seriesFloor(double r){ return __builtin_floor(r); } -#else -/* -** Case 3 (rarely happens): Use home-grown ceil() and floor() routines. -*/ -static double seriesCeil(double r){ - sqlite3_int64 x; - if( r!=r ) return r; - if( r<=(-4503599627370496.0) ) return r; - if( r>=(+4503599627370496.0) ) return r; - x = (sqlite3_int64)r; - if( r==(double)x ) return r; - if( r>(double)x ) x++; - return (double)x; -} -static double seriesFloor(double r){ - sqlite3_int64 x; - if( r!=r ) return r; - if( r<=(-4503599627370496.0) ) return r; - if( r>=(+4503599627370496.0) ) return r; - x = (sqlite3_int64)r; - if( r==(double)x ) return r; - if( r<(double)x ) x--; - return (double)x; -} -#endif - -/* -** This method is called to "rewind" the series_cursor object back -** to the first row of output. This method is always called at least -** once prior to any call to seriesColumn() or seriesRowid() or -** seriesEof(). -** -** The query plan selected by seriesBestIndex is passed in the idxNum -** parameter. (idxStr is not used in this implementation.) idxNum -** is a bitmask showing which constraints are available: -** -** 0x0001: start=VALUE -** 0x0002: stop=VALUE -** 0x0004: step=VALUE -** 0x0008: descending order -** 0x0010: ascending order -** 0x0020: LIMIT VALUE -** 0x0040: OFFSET VALUE -** 0x0080: value=VALUE -** 0x0100: value>=VALUE -** 0x0200: value>VALUE -** 0x1000: value<=VALUE -** 0x2000: value0, the value of the LIMIT */ - sqlite3_int64 iOffset = 0; /* if >0, the value of the OFFSET */ - - (void)idxStrUnused; - - /* If any constraints have a NULL value, then return no rows. - ** See ticket https://sqlite.org/src/info/fac496b61722daf2 - */ - for(i=0; i

");
-      }else{
-        spec.eStyle = eStyle;
-        sqlite3_format_query_result(pStmt, &spec, pzErrMsg);
-      }
-
-      /* print usage stats if stats on */
-      if( pArg && pArg->statsOn ){
-        display_stats(db, pArg, 0);
-      }
-
-      /* print loop-counters if required */
-      if( pArg && pArg->mode.scanstatsOn ){
-        char *zErr = 0;
-        switch( pArg->mode.scanstatsOn ){
-          case 1:   spec.eStyle = QRF_STYLE_Stats;     break;
-          case 2:   spec.eStyle = QRF_STYLE_StatsEst;  break;
-          default:  spec.eStyle = QRF_STYLE_StatsVm;   break;
-        }
-        sqlite3_reset(pStmt);
-        rc = sqlite3_format_query_result(pStmt, &spec, &zErr);
-        if( rc ){
-          cli_printf(stderr, "Stats query failed: %s\n", zErr);
-          sqlite3_free(zErr);
-        }          
-      }
-
-      /* Finalize the statement just executed. If this fails, save a
-      ** copy of the error message. Otherwise, set zSql to point to the
-      ** next statement to execute. */
-      rc2 = sqlite3_finalize(pStmt);
-      if( rc!=SQLITE_NOMEM ) rc = rc2;
-      if( rc==SQLITE_OK ){
-        zSql = zLeftover;
-        while( IsSpace(zSql[0]) ) zSql++;
-      }else if( pzErrMsg ){
-        *pzErrMsg = save_err_msg(db, "stepping", rc, 0);
-      }
-
-      /* clear saved stmt handle */
-      if( pArg ){
-        pArg->pStmt = NULL;
-      }
-    }
-  } /* end while */
-
-  return rc;
-}
-
-/*
-** Release memory previously allocated by tableColumnList().
-*/
-static void freeColumnList(char **azCol){
-  int i;
-  for(i=1; azCol[i]; i++){
-    sqlite3_free(azCol[i]);
-  }
-  /* azCol[0] is a static string */
-  sqlite3_free(azCol);
-}
-
-/*
-** Return a list of pointers to strings which are the names of all
-** columns in table zTab.   The memory to hold the names is dynamically
-** allocated and must be released by the caller using a subsequent call
-** to freeColumnList().
-**
-** The azCol[0] entry is usually NULL.  However, if zTab contains a rowid
-** value that needs to be preserved, then azCol[0] is filled in with the
-** name of the rowid column.
-**
-** The first regular column in the table is azCol[1].  The list is terminated
-** by an entry with azCol[i]==0.
-*/
-static char **tableColumnList(ShellState *p, const char *zTab){
-  char **azCol = 0;
-  sqlite3_stmt *pStmt;
-  char *zSql;
-  int nCol = 0;
-  i64 nAlloc = 0;
-  int nPK = 0;       /* Number of PRIMARY KEY columns seen */
-  int isIPK = 0;     /* True if one PRIMARY KEY column of type INTEGER */
-  int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
-  int rc;
-
-  zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
-  shell_check_oom(zSql);
-  rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-  sqlite3_free(zSql);
-  if( rc ) return 0;
-  while( sqlite3_step(pStmt)==SQLITE_ROW ){
-    if( nCol>=nAlloc-2 ){
-      nAlloc = nAlloc*2 + nCol + 10;
-      azCol = sqlite3_realloc64(azCol, nAlloc*sizeof(azCol[0]));
-      shell_check_oom(azCol);
-    }
-    azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
-    shell_check_oom(azCol[nCol]);
-    if( sqlite3_column_int(pStmt, 5) ){
-      nPK++;
-      if( nPK==1
-       && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
-                          "INTEGER")==0
-      ){
-        isIPK = 1;
-      }else{
-        isIPK = 0;
-      }
-    }
-  }
-  sqlite3_finalize(pStmt);
-  if( azCol==0 ) return 0;
-  azCol[0] = 0;
-  azCol[nCol+1] = 0;
-
-  /* The decision of whether or not a rowid really needs to be preserved
-  ** is tricky.  We never need to preserve a rowid for a WITHOUT ROWID table
-  ** or a table with an INTEGER PRIMARY KEY.  We are unable to preserve
-  ** rowids on tables where the rowid is inaccessible because there are other
-  ** columns in the table named "rowid", "_rowid_", and "oid".
-  */
-  if( preserveRowid && isIPK ){
-    /* If a single PRIMARY KEY column with type INTEGER was seen, then it
-    ** might be an alias for the ROWID.  But it might also be a WITHOUT ROWID
-    ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
-    ** ROWID aliases.  To distinguish these cases, check to see if
-    ** there is a "pk" entry in "PRAGMA index_list".  There will be
-    ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
-    */
-    zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
-                           " WHERE origin='pk'", zTab);
-    shell_check_oom(zSql);
-    rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-    sqlite3_free(zSql);
-    if( rc ){
-      freeColumnList(azCol);
-      return 0;
-    }
-    rc = sqlite3_step(pStmt);
-    sqlite3_finalize(pStmt);
-    preserveRowid = rc==SQLITE_ROW;
-  }
-  if( preserveRowid ){
-    /* Only preserve the rowid if we can find a name to use for the
-    ** rowid */
-    static char *azRowid[] = { "rowid", "_rowid_", "oid" };
-    int i, j;
-    for(j=0; j<3; j++){
-      for(i=1; i<=nCol; i++){
-        if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
-      }
-      if( i>nCol ){
-        /* At this point, we know that azRowid[j] is not the name of any
-        ** ordinary column in the table.  Verify that azRowid[j] is a valid
-        ** name for the rowid before adding it to azCol[0].  WITHOUT ROWID
-        ** tables will fail this last check */
-        rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
-        if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
-        break;
-      }
-    }
-  }
-  return azCol;
-}
-
-/*
-** Toggle the reverse_unordered_selects setting.
-*/
-static void toggleSelectOrder(sqlite3 *db){
-  sqlite3_stmt *pStmt = 0;
-  int iSetting = 0;
-  char zStmt[100];
-  sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
-  if( sqlite3_step(pStmt)==SQLITE_ROW ){
-    iSetting = sqlite3_column_int(pStmt, 0);
-  }
-  sqlite3_finalize(pStmt);
-  sqlite3_snprintf(sizeof(zStmt), zStmt,
-       "PRAGMA reverse_unordered_selects(%d)", !iSetting);
-  sqlite3_exec(db, zStmt, 0, 0, 0);
-}
-
-/* Forward reference */
-static int db_int(sqlite3 *db, const char *zSql, ...);
-
-/*
-** This is a different callback routine used for dumping the database.
-** Each row received by this callback consists of a table name,
-** the table type ("index" or "table") and SQL to create the table.
-** This routine should print text sufficient to recreate the table.
-*/
-static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){
-  int rc;
-  const char *zTable;
-  const char *zType;
-  const char *zSql;
-  ShellState *p = (ShellState *)pArg;
-  int dataOnly;
-  int noSys;
-
-  UNUSED_PARAMETER(azNotUsed);
-  if( nArg!=3 || azArg==0 ) return 0;
-  zTable = azArg[0];
-  zType = azArg[1];
-  zSql = azArg[2];
-  if( zTable==0 ) return 0;
-  if( zType==0 ) return 0;
-  dataOnly = (p->shellFlgs & SHFLG_DumpDataOnly)!=0;
-  noSys    = (p->shellFlgs & SHFLG_DumpNoSys)!=0;
-
-  if( cli_strcmp(zTable, "sqlite_sequence")==0 && !noSys ){
-    /* The sqlite_sequence table is repopulated last.  Delete content
-    ** in the sqlite_sequence table added by prior repopulations prior to
-    ** repopulating sqlite_sequence itself.  But only do this if the
-    ** table is non-empty, because if it is empty the table might not
-    ** have been recreated by prior repopulations. See forum posts:
-    ** 2024-10-13T17:10:01z and 2025-10-29T19:38:43z
-    */
-    if( db_int(p->db, "SELECT count(*) FROM sqlite_sequence")>0 ){
-      if( !p->writableSchema ){
-        cli_puts("PRAGMA writable_schema=ON;\n", p->out);
-        p->writableSchema = 1;
-      }
-      cli_puts("CREATE TABLE IF NOT EXISTS sqlite_sequence(name,seq);\n"
-                    "DELETE FROM sqlite_sequence;\n", p->out);
-    }
-  }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 && !noSys ){
-    if( !dataOnly ) cli_puts("ANALYZE sqlite_schema;\n", p->out);
-  }else if( cli_strncmp(zTable, "sqlite_", 7)==0 ){
-    return 0;
-  }else if( dataOnly ){
-    /* no-op */
-  }else if( cli_strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
-    char *zIns;
-    if( !p->writableSchema ){
-      cli_puts("PRAGMA writable_schema=ON;\n", p->out);
-      p->writableSchema = 1;
-    }
-    zIns = sqlite3_mprintf(
-       "INSERT INTO sqlite_schema(type,name,tbl_name,rootpage,sql)"
-       "VALUES('table','%q','%q',0,'%q');",
-       zTable, zTable, zSql);
-    shell_check_oom(zIns);
-    cli_printf(p->out, "%s\n", zIns);
-    sqlite3_free(zIns);
-    return 0;
-  }else{
-    printSchemaLine(p->out, zSql, ";\n");
-  }
-
-  if( cli_strcmp(zType, "table")==0 ){
-    ShellText sSelect;
-    ShellText sTable;
-    char **azCol;
-    int i;
-    Mode savedMode;
-
-    azCol = tableColumnList(p, zTable);
-    if( azCol==0 ){
-      p->nErr++;
-      return 0;
-    }
-
-    /* Always quote the table name, even if it appears to be pure ascii,
-    ** in case it is a keyword. Ex:  INSERT INTO "table" ... */
-    initText(&sTable);
-    appendText(&sTable, zTable, quoteChar(zTable));
-    /* If preserving the rowid, add a column list after the table name.
-    ** In other words:  "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
-    ** instead of the usual "INSERT INTO tab VALUES(...)".
-    */
-    if( azCol[0] ){
-      appendText(&sTable, "(", 0);
-      appendText(&sTable, azCol[0], 0);
-      for(i=1; azCol[i]; i++){
-        appendText(&sTable, ",", 0);
-        appendText(&sTable, azCol[i], quoteChar(azCol[i]));
-      }
-      appendText(&sTable, ")", 0);
-    }
-
-    /* Build an appropriate SELECT statement */
-    initText(&sSelect);
-    appendText(&sSelect, "SELECT ", 0);
-    if( azCol[0] ){
-      appendText(&sSelect, azCol[0], 0);
-      appendText(&sSelect, ",", 0);
-    }
-    for(i=1; azCol[i]; i++){
-      appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
-      if( azCol[i+1] ){
-        appendText(&sSelect, ",", 0);
-      }
-    }
-    freeColumnList(azCol);
-    appendText(&sSelect, " FROM ", 0);
-    appendText(&sSelect, zTable, quoteChar(zTable));
-
-
-    savedMode = p->mode;
-    p->mode.spec.zTableName = (char*)zTable;
-    p->mode.eMode = MODE_Insert;
-    p->mode.spec.eText = QRF_TEXT_Sql;
-    p->mode.spec.eBlob = QRF_BLOB_Sql;
-    p->mode.spec.bTitles = QRF_No;
-    p->mode.spec.nCharLimit = 0;
-    rc = shell_exec(p, sSelect.zTxt, 0);
-    if( (rc&0xff)==SQLITE_CORRUPT ){
-      cli_puts("/****** CORRUPTION ERROR *******/\n", p->out);
-      toggleSelectOrder(p->db);
-      shell_exec(p, sSelect.zTxt, 0);
-      toggleSelectOrder(p->db);
-    }
-    p->mode = savedMode;
-    freeText(&sTable);
-    freeText(&sSelect);
-    if( rc ) p->nErr++;
-  }
-  return 0;
-}
-
-/*
-** Run zQuery.  Use dump_callback() as the callback routine so that
-** the contents of the query are output as SQL statements.
-**
-** If we get a SQLITE_CORRUPT error, rerun the query after appending
-** "ORDER BY rowid DESC" to the end.
-*/
-static int run_schema_dump_query(
-  ShellState *p,
-  const char *zQuery
-){
-  int rc;
-  char *zErr = 0;
-  rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
-  if( rc==SQLITE_CORRUPT ){
-    char *zQ2;
-    int len = strlen30(zQuery);
-    cli_puts("/****** CORRUPTION ERROR *******/\n", p->out);
-    if( zErr ){
-      cli_printf(p->out, "/****** %s ******/\n", zErr);
-      sqlite3_free(zErr);
-      zErr = 0;
-    }
-    zQ2 = malloc( len+100 );
-    if( zQ2==0 ) return rc;
-    sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
-    rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
-    if( rc ){
-      cli_printf(p->out, "/****** ERROR: %s ******/\n", zErr);
-    }else{
-      rc = SQLITE_CORRUPT;
-    }
-    free(zQ2);
-  }
-  sqlite3_free(zErr);
-  return rc;
-}
-
-/*
-** Text of help messages.
-**
-** The help text for each individual command begins with a line that starts
-** with ".".  Subsequent lines are supplemental information.
-**
-** There must be two or more spaces between the end of the command and the
-** start of the description of what that command does.
-*/
-static const char *(azHelp[]) = {
-#if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE) \
-  && !defined(SQLITE_SHELL_FIDDLE)
-  ".archive ...             Manage SQL archives",
-  "   Each command must have exactly one of the following options:",
-  "     -c, --create               Create a new archive",
-  "     -u, --update               Add or update files with changed mtime",
-  "     -i, --insert               Like -u but always add even if unchanged",
-  "     -r, --remove               Remove files from archive",
-  "     -t, --list                 List contents of archive",
-  "     -x, --extract              Extract files from archive",
-  "   Optional arguments:",
-  "     -v, --verbose              Print each filename as it is processed",
-  "     -f FILE, --file FILE       Use archive FILE (default is current db)",
-  "     -a FILE, --append FILE     Open FILE using the apndvfs VFS",
-  "     -C DIR, --directory DIR    Read/extract files from directory DIR",
-  "     -g, --glob                 Use glob matching for names in archive",
-  "     -n, --dryrun               Show the SQL that would have occurred",
-  "   Examples:",
-  "     .ar -cf ARCHIVE foo bar  # Create ARCHIVE from files foo and bar",
-  "     .ar -tf ARCHIVE          # List members of ARCHIVE",
-  "     .ar -xvf ARCHIVE         # Verbosely extract files from ARCHIVE",
-  "   See also:",
-  "      http://sqlite.org/cli.html#sqlite_archive_support",
-#endif
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  ".auth ON|OFF             Show authorizer callbacks",
-#endif
-#ifndef SQLITE_SHELL_FIDDLE
-  ".backup ?DB? FILE        Backup DB (default \"main\") to FILE",
-  "   Options:",
-  "       --append            Use the appendvfs",
-  "       --async             Write to FILE without journal and fsync()",
-#endif
-  ".bail on|off             Stop after hitting an error.  Default OFF",
-#ifndef SQLITE_SHELL_FIDDLE
-  ".cd DIRECTORY            Change the working directory to DIRECTORY",
-#endif
-  ".changes on|off          Show number of rows changed by SQL",
-  ".check OPTIONS ...       Verify the results of a .testcase",
-#ifndef SQLITE_SHELL_FIDDLE
-  ".clone NEWDB             Clone data into NEWDB from the existing database",
-#endif
-  ".connection [close] [#]  Open or close an auxiliary database connection",
-  ".crlf ?on|off?           Whether or not to use \\r\\n line endings",
-  ".databases               List names and files of attached databases",
-  ".dbconfig ?op? ?val?     List or change sqlite3_db_config() options",
-#if SQLITE_SHELL_HAVE_RECOVER
-  ".dbinfo ?DB?             Show status information about the database",
-#endif
-  ".dbtotxt                 Hex dump of the database file",
-  ".dump ?OBJECTS?          Render database content as SQL",
-  "   Options:",
-  "     --data-only            Output only INSERT statements",
-  "     --newlines             Allow unescaped newline characters in output",
-  "     --nosys                Omit system tables (ex: \"sqlite_stat1\")",
-  "     --preserve-rowids      Include ROWID values in the output",
-  "   OBJECTS is a LIKE pattern for tables, indexes, triggers or views to dump",
-  "   Additional LIKE patterns can be given in subsequent arguments",
-  ".echo on|off             Turn command echo on or off",
-  ".eqp on|off|full|...     Enable or disable automatic EXPLAIN QUERY PLAN",
-  "   Other Modes:",
-#ifdef SQLITE_DEBUG
-  "      test                  Show raw EXPLAIN QUERY PLAN output",
-  "      trace                 Like \"full\" but enable \"PRAGMA vdbe_trace\"",
-#endif
-  "      trigger               Like \"full\" but also show trigger bytecode",
-#ifndef SQLITE_SHELL_FIDDLE
-  ".excel                   Display the output of next command in spreadsheet",
-  "   --bom                   Put a UTF8 byte-order mark on intermediate file",
-#endif
-#ifndef SQLITE_SHELL_FIDDLE
-  ".exit ?CODE?             Exit this program with return-code CODE",
-#endif
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_AUTHORIZATION)
-  ".expert                  EXPERIMENTAL. Suggest indexes for queries",
-#endif
-  ".explain ?on|off|auto?   Change the EXPLAIN formatting mode.  Default: auto",
-  ".filectrl CMD ...        Run various sqlite3_file_control() operations",
-  "   --schema SCHEMA         Use SCHEMA instead of \"main\"",
-  "   --help                  Show CMD details",
-  ".fullschema ?--indent?   Show schema and the content of sqlite_stat tables",
-  ".headers on|off          Turn display of headers on or off",
-  ".help ?-all? ?PATTERN?   Show help text for PATTERN",
-#ifndef SQLITE_SHELL_FIDDLE
-  ".import FILE TABLE       Import data from FILE into TABLE",
-#endif
-#ifndef SQLITE_OMIT_TEST_CONTROL
-  ".imposter INDEX TABLE    Create imposter table TABLE on index INDEX",
-#endif
-  ".indexes ?PATTERN?       Show names of indexes matching PATTERN",
-  "   -a|--all                Also show system-generated indexes",
-  "   --expr                  Show only expression indexes",
-  "   --sys                   Show only system-generated indexes",
-  ".intck ?STEPS_PER_UNLOCK?  Run an incremental integrity check on the db",
-#ifdef SQLITE_ENABLE_IOTRACE
-  ",iotrace FILE            Enable I/O diagnostic logging to FILE",
-#endif
-  ".limit ?LIMIT? ?VAL?     Display or change the value of an SQLITE_LIMIT",
-  ".lint OPTIONS            Report potential schema issues.",
-  "     Options:",
-  "        fkey-indexes     Find missing foreign key indexes",
-#if !defined(SQLITE_OMIT_LOAD_EXTENSION) && !defined(SQLITE_SHELL_FIDDLE)
-  ".load FILE ?ENTRY?       Load an extension library",
-#endif
-#if !defined(SQLITE_SHELL_FIDDLE)
-  ".log FILE|on|off         Turn logging on or off.  FILE can be stderr/stdout",
-#else
-  ".log on|off              Turn logging on or off.",
-#endif
-  ".mode ?MODE? ?OPTIONS?   Set output mode",
-#ifndef SQLITE_SHELL_FIDDLE
-  ".nonce STRING            Suspend safe mode for one command if nonce matches",
-#endif
-  ".nullvalue STRING        Use STRING in place of NULL values",
-#ifndef SQLITE_SHELL_FIDDLE
-  ".once ?OPTIONS? ?FILE?   Output for the next SQL command only to FILE",
-  /* Note that .open is (partially) available in WASM builds but is
-  ** currently only intended to be used by the fiddle tool, not
-  ** end users, so is "undocumented." */
-  ".open ?OPTIONS? ?FILE?   Close existing database and reopen FILE",
-  "     Options:",
-  "        --append        Use appendvfs to append database to the end of FILE",
-#endif
-#ifndef SQLITE_OMIT_DESERIALIZE
-  "        --deserialize   Load into memory using sqlite3_deserialize()",
-#endif
-/*"        --exclusive     Set the SQLITE_OPEN_EXCLUSIVE flag", UNDOCUMENTED */
-#ifndef SQLITE_OMIT_DESERIALIZE
-  "        --hexdb         Load the output of \"dbtotxt\" as an in-memory db",
-#endif
-  "        --ifexist       Only open if FILE already exists",
-#ifndef SQLITE_OMIT_DESERIALIZE
-  "        --maxsize N     Maximum size for --hexdb or --deserialized database",
-#endif
-  "        --new           Initialize FILE to an empty database",
-  "        --normal        FILE is an ordinary SQLite database",
-  "        --nofollow      Do not follow symbolic links",
-  "        --readonly      Open FILE readonly",
-  "        --zip           FILE is a ZIP archive",
-#ifndef SQLITE_SHELL_FIDDLE
-  ".output ?FILE?           Send output to FILE or stdout if FILE is omitted",
-#endif
-  ".parameter CMD ...       Manage SQL parameter bindings",
-  "   clear                   Erase all bindings",
-  "   init                    Initialize the TEMP table that holds bindings",
-  "   list                    List the current parameter bindings",
-  "   set PARAMETER VALUE     Given SQL parameter PARAMETER a value of VALUE",
-  "                           PARAMETER should start with one of: $ : @ ?",
-  "   unset PARAMETER         Remove PARAMETER from the binding table",
-  ".print STRING...         Print literal STRING",
-#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
-  ".progress N              Invoke progress handler after every N opcodes",
-  "   --limit N                 Interrupt after N progress callbacks",
-  "   --once                    Do no more than one progress interrupt",
-  "   --quiet|-q                No output except at interrupts",
-  "   --reset                   Reset the count for each input and interrupt",
-  "   --timeout S               Halt after running for S seconds",
-#endif
-  ".prompt MAIN CONTINUE    Replace the standard prompts",
-#ifndef SQLITE_SHELL_FIDDLE
-  ".quit                    Stop interpreting input stream, exit if primary.",
-  ".read FILE               Read input from FILE or command output",
-  "    If FILE begins with \"|\", it is a command that generates the input.",
-#endif
-#if SQLITE_SHELL_HAVE_RECOVER
-  ".recover                 Recover as much data as possible from corrupt db.",
-  "   --ignore-freelist        Ignore pages that appear to be on db freelist",
-  "   --lost-and-found TABLE   Alternative name for the lost-and-found table",
-  "   --no-rowids              Do not attempt to recover rowid values",
-  "                            that are not also INTEGER PRIMARY KEYs",
-#endif
-#ifndef SQLITE_SHELL_FIDDLE
-  ".restore ?DB? FILE       Restore content of DB (default \"main\") from FILE",
-  ".save ?OPTIONS? FILE     Write database to FILE (an alias for .backup ...)",
-#endif
-  ".scanstats on|off|est    Turn sqlite3_stmt_scanstatus() metrics on or off",
-  ".schema ?PATTERN?        Show the CREATE statements matching PATTERN",
-  "   Options:",
-  "      --indent             Try to pretty-print the schema",
-  "      --nosys              Omit objects whose names start with \"sqlite_\"",
-  ",selftest ?OPTIONS?      Run tests defined in the SELFTEST table",
-  "    Options:",
-  "       --init               Create a new SELFTEST table",
-  "       -v                   Verbose output",
-  ",separator COL ?ROW?     Change the column and row separators",
-#if defined(SQLITE_ENABLE_SESSION)
-  ".session ?NAME? CMD ...  Create or control sessions",
-  "   Subcommands:",
-  "     attach TABLE             Attach TABLE",
-  "     changeset FILE           Write a changeset into FILE",
-  "     close                    Close one session",
-  "     enable ?BOOLEAN?         Set or query the enable bit",
-  "     filter GLOB...           Reject tables matching GLOBs",
-  "     indirect ?BOOLEAN?       Mark or query the indirect status",
-  "     isempty                  Query whether the session is empty",
-  "     list                     List currently open session names",
-  "     open DB NAME             Open a new session on DB",
-  "     patchset FILE            Write a patchset into FILE",
-  "   If ?NAME? is omitted, the first defined session is used.",
-#endif
-  ".sha3sum ...             Compute a SHA3 hash of database content",
-  "    Options:",
-  "      --schema              Also hash the sqlite_schema table",
-  "      --sha3-224            Use the sha3-224 algorithm",
-  "      --sha3-256            Use the sha3-256 algorithm (default)",
-  "      --sha3-384            Use the sha3-384 algorithm",
-  "      --sha3-512            Use the sha3-512 algorithm",
-  "    Any other argument is a LIKE pattern for tables to hash",
-#if !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE)
-  ".shell CMD ARGS...       Run CMD ARGS... in a system shell",
-#endif
-  ",show                    Show the current values for various settings",
-  ".stats ?ARG?             Show stats or turn stats on or off",
-  "   off                      Turn off automatic stat display",
-  "   on                       Turn on automatic stat display",
-  "   stmt                     Show statement stats",
-  "   vmstep                   Show the virtual machine step count only",
-#if !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE)
-  ".system CMD ARGS...      Run CMD ARGS... in a system shell",
-#endif
-  ".tables ?TABLE?          List names of tables matching LIKE pattern TABLE",
-  ".testcase NAME           Begin a test case.",
-  ",testctrl CMD ...        Run various sqlite3_test_control() operations",
-  "                           Run \".testctrl\" with no arguments for details",
-  ".timeout MS              Try opening locked tables for MS milliseconds",
-  ".timer on|off|once       Turn SQL timer on or off.",
-#ifndef SQLITE_OMIT_TRACE
-  ".trace ?OPTIONS?         Output each SQL statement as it is run",
-  "    FILE                    Send output to FILE",
-  "    stdout                  Send output to stdout",
-  "    stderr                  Send output to stderr",
-  "    off                     Disable tracing",
-  "    --expanded              Expand query parameters",
-#ifdef SQLITE_ENABLE_NORMALIZE
-  "    --normalized            Normal the SQL statements",
-#endif
-  "    --plain                 Show SQL as it is input",
-  "    --stmt                  Trace statement execution (SQLITE_TRACE_STMT)",
-  "    --profile               Profile statements (SQLITE_TRACE_PROFILE)",
-  "    --row                   Trace each row (SQLITE_TRACE_ROW)",
-  "    --close                 Trace connection close (SQLITE_TRACE_CLOSE)",
-#endif /* SQLITE_OMIT_TRACE */
-#ifdef SQLITE_DEBUG
-  ".unmodule NAME ...       Unregister virtual table modules",
-  "    --allexcept             Unregister everything except those named",
-#endif
-  ".version                 Show source, library and compiler versions",
-  ".vfsinfo ?AUX?           Information about the top-level VFS",
-  ".vfslist                 List all available VFSes",
-  ".vfsname ?AUX?           Print the name of the VFS stack",
-  ",width NUM1 NUM2 ...     Set minimum column widths for columnar output",
-  "     Negative values right-justify",
-#ifndef SQLITE_SHELL_FIDDLE
-  ".www                     Display output of the next command in web browser",
-  "    --plain                 Show results as text/plain, not as HTML",
-#endif
-};
-
-/**************************************************************
-** "Usage" help text automatically generated from comments */
-static const struct {
-  const char *zCmd;   /* Name of the dot-command */
-  const char *zUsage; /* Documentation */
-} aUsage[] = {
-  { ".import",
-"USAGE: .import [OPTIONS] FILE TABLE\n"
-"\n"
-"Import CSV or similar text from FILE into TABLE.  If TABLE does\n"
-"not exist, it is created using the first row of FILE as the column\n"
-"names.  If FILE begins with \"|\" then it is a command that is run\n"
-"and the output from the command is used as the input data.  If\n"
-"FILE begins with \"<<\" followed by a label, then content is read from\n"
-"the script until the first line that matches the label.\n"
-"\n"
-"The content of FILE is interpreted using RFC-4180 (\"CSV\") quoting\n"
-"rules unless the current mode is \"ascii\" or \"tabs\" or unless one\n"
-"the --ascii option is used.\n"
-"\n"
-"The column and row separators must be single ASCII characters.  If\n"
-"multiple characters or a Unicode character are specified for the\n"
-"separators, then only the first byte of the separator is used.  Except,\n"
-"if the row separator is \\n and the mode is not --ascii, then \\r\\n is\n"
-"understood as a row separator too.\n"
-"\n"
-"Options:\n"
-"  --ascii         Do not use RFC-4180 quoting.  Use \\037 and \\036\n"
-"                  as column and row separators on input, unless other\n"
-"                  delimiters are specified using --colsep and/or --rowsep\n"
-"  --colsep CHAR   Use CHAR as the column separator.\n"
-"  --csv           Input is standard RFC-4180 CSV.\n"
-"  --esc CHAR      Use CHAR as an escape character in unquoted CSV inputs.\n"
-"  --qesc CHAR     Use CHAR as an escape character in quoted CSV inputs.\n"
-"  --rowsep CHAR   Use CHAR as the row separator.\n"
-"  --schema S      When creating TABLE, put it in schema S\n"
-"  --skip N        Ignore the first N rows of input\n"
-"  -v              Verbose mode\n"
-  },
-  { ".mode",
-"USAGE: .mode [MODE] [OPTIONS]\n"
-"\n"
-"Change the output mode to MODE and/or apply OPTIONS to the output mode.\n"
-"Arguments are processed from left to right.  If no arguments, show the\n"
-"current output mode and relevant options.\n"
-"\n"
-"Options:\n"
-"  --align STRING           Set the alignment of text in columnar modes\n"
-"                           String consists of characters 'L', 'C', 'R'\n"
-"                           meaning \"left\", \"centered\", and \"right\", with\n"
-"                           one letter per column starting from the left.\n"
-"                           Unspecified alignment defaults to 'L'.\n"
-"  --blob-quote ARG         ARG can be \"auto\", \"text\", \"sql\", \"hex\", \"tcl\",\n"
-"                           \"json\", or \"size\".  Default is \"auto\".\n"
-"  --border on|off          Show outer border on \"box\" and \"table\" modes.\n"
-"  --charlimit N            Set the maximum number of output characters to\n"
-"                           show for any single SQL value to N. Longer values\n"
-"                           truncated. Zero means \"no limit\".\n"
-"  --colsep STRING          Use STRING as the column separator\n"
-"  --escape ESC             Enable/disable escaping of control characters\n"
-"                           found in the output. ESC can be \"off\", \"ascii\",\n"
-"                           or \"symbol\".\n"
-"  --linelimit N            Set the maximum number of output lines to show for\n"
-"                           any single SQL value to N. Longer values are\n"
-"                           truncated. Zero means \"no limit\". Only works\n"
-"                           in \"line\" mode and in columnar modes.\n"
-"  --limits L,C,T           Shorthand for \"--linelimit L --charlimit C\n"
-"                           --titlelimit T\". The \",T\" can be omitted in which\n"
-"                           case the --titlelimit is unchanged.  The argument\n"
-"                           can also be \"off\" to mean \"0,0,0\" or \"on\" to\n"
-"                           mean \"5,300,20\".\n"
-"  --list                   List available modes\n"
-"  --multiinsert N          In \"insert\" mode, put multiple rows on a single\n"
-"                           INSERT statement until the size exceeds N bytes.\n"
-"  --null STRING            Render SQL NULL values as the given string\n"
-"  --once                   Setting changes to the right are reverted after\n"
-"                           the next SQL command.\n"
-"  --quote ARG              Enable/disable quoting of text. ARG can be\n"
-"                           \"off\", \"on\", \"sql\", \"relaxed\", \"csv\", \"html\",\n"
-"                           \"tcl\", or \"json\". \"off\" means show the text as-is.\n"
-"                           \"on\" is an alias for \"sql\".\n"
-"  --reset                  Changes all mode settings back to their default.\n"
-"  --rowsep STRING          Use STRING as the row separator\n"
-"  --sw|--screenwidth N     Declare the screen width of the output device\n"
-"                           to be N characters.  An attempt may be made to\n"
-"                           wrap output text to fit within this limit. Zero\n"
-"                           means \"no limit\".  Or N can be \"auto\" to set the\n"
-"                           width automatically.\n"
-"  --tablename NAME         Set the name of the table for \"insert\" mode.\n"
-"  --tag NAME               Save mode to the left as NAME.\n"
-"  --textjsonb BOOLEAN      If enabled, JSONB text is displayed as text JSON.\n"
-"  --title ARG              Whether or not to show column headers, and if so\n"
-"                           how to encode them.  ARG can be \"off\", \"on\",\n"
-"                           \"sql\", \"csv\", \"html\", \"tcl\", or \"json\".\n"
-"  --titlelimit N           Limit the length of column titles to N characters.\n"
-"  -v|--verbose             Verbose output\n"
-"  --widths LIST            Set the columns widths for columnar modes. The\n"
-"                           argument is a list of integers, one for each\n"
-"                           column. A \"0\" width means use a dynamic width\n"
-"                           based on the actual width of data. If there are\n"
-"                           fewer entries in LIST than columns, \"0\" is used\n"
-"                           for the unspecified widths.\n"
-"  --wordwrap BOOLEAN       Enable/disable word wrapping\n"
-"  --wrap N                 Wrap columns wider than N characters\n"
-"  --ww                     Shorthand for \"--wordwrap on\"\n"
-  },
-  { ".output",
-"USAGE: .output [OPTIONS] [FILE]\n"
-"\n"
-"Begin redirecting output to FILE.  Or if FILE is omitted, revert\n"
-"to sending output to the console.  If FILE begins with \"|\" then\n"
-"the remainder of file is taken as a pipe and output is directed\n"
-"into that pipe.  If FILE is \"memory\" then output is captured in an\n"
-"internal memory buffer.  If FILE is \"off\" then output is redirected\n"
-"into /dev/null or the equivalent.\n"
-"\n"
-"Options:\n"
-"  --bom             Prepend a byte-order mark to the output\n"
-"  -e                Accumulate output in a temporary text file then\n"
-"                    launch a text editor when the redirection ends.\n"
-"  --error-prefix X  Use X as the left-margin prefix for error messages.\n"
-"                    Set to an empty string to restore the default.\n"
-"  --keep            Keep redirecting output to its current destination.\n"
-"                    Use this option in combination with --show or\n"
-"                    with --error-prefix when you do not want to stop\n"
-"                    a current redirection.\n"
-"  --plain           Use plain text rather than HTML tables with -w\n"
-"  --show            Show output text captured by .testcase or by\n"
-"                    redirecting to \"memory\".\n"
-"  -w                Show the output in a web browser.  Output is\n"
-"                    written into a temporary HTML file until the\n"
-"                    redirect ends, then the web browser is launched.\n"
-"                    Query results  are shown as HTML tables, unless\n"
-"                    the --plain is used too.\n"
-"  -x                Show the output in a spreadsheet.  Output is\n"
-"                    written to a temp file as CSV then the spreadsheet\n"
-"                    is launched when\n"
-  },
-  { ".once",
-"USAGE: .once [OPTIONS] FILE ...\n"
-"\n"
-"Write the output for the next line of SQL or the next dot-command into\n"
-"FILE.  If FILE begins with \"|\" then it is a program into which output\n"
-"is written. The FILE argument should be omitted if one of the -e, -w,\n"
-"or -x options is used.\n"
-"\n"
-"Options:\n"
-"  -e                Capture output into a temporary file then bring up\n"
-"                    a text editor on that temporary file.\n"
-"  --plain           Use plain text rather than HTML tables with -w\n"
-"  -w                Capture output into an HTML file then bring up that\n"
-"                    file in a web browser\n"
-"  -x                Show the output in a spreadsheet.  Output is\n"
-"                    written to a temp file as CSV then the spreadsheet\n"
-"                    is launched when\n"
-  },
-  { ".check",
-"USAGE: .check [OPTIONS] PATTERN\n"
-"\n"
-"Verify results of commands since the most recent .testcase command.\n"
-"Restore output to the console, unless --keep is used.\n"
-"\n"
-"If PATTERN starts with \"<p);
-  sqlite3_free(pSession->zName);
-  for(i=0; inFilter; i++){
-    sqlite3_free(pSession->azFilter[i]);
-  }
-  sqlite3_free(pSession->azFilter);
-  memset(pSession, 0, sizeof(OpenSession));
-}
-#endif
-
-/*
-** Close all OpenSession objects and release all associated resources.
-*/
-#if defined(SQLITE_ENABLE_SESSION)
-static void session_close_all(ShellState *p, int i){
-  int j;
-  struct AuxDb *pAuxDb = i<0 ? p->pAuxDb : &p->aAuxDb[i];
-  for(j=0; jnSession; j++){
-    session_close(&pAuxDb->aSession[j]);
-  }
-  pAuxDb->nSession = 0;
-}
-#else
-# define session_close_all(X,Y)
-#endif
-
-/*
-** Implementation of the xFilter function for an open session.  Omit
-** any tables named by ".session filter" but let all other table through.
-*/
-#if defined(SQLITE_ENABLE_SESSION)
-static int session_filter(void *pCtx, const char *zTab){
-  OpenSession *pSession = (OpenSession*)pCtx;
-  int i;
-  for(i=0; inFilter; i++){
-    if( sqlite3_strglob(pSession->azFilter[i], zTab)==0 ) return 0;
-  }
-  return 1;
-}
-#endif
-
-/*
-** Return the size of the named file in bytes.  Or return a negative
-** number if the file does not exist.
-*/
-static sqlite3_int64 fileSize(const char *zFile){
-#if defined(_WIN32) || defined(WIN32)
-  struct _stat64 x;
-  if( _stat64(zFile, &x)!=0 ) return -1;
-  return (sqlite3_int64)x.st_size;
-#else
-  struct stat x;
-  if( stat(zFile, &x)!=0 ) return -1;
-  return (sqlite3_int64)x.st_size;
-#endif
-}
-
-/*
-** Return true if zFile is an SQLite database.
-**
-** Algorithm:
-**    * If the file does not exist -> return false
-**    * If the size of the file is not a multiple of 512 -> return false
-**    * If sqlite3_open() fails -> return false
-**    * if sqlite3_prepare() or sqlite3_step() fails -> return false
-**    * Otherwise -> return true
-*/
-static int isDatabaseFile(const char *zFile, int openFlags){
-  sqlite3 *db = 0;
-  sqlite3_stmt *pStmt = 0;
-  int rc;
-  sqlite3_int64 sz = fileSize(zFile);
-  if( sz<512 || (sz%512)!=0 ) return 0;
-  if( sqlite3_open_v2(zFile, &db, openFlags, 0)==SQLITE_OK
-   && sqlite3_prepare_v2(db,"SELECT count(*) FROM sqlite_schema",-1,&pStmt,0)
-           ==SQLITE_OK
-   && sqlite3_step(pStmt)==SQLITE_ROW
-  ){
-    rc = 1;
-  }else{
-    rc = 0;
-  }
-  sqlite3_finalize(pStmt);
-  sqlite3_close(db);
-  return rc;
-}
-
-/*
-** Try to deduce the type of file for zName based on its content.  Return
-** one of the SHELL_OPEN_* constants.
-**
-** If the file does not exist or is empty but its name looks like a ZIP
-** archive and the dfltZip flag is true, then assume it is a ZIP archive.
-** Otherwise, assume an ordinary database regardless of the filename if
-** the type cannot be determined from content.
-*/
-int deduceDatabaseType(const char *zName, int dfltZip, int openFlags){
-  FILE *f;
-  size_t n;
-  int rc = SHELL_OPEN_UNSPEC;
-  char zBuf[100];
-  if( access(zName,0)!=0 ) goto database_type_by_name;
-  if( isDatabaseFile(zName, openFlags) ){
-    rc = SHELL_OPEN_NORMAL;
-  }
-  if( rc==SHELL_OPEN_NORMAL ) return SHELL_OPEN_NORMAL;
-  f = sqlite3_fopen(zName, "rb");
-  if( f==0 ) goto database_type_by_name;
-  n = fread(zBuf, 16, 1, f);
-  if( n==1 && memcmp(zBuf, "SQLite format 3", 16)==0 ){
-    fclose(f);
-    return SHELL_OPEN_NORMAL;
-  }
-  fseek(f, -25, SEEK_END);
-  n = fread(zBuf, 25, 1, f);
-  if( n==1 && memcmp(zBuf, "Start-Of-SQLite3-", 17)==0 ){
-    rc = SHELL_OPEN_APPENDVFS;
-  }else{
-    fseek(f, -22, SEEK_END);
-    n = fread(zBuf, 22, 1, f);
-    if( n==1 && zBuf[0]==0x50 && zBuf[1]==0x4b && zBuf[2]==0x05
-       && zBuf[3]==0x06 ){
-      rc = SHELL_OPEN_ZIPFILE;
-    }else if( n==0 && dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
-      rc = SHELL_OPEN_ZIPFILE;
-    }
-  }
-  fclose(f);
-  return rc;
-
-database_type_by_name:
-  if( dfltZip && sqlite3_strlike("%.zip",zName,0)==0 ){
-    rc = SHELL_OPEN_ZIPFILE;
-  }else{
-    rc = SHELL_OPEN_NORMAL;
-  }
-  return rc;
-}
-
-/*
-** If the text in z[] is the name of a readable file and that file appears
-** to contain SQL text and/or dot-commands, then return true.  If z[] is
-** not a file, or if the file is unreadable, or if the file is a database
-** or anything else that is not SQL text and dot-commands, then return false.
-**
-** If the bLeaveUninit flag is set, then be sure to leave SQLite in an
-** uninitialized state.  This means invoking sqlite3_shutdown() after any
-** SQLite API is used.
-**
-** Some amount of guesswork is involved in this decision.
-*/
-static int isScriptFile(const char *z, int bLeaveUninit){
-  sqlite3_int64 sz = fileSize(z);
-  if( sz<=0 ) return 0;
-  if( (sz%512)==0 ){
-    int rc;
-    sqlite3_initialize();
-    rc = isDatabaseFile(z, SQLITE_OPEN_READONLY);
-    if( bLeaveUninit ){
-      sqlite3_shutdown();
-    }
-    if( rc ) return 0;  /* Is a database */
-  }
-  if( sqlite3_strlike("%.sql",z,0)==0 ) return 1;
-  if( sqlite3_strlike("%.txt",z,0)==0 ) return 1;
-  return 0;
-}
-
-#ifndef SQLITE_OMIT_DESERIALIZE
-/*
-** Reconstruct an in-memory database using the output from the "dbtotxt"
-** program.  Read content from the file in p->aAuxDb[].zDbFilename.
-** If p->aAuxDb[].zDbFilename is 0, then read from standard input.
-*/
-static unsigned char *readHexDb(ShellState *p, int *pnData){
-  unsigned char *a = 0;
-  i64 nLine;
-  int n = 0;                      /* Size of db per first line of hex dump */
-  i64 sz = 0;                     /* n rounded up to nearest page boundary */
-  int pgsz = 0;
-  i64 iOffset = 0;
-  int rc;
-  FILE *in;
-  const char *zDbFilename = p->pAuxDb->zDbFilename;
-  unsigned int x[16];
-  char zLine[1000];
-  if( zDbFilename ){
-    in = sqlite3_fopen(zDbFilename, "r");
-    if( in==0 ){
-      cli_printf(stderr,"cannot open \"%s\" for reading\n", zDbFilename);
-      return 0;
-    }
-    nLine = 0;
-  }else{
-    in = p->in;
-    nLine = p->lineno;
-    if( in==0 ) in = stdin;
-  }
-  *pnData = 0;
-  nLine++;
-  if( sqlite3_fgets(zLine, sizeof(zLine), in)==0 ) goto readHexDb_error;
-  rc = sscanf(zLine, "| size %d pagesize %d", &n, &pgsz);
-  if( rc!=2 ) goto readHexDb_error;
-  if( n<0 ) goto readHexDb_error;
-  if( pgsz<512 || pgsz>65536 || (pgsz & (pgsz-1))!=0 ){
-    cli_puts("invalid pagesize\n", stderr);
-    goto readHexDb_error;
-  }
-  sz = ((i64)n+pgsz-1)&~(pgsz-1); /* Round up to nearest multiple of pgsz */
-  a = sqlite3_malloc64( sz ? sz : 1 );
-  shell_check_oom(a);
-  memset(a, 0, sz);
-  for(nLine++; sqlite3_fgets(zLine, sizeof(zLine), in)!=0; nLine++){
-    int j = 0;                    /* Page number from "| page" line */
-    int k = 0;                    /* Offset from "| page" line */
-    if( nLine>=2000000000 ){
-      cli_printf(stderr, "input too big\n");
-      goto readHexDb_error;
-    }
-    rc = sscanf(zLine, "| page %d offset %d", &j, &k);
-    if( rc==2 ){
-      iOffset = k;
-      continue;
-    }
-    if( cli_strncmp(zLine, "| end ", 6)==0 ){
-      break;
-    }
-    rc = sscanf(zLine,"| %d: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
-                &j, &x[0], &x[1], &x[2], &x[3], &x[4], &x[5], &x[6], &x[7],
-                &x[8], &x[9], &x[10], &x[11], &x[12], &x[13], &x[14], &x[15]);
-    if( rc==17 ){
-      i64 iOff = iOffset+j;
-      if( iOff+16<=sz && iOff>=0 ){
-        int ii;
-        for(ii=0; ii<16; ii++) a[iOff+ii] = x[ii]&0xff;
-      }
-    }
-  }
-  *pnData = sz;
-  if( in!=p->in ){
-    fclose(in);
-  }else{
-    p->lineno = nLine;
-  }
-  return a;
-
-readHexDb_error:
-  if( in!=p->in ){
-    fclose(in);
-  }else{
-    while( sqlite3_fgets(zLine, sizeof(zLine), p->in)!=0 ){
-      nLine++;
-      if(cli_strncmp(zLine, "| end ", 6)==0 ) break;
-    }
-    p->lineno = nLine;
-  }
-  sqlite3_free(a);
-  cli_printf(stderr,"Error on line %lld of --hexdb input\n", nLine);
-  return 0;
-}
-#endif /* SQLITE_OMIT_DESERIALIZE */
-
-/*
-** Scalar function "usleep(X)" invokes sqlite3_sleep(X) and returns X.
-*/
-static void shellUSleepFunc(
-  sqlite3_context *context,
-  int argcUnused,
-  sqlite3_value **argv
-){
-  int sleep = sqlite3_value_int(argv[0]);
-  (void)argcUnused;
-  sqlite3_sleep(sleep/1000);
-  sqlite3_result_int(context, sleep);
-}
-
-/*
-** SQL function:  shell_module_schema(X)
-**
-** Return a fake schema for the table-valued function or eponymous virtual
-** table X.
-*/
-static void shellModuleSchema(
-  sqlite3_context *pCtx,
-  int nVal,
-  sqlite3_value **apVal
-){
-  const char *zName;
-  char *zFake;
-  ShellState *p = (ShellState*)sqlite3_user_data(pCtx);
-  FILE *pSavedLog = p->pLog;
-  UNUSED_PARAMETER(nVal);
-  zName = (const char*)sqlite3_value_text(apVal[0]);
-
-  /* Temporarily disable the ".log" when calling shellFakeSchema() because
-  ** shellFakeSchema() might generate failures for some ephemeral virtual
-  ** tables due to missing arguments.  Example: fts4aux.
-  ** https://sqlite.org/forum/forumpost/42fe6520b803be51 */
-  p->pLog = 0;
-  zFake = zName? shellFakeSchema(sqlite3_context_db_handle(pCtx), 0, zName) : 0;
-  p->pLog = pSavedLog;
-
-  if( zFake ){
-    sqlite3_result_text(pCtx, sqlite3_mprintf("/* %s */", zFake),
-                        -1, sqlite3_free);
-    sqlite3_free(zFake);
-  }
-}
-
-/* Flags for open_db().
-**
-** The default behavior of open_db() is to exit(1) if the database fails to
-** open.  The OPEN_DB_KEEPALIVE flag changes that so that it prints an error
-** but still returns without calling exit.
-**
-** The OPEN_DB_ZIPFILE flag causes open_db() to prefer to open files as a
-** ZIP archive if the file does not exist or is empty and its name matches
-** the *.zip pattern.
-*/
-#define OPEN_DB_KEEPALIVE   0x001   /* Return after error if true */
-#define OPEN_DB_ZIPFILE     0x002   /* Open as ZIP if name matches *.zip */
-
-/*
-** Make sure the database is open.  If it is not, then open it.  If
-** the database fails to open, print an error message and exit.
-*/
-static void open_db(ShellState *p, int openFlags){
-  if( p->db==0 ){
-    const char *zDbFilename = p->pAuxDb->zDbFilename;
-    if( p->openMode==SHELL_OPEN_UNSPEC ){
-      if( zDbFilename==0 || zDbFilename[0]==0 ){
-        p->openMode = SHELL_OPEN_NORMAL;
-      }else{
-        p->openMode = (u8)deduceDatabaseType(zDbFilename,
-                             (openFlags & OPEN_DB_ZIPFILE)!=0, p->openFlags);
-      }
-    }
-    if( (p->openFlags & (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE))==0 ){
-      if( p->openFlags==0 ) p->openFlags = SQLITE_OPEN_CREATE;
-      p->openFlags |= SQLITE_OPEN_READWRITE;
-    }
-    switch( p->openMode ){
-      case SHELL_OPEN_APPENDVFS: {
-        sqlite3_open_v2(zDbFilename, &p->db, p->openFlags, "apndvfs");
-        break;
-      }
-      case SHELL_OPEN_HEXDB:
-      case SHELL_OPEN_DESERIALIZE: {
-        sqlite3_open(0, &p->db);
-        break;
-      }
-      case SHELL_OPEN_ZIPFILE: {
-        sqlite3_open(":memory:", &p->db);
-        break;
-      }
-      case SHELL_OPEN_UNSPEC:
-      case SHELL_OPEN_NORMAL: {
-        sqlite3_open_v2(zDbFilename, &p->db, p->openFlags, 0);
-        break;
-      }
-    }
-    if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
-      cli_printf(stderr,"Error: unable to open database \"%s\": %s\n",
-            zDbFilename, sqlite3_errmsg(p->db));
-      if( (openFlags & OPEN_DB_KEEPALIVE)==0 ){
-        cli_exit(1);
-      }
-      sqlite3_close(p->db);
-      sqlite3_open(":memory:", &p->db);
-      if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
-        cli_puts("Also: unable to open substitute in-memory database.\n",
-                      stderr);
-        cli_exit(1);
-      }else{
-        cli_printf(stderr,
-              "Notice: using substitute in-memory database instead of \"%s\"\n",
-              zDbFilename);
-      }
-    }
-    globalDb = p->db;
-    sqlite3_db_config(p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, (int)0, (int*)0);
-
-    /* Reflect the use or absence of --unsafe-testing invocation. */
-    {
-      int testmode_on = ShellHasFlag(p,SHFLG_TestingMode);
-      sqlite3_db_config(p->db, SQLITE_DBCONFIG_TRUSTED_SCHEMA, testmode_on,0);
-      sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, !testmode_on,0);
-    }
-
-#ifndef SQLITE_OMIT_LOAD_EXTENSION
-    sqlite3_enable_load_extension(p->db, 1);
-#endif
-    sqlite3_sha_init(p->db, 0, 0);
-    sqlite3_shathree_init(p->db, 0, 0);
-    sqlite3_uint_init(p->db, 0, 0);
-    sqlite3_stmtrand_init(p->db, 0, 0);
-    sqlite3_decimal_init(p->db, 0, 0);
-    sqlite3_base64_init(p->db, 0, 0);
-    sqlite3_base85_init(p->db, 0, 0);
-    sqlite3_regexp_init(p->db, 0, 0);
-    sqlite3_ieee_init(p->db, 0, 0);
-    sqlite3_series_init(p->db, 0, 0);
-#ifndef SQLITE_SHELL_FIDDLE
-    sqlite3_fileio_init(p->db, 0, 0);
-    sqlite3_completion_init(p->db, 0, 0);
-#endif
-#ifdef SQLITE_HAVE_ZLIB
-    if( !p->bSafeModePersist ){
-      sqlite3_zipfile_init(p->db, 0, 0);
-      sqlite3_sqlar_init(p->db, 0, 0);
-    }
-#endif
-#ifdef SQLITE_SHELL_EXTFUNCS
-    /* Create a preprocessing mechanism for extensions to make
-     * their own provisions for being built into the shell.
-     * This is a short-span macro. See further below for usage.
-     */
-#define SHELL_SUB_MACRO(base, variant) base ## _ ## variant
-#define SHELL_SUBMACRO(base, variant) SHELL_SUB_MACRO(base, variant)
-    /* Let custom-included extensions get their ..._init() called.
-     * The WHATEVER_INIT( db, pzErrorMsg, pApi ) macro should cause
-     * the extension's sqlite3_*_init( db, pzErrorMsg, pApi )
-     * initialization routine to be called.
-     */
-    {
-      int irc = SHELL_SUBMACRO(SQLITE_SHELL_EXTFUNCS, INIT)(p->db);
-    /* Let custom-included extensions expose their functionality.
-     * The WHATEVER_EXPOSE( db, pzErrorMsg ) macro should cause
-     * the SQL functions, virtual tables, collating sequences or
-     * VFS's implemented by the extension to be registered.
-     */
-      if( irc==SQLITE_OK
-          || irc==SQLITE_OK_LOAD_PERMANENTLY ){
-        SHELL_SUBMACRO(SQLITE_SHELL_EXTFUNCS, EXPOSE)(p->db, 0);
-      }
-#undef SHELL_SUB_MACRO
-#undef SHELL_SUBMACRO
-    }
-#endif
-
-    sqlite3_create_function(p->db, "strtod", 1, SQLITE_UTF8, 0,
-                            shellStrtod, 0, 0);
-    sqlite3_create_function(p->db, "dtostr", 1, SQLITE_UTF8, 0,
-                            shellDtostr, 0, 0);
-    sqlite3_create_function(p->db, "dtostr", 2, SQLITE_UTF8, 0,
-                            shellDtostr, 0, 0);
-    sqlite3_create_function(p->db, "shell_add_schema", 3, SQLITE_UTF8, 0,
-                            shellAddSchemaName, 0, 0);
-    sqlite3_create_function(p->db, "shell_module_schema", 1, SQLITE_UTF8, p,
-                            shellModuleSchema, 0, 0);
-    sqlite3_create_function(p->db, "shell_putsnl", 1, SQLITE_UTF8, p,
-                            shellPutsFunc, 0, 0);
-    sqlite3_create_function(p->db, "shell_format_schema", 2, SQLITE_UTF8, p,
-                            shellFormatSchema, 0, 0);
-    sqlite3_create_function(p->db, "usleep",1,SQLITE_UTF8,0,
-                            shellUSleepFunc, 0, 0);
-#ifndef SQLITE_NOHAVE_SYSTEM
-    sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0,
-                            editFunc, 0, 0);
-    sqlite3_create_function(p->db, "edit", 2, SQLITE_UTF8, 0,
-                            editFunc, 0, 0);
-#endif
-
-    if( p->openMode==SHELL_OPEN_ZIPFILE ){
-      char *zSql = sqlite3_mprintf(
-         "CREATE VIRTUAL TABLE zip USING zipfile(%Q);", zDbFilename);
-      shell_check_oom(zSql);
-      sqlite3_exec(p->db, zSql, 0, 0, 0);
-      sqlite3_free(zSql);
-    }
-#ifndef SQLITE_OMIT_DESERIALIZE
-    else
-    if( p->openMode==SHELL_OPEN_DESERIALIZE || p->openMode==SHELL_OPEN_HEXDB ){
-      int rc;
-      int nData = 0;
-      unsigned char *aData;
-      if( p->openMode==SHELL_OPEN_DESERIALIZE ){
-        aData = (unsigned char*)readFile(zDbFilename, &nData);
-      }else{
-        aData = readHexDb(p, &nData);
-      }
-      if( aData==0 ){
-        return;
-      }
-      rc = sqlite3_deserialize(p->db, "main", aData, nData, nData,
-                   SQLITE_DESERIALIZE_RESIZEABLE |
-                   SQLITE_DESERIALIZE_FREEONCLOSE);
-      if( rc ){
-        cli_printf(stderr,"Error: sqlite3_deserialize() returns %d\n", rc);
-      }
-      if( p->szMax>0 ){
-        sqlite3_file_control(p->db, "main", SQLITE_FCNTL_SIZE_LIMIT, &p->szMax);
-      }
-    }
-#endif
-  }
-  if( p->db!=0 ){
-#ifndef SQLITE_OMIT_AUTHORIZATION
-    if( p->bSafeModePersist ){
-      sqlite3_set_authorizer(p->db, safeModeAuth, p);
-    }
-#endif
-    sqlite3_db_config(
-        p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, p->mode.scanstatsOn, (int*)0
-    );
-  }
-}
-
-/*
-** Attempt to close the database connection.  Report errors.
-*/
-void close_db(sqlite3 *db){
-  int rc = sqlite3_close(db);
-  if( rc ){
-    cli_printf(stderr,
-        "Error: sqlite3_close() returns %d: %s\n", rc, sqlite3_errmsg(db));
-  }
-}
-
-#if (HAVE_READLINE || HAVE_EDITLINE) \
-  && !defined(SQLITE_OMIT_READLINE_COMPLETION)
-/*
-** Readline completion callbacks
-*/
-static char *readline_completion_generator(const char *text, int state){
-  static sqlite3_stmt *pStmt = 0;
-  char *zRet;
-  if( state==0 ){
-    char *zSql;
-    sqlite3_finalize(pStmt);
-    zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
-                           "  FROM completion(%Q) ORDER BY 1", text);
-    shell_check_oom(zSql);
-    sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
-    sqlite3_free(zSql);
-  }
-  if( sqlite3_step(pStmt)==SQLITE_ROW ){
-    const char *z = (const char*)sqlite3_column_text(pStmt,0);
-    zRet = z ? strdup(z) : 0;
-  }else{
-    sqlite3_finalize(pStmt);
-    pStmt = 0;
-    zRet = 0;
-  }
-  return zRet;
-}
-static char **readline_completion(const char *zText, int iStart, int iEnd){
-  (void)iStart;
-  (void)iEnd;
-  rl_attempted_completion_over = 1;
-  return rl_completion_matches(zText, readline_completion_generator);
-}
-
-#elif HAVE_LINENOISE
-/*
-** Linenoise completion callback. Note that the 3rd argument is from
-** the "msteveb" version of linenoise, not the "antirez" version.
-*/
-static void linenoise_completion(
-  const char *zLine,
-  linenoiseCompletions *lc
-#if HAVE_LINENOISE==2
-  ,void *pUserData
-#endif
-){
-  i64 nLine = strlen(zLine);
-  i64 i, iStart;
-  sqlite3_stmt *pStmt = 0;
-  char *zSql;
-  char zBuf[1000];
-
-#if HAVE_LINENOISE==2
-  UNUSED_PARAMETER(pUserData);
-#endif
-  if( nLine>(i64)sizeof(zBuf)-30 ) return;
-  if( zLine[0]=='.' || zLine[0]=='#') return;
-  for(i=nLine-1; i>=0 && (IsAlnum(zLine[i]) || zLine[i]=='_'); i--){}
-  if( i==nLine-1 ) return;
-  iStart = i+1;
-  memcpy(zBuf, zLine, iStart);
-  zSql = sqlite3_mprintf("SELECT DISTINCT candidate COLLATE nocase"
-                         "  FROM completion(%Q,%Q) ORDER BY 1",
-                         &zLine[iStart], zLine);
-  shell_check_oom(zSql);
-  sqlite3_prepare_v2(globalDb, zSql, -1, &pStmt, 0);
-  sqlite3_free(zSql);
-  sqlite3_exec(globalDb, "PRAGMA page_count", 0, 0, 0); /* Load the schema */
-  while( sqlite3_step(pStmt)==SQLITE_ROW ){
-    const char *zCompletion = (const char*)sqlite3_column_text(pStmt, 0);
-    int nCompletion = sqlite3_column_bytes(pStmt, 0);
-    if( iStart+nCompletion < (i64)sizeof(zBuf)-1 && zCompletion ){
-      memcpy(zBuf+iStart, zCompletion, nCompletion+1);
-      linenoiseAddCompletion(lc, zBuf);
-    }
-  }
-  sqlite3_finalize(pStmt);
-}
-#endif
-
-/*
-** Do C-language style dequoting.
-**
-**    \a    -> alarm
-**    \b    -> backspace
-**    \t    -> tab
-**    \n    -> newline
-**    \v    -> vertical tab
-**    \f    -> form feed
-**    \r    -> carriage return
-**    \s    -> space
-**    \"    -> "
-**    \'    -> '
-**    \\    -> backslash
-**    \NNN  -> ascii character NNN in octal
-**    \xHH  -> ascii character HH in hexadecimal
-*/
-static void resolve_backslashes(char *z){
-  int i, j;
-  char c;
-  while( *z && *z!='\\' ) z++;
-  for(i=j=0; (c = z[i])!=0; i++, j++){
-    if( c=='\\' && z[i+1]!=0 ){
-      c = z[++i];
-      if( c=='a' ){
-        c = '\a';
-      }else if( c=='b' ){
-        c = '\b';
-      }else if( c=='t' ){
-        c = '\t';
-      }else if( c=='n' ){
-        c = '\n';
-      }else if( c=='v' ){
-        c = '\v';
-      }else if( c=='f' ){
-        c = '\f';
-      }else if( c=='r' ){
-        c = '\r';
-      }else if( c=='"' ){
-        c = '"';
-      }else if( c=='\'' ){
-        c = '\'';
-      }else if( c=='\\' ){
-        c = '\\';
-      }else if( c=='x' ){
-        int nhd = 0, hdv;
-        u8 hv = 0;
-        while( nhd<2 && (c=z[i+1+nhd])!=0 && (hdv=hexDigitValue(c))>=0 ){
-          hv = (u8)((hv<<4)|hdv);
-          ++nhd;
-        }
-        i += nhd;
-        c = (u8)hv;
-      }else if( c>='0' && c<='7' ){
-        c -= '0';
-        if( z[i+1]>='0' && z[i+1]<='7' ){
-          i++;
-          c = (c<<3) + z[i] - '0';
-          if( z[i+1]>='0' && z[i+1]<='7' ){
-            i++;
-            c = (c<<3) + z[i] - '0';
-          }
-        }
-      }
-    }
-    z[j] = c;
-  }
-  if( j=0; i++){}
-  }else{
-    for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
-  }
-  if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
-  if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
-    return 1;
-  }
-  if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
-    return 0;
-  }
-  cli_printf(stderr,
-       "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", zArg);
-  return 0;
-}
-
-/*
-** Set or clear a shell flag according to a boolean value.
-*/
-static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
-  if( booleanValue(zArg) ){
-    ShellSetFlag(p, mFlag);
-  }else{
-    ShellClearFlag(p, mFlag);
-  }
-}
-
-/*
-** Close an output file, assuming it is not stderr or stdout
-*/
-static void output_file_close(FILE *f){
-  if( f && f!=stdout && f!=stderr ) fclose(f);
-}
-
-/*
-** Try to open an output file.   The names "stdout" and "stderr" are
-** recognized and do the right thing.  NULL is returned if the output
-** filename is "off".
-*/
-static FILE *output_file_open(ShellState *p, const char *zFile){
-  FILE *f;
-  if( cli_strcmp(zFile,"stdout")==0 ){
-    f = stdout;
-  }else if( cli_strcmp(zFile, "stderr")==0 ){
-    f = stderr;
-  }else if( cli_strcmp(zFile, "off")==0 || p->bSafeMode ){
-    f = 0;
-  }else{
-    f = sqlite3_fopen(zFile, "w");
-    if( f==0 ){
-      cli_printf(stderr,"Error: cannot open \"%s\"\n", zFile);
-    }
-  }
-  return f;
-}
-
-#ifndef SQLITE_OMIT_TRACE
-/*
-** A routine for handling output from sqlite3_trace().
-*/
-static int sql_trace_callback(
-  unsigned mType,         /* The trace type */
-  void *pArg,             /* The ShellState pointer */
-  void *pP,               /* Usually a pointer to sqlite_stmt */
-  void *pX                /* Auxiliary output */
-){
-  ShellState *p = (ShellState*)pArg;
-  sqlite3_stmt *pStmt;
-  const char *zSql;
-  i64 nSql;
-  if( p->traceOut==0 ) return 0;
-  if( mType==SQLITE_TRACE_CLOSE ){
-    sputz(p->traceOut, "-- closing database connection\n");
-    return 0;
-  }
-  if( mType!=SQLITE_TRACE_ROW && pX!=0 && ((const char*)pX)[0]=='-' ){
-    zSql = (const char*)pX;
-  }else{
-    pStmt = (sqlite3_stmt*)pP;
-    switch( p->eTraceType ){
-      case SHELL_TRACE_EXPANDED: {
-        zSql = sqlite3_expanded_sql(pStmt);
-        break;
-      }
-#ifdef SQLITE_ENABLE_NORMALIZE
-      case SHELL_TRACE_NORMALIZED: {
-        zSql = sqlite3_normalized_sql(pStmt);
-        break;
-      }
-#endif
-      default: {
-        zSql = sqlite3_sql(pStmt);
-        break;
-      }
-    }
-  }
-  if( zSql==0 ) return 0;
-  nSql = strlen(zSql);
-  if( nSql>1000000000 ) nSql = 1000000000;
-  while( nSql>0 && zSql[nSql-1]==';' ){ nSql--; }
-  switch( mType ){
-    case SQLITE_TRACE_ROW:
-    case SQLITE_TRACE_STMT: {
-      cli_printf(p->traceOut, "%.*s;\n", (int)nSql, zSql);
-      break;
-    }
-    case SQLITE_TRACE_PROFILE: {
-      sqlite3_int64 nNanosec = pX ? *(sqlite3_int64*)pX : 0;
-      cli_printf(p->traceOut,
-                      "%.*s; -- %lld ns\n", (int)nSql, zSql, nNanosec);
-      break;
-    }
-  }
-  return 0;
-}
-#endif
-
-/*
-** A no-op routine that runs with the ".breakpoint" doc-command.  This is
-** a useful spot to set a debugger breakpoint.
-**
-** This routine does not do anything practical.  The code are there simply
-** to prevent the compiler from optimizing this routine out.
-*/
-static void test_breakpoint(void){
-  static unsigned int nCall = 0;
-  if( (nCall++)==0xffffffff ) printf("Many .breakpoints have run\n");
-}
-
-/*
-** An object used to read a CSV and other files for import.
-*/
-typedef struct ImportCtx ImportCtx;
-struct ImportCtx {
-  const char *zFile;  /* Name of the input file */
-  FILE *in;           /* Read the CSV text from this input stream */
-  int (SQLITE_CDECL *xCloser)(FILE*);      /* Func to close in */
-  char *zIn;          /* Input text */
-  char *z;            /* Accumulated text for a field */
-  i64 nUsed;          /* Bytes of zIn[] used so far */
-  i64 n;              /* Number of bytes in z */
-  i64 nAlloc;         /* Space allocated for z[] */
-  int nLine;          /* Current line number */
-  int nRow;           /* Number of rows imported */
-  int nErr;           /* Number of errors encountered */
-  int bNotFirst;      /* True if one or more bytes already read */
-  int cTerm;          /* Character that terminated the most recent field */
-  int cColSep;        /* The column separator character.  (Usually ",") */
-  int cRowSep;        /* The row separator character.  (Usually "\n") */
-  int cQEscape;       /* Escape character with "...".  0 for none */
-  int cUQEscape;      /* Escape character not with "...".  0 for none */
-};
-
-/* Clean up resourced used by an ImportCtx */
-static void import_cleanup(ImportCtx *p){
-  if( p->in!=0 && p->xCloser!=0 ){
-    p->xCloser(p->in);
-    p->in = 0;
-  }
-  sqlite3_free(p->z);
-  p->z = 0;
-  if( p->zIn ){
-    sqlite3_free(p->zIn);
-    p->zIn = 0;
-  }
-}
-
-/* Read a single character of the .import input text.  Return EOF
-** at end-of-file.
-*/
-static int import_getc(ImportCtx *p){
-  if( p->in ){
-    return fgetc(p->in);
-  }else if( p->zIn && p->zIn[p->nUsed]!=0 ){
-    return p->zIn[p->nUsed++];
-  }else{
-    return EOF;
-  }
-}
-
-/* Append a single byte to the field value begin constructed
-** in the p->z[] buffer
-*/
-static void import_append_char(ImportCtx *p, int c){
-  if( p->n+1>=p->nAlloc ){
-    p->nAlloc += p->nAlloc + 100;
-    p->z = sqlite3_realloc64(p->z, p->nAlloc);
-    shell_check_oom(p->z);
-  }
-  p->z[p->n++] = (char)c;
-}
-
-/* Read a single field of CSV text.  Compatible with rfc4180 and extended
-** with the option of having a separator other than ",".
-**
-**   +  Input comes from p->in.
-**   +  Store results in p->z of length p->n.  Space to hold p->z comes
-**      from sqlite3_malloc64().
-**   +  Use p->cColSep as the column separator.  The default is ",".
-**   +  Use p->cRowSep as the row separator.  The default is "\n".
-**   +  Keep track of the line number in p->nLine.
-**   +  Store the character that terminates the field in p->cTerm.  Store
-**      EOF on end-of-file.
-**   +  Report syntax errors on stderr
-*/
-static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
-  int c;
-  int cSep = (u8)p->cColSep;
-  int rSep = (u8)p->cRowSep;
-  p->n = 0;
-  c = import_getc(p);
-  if( c==EOF || seenInterrupt ){
-    p->cTerm = EOF;
-    return 0;
-  }
-  if( c=='"' ){
-    int pc, ppc;
-    int startLine = p->nLine;
-    int cQuote = c;
-    int cEsc = (u8)p->cQEscape;
-    pc = ppc = 0;
-    while( 1 ){
-      c = import_getc(p);
-      if( c==rSep ) p->nLine++;
-      if( c==cEsc && cEsc!=0 ){
-        c = import_getc(p);
-        import_append_char(p, c);
-        ppc = pc = 0;
-        continue;
-      }
-      if( c==cQuote ){
-        if( pc==cQuote ){
-          pc = 0;
-          continue;
-        }
-      }
-      if( (c==cSep && pc==cQuote)
-       || (c==rSep && pc==cQuote)
-       || (c==rSep && pc=='\r' && ppc==cQuote)
-       || (c==EOF && pc==cQuote)
-      ){
-        do{ p->n--; }while( p->z[p->n]!=cQuote );
-        p->cTerm = c;
-        break;
-      }
-      if( pc==cQuote && c!='\r' ){
-        cli_printf(stderr,"%s:%d: unescaped %c character\n", 
-                   p->zFile, p->nLine, cQuote);
-      }
-      if( c==EOF ){
-        cli_printf(stderr,"%s:%d: unterminated %c-quoted field\n",
-              p->zFile, startLine, cQuote);
-        p->cTerm = c;
-        break;
-      }
-      import_append_char(p, c);
-      ppc = pc;
-      pc = c;
-    }
-  }else{
-    /* If this is the first field being parsed and it begins with the
-    ** UTF-8 BOM  (0xEF BB BF) then skip the BOM */
-    int cEsc = p->cUQEscape;
-    if( (c&0xff)==0xef && p->bNotFirst==0 ){
-      import_append_char(p, c);
-      c = import_getc(p);
-      if( (c&0xff)==0xbb ){
-        import_append_char(p, c);
-        c = import_getc(p);
-        if( (c&0xff)==0xbf ){
-          p->bNotFirst = 1;
-          p->n = 0;
-          return csv_read_one_field(p);
-        }
-      }
-    }
-    while( c!=EOF && c!=cSep && c!=rSep ){
-      if( c==cEsc && cEsc!=0 ) c = import_getc(p);
-      import_append_char(p, c);
-      c = import_getc(p);
-    }
-    if( c==rSep ){
-      p->nLine++;
-      if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
-    }
-    p->cTerm = c;
-  }
-  if( p->z ) p->z[p->n] = 0;
-  p->bNotFirst = 1;
-  return p->z;
-}
-
-/* Read a single field of ASCII delimited text.
-**
-**   +  Input comes from p->in.
-**   +  Store results in p->z of length p->n.  Space to hold p->z comes
-**      from sqlite3_malloc64().
-**   +  Use p->cColSep as the column separator.  The default is "\x1F".
-**   +  Use p->cRowSep as the row separator.  The default is "\x1E".
-**   +  Keep track of the row number in p->nLine.
-**   +  Store the character that terminates the field in p->cTerm.  Store
-**      EOF on end-of-file.
-**   +  Report syntax errors on stderr
-*/
-static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
-  int c;
-  int cSep = (u8)p->cColSep;
-  int rSep = (u8)p->cRowSep;
-  p->n = 0;
-  c = import_getc(p);
-  if( c==EOF || seenInterrupt ){
-    p->cTerm = EOF;
-    return 0;
-  }
-  while( c!=EOF && c!=cSep && c!=rSep ){
-    import_append_char(p, c);
-    c = import_getc(p);
-  }
-  if( c==rSep ){
-    p->nLine++;
-  }
-  p->cTerm = c;
-  if( p->z ) p->z[p->n] = 0;
-  return p->z;
-}
-
-/*
-** Try to transfer data for table zTable.  If an error is seen while
-** moving forward, try to go backwards.  The backwards movement won't
-** work for WITHOUT ROWID tables.
-*/
-static void tryToCloneData(
-  ShellState *p,
-  sqlite3 *newDb,
-  const char *zTable
-){
-  sqlite3_stmt *pQuery = 0;
-  sqlite3_stmt *pInsert = 0;
-  char *zQuery = 0;
-  char *zInsert = 0;
-  int rc;
-  int i, j, n;
-  int nTable = strlen30(zTable);
-  int k = 0;
-  int cnt = 0;
-  const int spinRate = 10000;
-
-  zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
-  shell_check_oom(zQuery);
-  rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
-  if( rc ){
-    cli_printf(stderr,"Error %d: %s on [%s]\n",
-          sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zQuery);
-    goto end_data_xfer;
-  }
-  n = sqlite3_column_count(pQuery);
-  zInsert = sqlite3_malloc64(200 + nTable + n*3);
-  shell_check_oom(zInsert);
-  sqlite3_snprintf(200+nTable,zInsert,
-                   "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
-  i = strlen30(zInsert);
-  for(j=1; jdb, zQuery, -1, &pQuery, 0);
-    if( rc ){
-      cli_printf(stderr,"Warning: cannot step \"%s\" backwards", zTable);
-      break;
-    }
-  } /* End for(k=0...) */
-
-end_data_xfer:
-  sqlite3_finalize(pQuery);
-  sqlite3_finalize(pInsert);
-  sqlite3_free(zQuery);
-  sqlite3_free(zInsert);
-}
-
-
-/*
-** Try to transfer all rows of the schema that match zWhere.  For
-** each row, invoke xForEach() on the object defined by that row.
-** If an error is encountered while moving forward through the
-** sqlite_schema table, try again moving backwards.
-*/
-static void tryToCloneSchema(
-  ShellState *p,
-  sqlite3 *newDb,
-  const char *zWhere,
-  void (*xForEach)(ShellState*,sqlite3*,const char*)
-){
-  sqlite3_stmt *pQuery = 0;
-  char *zQuery = 0;
-  int rc;
-  const unsigned char *zName;
-  const unsigned char *zSql;
-  char *zErrMsg = 0;
-
-  zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
-                           " WHERE %s ORDER BY rowid ASC", zWhere);
-  shell_check_oom(zQuery);
-  rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
-  if( rc ){
-    cli_printf(stderr,
-          "Error: (%d) %s on [%s]\n", sqlite3_extended_errcode(p->db),
-          sqlite3_errmsg(p->db), zQuery);
-    goto end_schema_xfer;
-  }
-  while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
-    zName = sqlite3_column_text(pQuery, 0);
-    zSql = sqlite3_column_text(pQuery, 1);
-    if( zName==0 || zSql==0 ) continue;
-    if( sqlite3_stricmp((char*)zName, "sqlite_sequence")!=0 ){
-      cli_printf(stdout, "%s... ", zName); fflush(stdout);
-      sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
-      if( zErrMsg ){
-        cli_printf(stderr,"Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
-        sqlite3_free(zErrMsg);
-        zErrMsg = 0;
-      }
-    }
-    if( xForEach ){
-      xForEach(p, newDb, (const char*)zName);
-    }
-    sputz(stdout, "done\n");
-  }
-  if( rc!=SQLITE_DONE ){
-    sqlite3_finalize(pQuery);
-    sqlite3_free(zQuery);
-    zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_schema"
-                             " WHERE %s ORDER BY rowid DESC", zWhere);
-    shell_check_oom(zQuery);
-    rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
-    if( rc ){
-      cli_printf(stderr,"Error: (%d) %s on [%s]\n",
-            sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), zQuery);
-      goto end_schema_xfer;
-    }
-    while( sqlite3_step(pQuery)==SQLITE_ROW ){
-      zName = sqlite3_column_text(pQuery, 0);
-      zSql = sqlite3_column_text(pQuery, 1);
-      if( zName==0 || zSql==0 ) continue;
-      if( sqlite3_stricmp((char*)zName, "sqlite_sequence")==0 ) continue;
-      cli_printf(stdout, "%s... ", zName); fflush(stdout);
-      sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
-      if( zErrMsg ){
-        cli_printf(stderr,"Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
-        sqlite3_free(zErrMsg);
-        zErrMsg = 0;
-      }
-      if( xForEach ){
-        xForEach(p, newDb, (const char*)zName);
-      }
-      sputz(stdout, "done\n");
-    }
-  }
-end_schema_xfer:
-  sqlite3_finalize(pQuery);
-  sqlite3_free(zQuery);
-}
-
-/*
-** Open a new database file named "zNewDb".  Try to recover as much information
-** as possible out of the main database (which might be corrupt) and write it
-** into zNewDb.
-*/
-static void tryToClone(ShellState *p, const char *zNewDb){
-  int rc;
-  sqlite3 *newDb = 0;
-  if( access(zNewDb,0)==0 ){
-    cli_printf(stderr,"File \"%s\" already exists.\n", zNewDb);
-    return;
-  }
-  rc = sqlite3_open(zNewDb, &newDb);
-  if( rc ){
-    cli_printf(stderr,
-        "Cannot create output database: %s\n", sqlite3_errmsg(newDb));
-  }else{
-    sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
-    sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
-    tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
-    tryToCloneSchema(p, newDb, "type!='table'", 0);
-    sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
-    sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
-  }
-  close_db(newDb);
-}
-
-#ifndef SQLITE_SHELL_FIDDLE
-/*
-** Change the output stream (file or pipe or console) to something else.
-*/
-static void output_redir(ShellState *p, FILE *pfNew){
-  if( p->out != stdout ){
-    cli_puts("Output already redirected.\n", stderr);
-  }else{
-    p->out = pfNew;
-    setCrlfMode(p);
-    if( p->mode.eMode==MODE_Www ){
-      cli_puts(
-        "\n"
-        "
\n",
-        p->out
-      );
-    }
-  }
-}
-
-/*
-** Change the output file back to stdout.
-**
-** If the p->doXdgOpen flag is set, that means the output was being
-** redirected to a temporary file named by p->zTempFile.  In that case,
-** launch start/open/xdg-open on that temporary file.
-*/
-static void output_reset(ShellState *p){
-  if( p->outfile[0]=='|' ){
-#ifndef SQLITE_OMIT_POPEN
-    pclose(p->out);
-#endif
-  }else{
-    if( p->mode.eMode==MODE_Www ){
-      cli_puts("
\n", p->out);
-    }
-    output_file_close(p->out);
-#ifndef SQLITE_NOHAVE_SYSTEM
-    if( p->doXdgOpen ){
-      const char *zXdgOpenCmd =
-#if defined(_WIN32)
-      "start";
-#elif defined(__APPLE__)
-      "open";
-#else
-      "xdg-open";
-#endif
-      char *zCmd;
-      zCmd = sqlite3_mprintf("%s %s", zXdgOpenCmd, p->zTempFile);
-      if( system(zCmd) ){
-        cli_printf(stderr,"Failed: [%s]\n", zCmd);
-      }else{
-        /* Give the start/open/xdg-open command some time to get
-        ** going before we continue, and potential delete the
-        ** p->zTempFile data file out from under it */
-        sqlite3_sleep(2000);
-      }
-      sqlite3_free(zCmd);
-      modePop(p);
-      p->doXdgOpen = 0;
-    }
-#endif /* !defined(SQLITE_NOHAVE_SYSTEM) */
-  }
-  p->outfile[0] = 0;
-  p->out = stdout;
-  setCrlfMode(p);
-  if( cli_output_capture ){
-    sqlite3_str_free(cli_output_capture);
-    cli_output_capture = 0;
-  }
-}
-#else
-# define output_redir(SS,pfO)
-# define output_reset(SS)
-#endif
-
-/*
-** Run an SQL command and return the single integer result.
-*/
-static int db_int(sqlite3 *db, const char *zSql, ...){
-  sqlite3_stmt *pStmt;
-  int res = 0;
-  char *z;
-  va_list ap;
-  va_start(ap, zSql);
-  z = sqlite3_vmprintf(zSql, ap);
-  va_end(ap);
-  sqlite3_prepare_v2(db, z, -1, &pStmt, 0);
-  if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
-    res = sqlite3_column_int(pStmt,0);
-  }
-  sqlite3_finalize(pStmt);
-  sqlite3_free(z);
-  return res;
-}
-
-#if SQLITE_SHELL_HAVE_RECOVER
-/*
-** Convert a 2-byte or 4-byte big-endian integer into a native integer
-*/
-static unsigned int get2byteInt(unsigned char *a){
-  return ((unsigned int)a[0]<<8) + (unsigned int)a[1];
-}
-static unsigned int get4byteInt(unsigned char *a){
-  return ((unsigned int)a[0]<<24)
-       + ((unsigned int)a[1]<<16)
-       + ((unsigned int)a[2]<<8)
-       + (unsigned int)a[3];
-}
-
-/*
-** Implementation of the ".dbinfo" command.
-**
-** Return 1 on error, 2 to exit, and 0 otherwise.
-*/
-static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
-  static const struct { const char *zName; int ofst; } aField[] = {
-     { "file change counter:",  24  },
-     { "database page count:",  28  },
-     { "freelist page count:",  36  },
-     { "schema cookie:",        40  },
-     { "schema format:",        44  },
-     { "default cache size:",   48  },
-     { "autovacuum top root:",  52  },
-     { "incremental vacuum:",   64  },
-     { "text encoding:",        56  },
-     { "user version:",         60  },
-     { "application id:",       68  },
-     { "software version:",     96  },
-  };
-  static const struct { const char *zName; const char *zSql; } aQuery[] = {
-     { "number of tables:",
-       "SELECT count(*) FROM %s WHERE type='table'" },
-     { "number of indexes:",
-       "SELECT count(*) FROM %s WHERE type='index'" },
-     { "number of triggers:",
-       "SELECT count(*) FROM %s WHERE type='trigger'" },
-     { "number of views:",
-       "SELECT count(*) FROM %s WHERE type='view'" },
-     { "schema size:",
-       "SELECT total(length(sql)) FROM %s" },
-  };
-  int i, rc;
-  unsigned iDataVersion;
-  char *zSchemaTab;
-  char *zDb = nArg>=2 ? azArg[1] : "main";
-  sqlite3_stmt *pStmt = 0;
-  unsigned char aHdr[100];
-  open_db(p, 0);
-  if( p->db==0 ) return 1;
-  rc = sqlite3_prepare_v2(p->db,
-             "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
-             -1, &pStmt, 0);
-  if( rc ){
-    cli_printf(stderr,"error: %s\n", sqlite3_errmsg(p->db));
-    sqlite3_finalize(pStmt);
-    return 1;
-  }
-  sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC);
-  if( sqlite3_step(pStmt)==SQLITE_ROW
-   && sqlite3_column_bytes(pStmt,0)>100
-  ){
-    const u8 *pb = sqlite3_column_blob(pStmt,0);
-    shell_check_oom(pb);
-    memcpy(aHdr, pb, 100);
-    sqlite3_finalize(pStmt);
-  }else{
-    cli_puts("unable to read database header\n", stderr);
-    sqlite3_finalize(pStmt);
-    return 1;
-  }
-  i = get2byteInt(aHdr+16);
-  if( i==1 ) i = 65536;
-  cli_printf(p->out, "%-20s %d\n", "database page size:", i);
-  cli_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
-  cli_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
-  cli_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
-  for(i=0; iout, "%-20s %u", aField[i].zName, val);
-    switch( ofst ){
-      case 56: {
-        if( val==1 ) cli_puts(" (utf8)", p->out);
-        if( val==2 ) cli_puts(" (utf16le)", p->out);
-        if( val==3 ) cli_puts(" (utf16be)", p->out);
-      }
-    }
-    cli_puts("\n", p->out);
-  }
-  if( zDb==0 ){
-    zSchemaTab = sqlite3_mprintf("main.sqlite_schema");
-  }else if( cli_strcmp(zDb,"temp")==0 ){
-    zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_schema");
-  }else{
-    zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_schema", zDb);
-  }
-  for(i=0; idb, aQuery[i].zSql, zSchemaTab);
-    cli_printf(p->out, "%-20s %d\n", aQuery[i].zName, val);
-  }
-  sqlite3_free(zSchemaTab);
-  sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_DATA_VERSION, &iDataVersion);
-  cli_printf(p->out, "%-20s %u\n", "data version", iDataVersion);
-  return 0;
-}
-#endif /* SQLITE_SHELL_HAVE_RECOVER */
-
-/*
-** Implementation of the ".dbtotxt" command.
-**
-** Return 1 on error, 2 to exit, and 0 otherwise.
-*/
-static int shell_dbtotxt_command(ShellState *p, int nArg, char **azArg){
-  sqlite3_stmt *pStmt = 0;
-  sqlite3_int64 nPage = 0;
-  int pgSz = 0;
-  const char *zTail;
-  char *zName = 0;
-  int rc, i, j;
-  unsigned char bShow[256];   /* Characters ok to display */
-
-  UNUSED_PARAMETER(nArg);
-  UNUSED_PARAMETER(azArg);
-  memset(bShow, '.', sizeof(bShow));
-  for(i=' '; i<='~'; i++){
-    if( i!='{' && i!='}' && i!='"' && i!='\\' ) bShow[i] = (unsigned char)i;
-  }
-  rc = sqlite3_prepare_v2(p->db, "PRAGMA page_size", -1, &pStmt, 0);
-  if( rc ) goto dbtotxt_error;
-  rc = 0;
-  if( sqlite3_step(pStmt)!=SQLITE_ROW ) goto dbtotxt_error;
-  pgSz = sqlite3_column_int(pStmt, 0);
-  sqlite3_finalize(pStmt);
-  pStmt = 0;
-  if( pgSz<512 || pgSz>65536 || (pgSz&(pgSz-1))!=0 ) goto dbtotxt_error;
-  rc = sqlite3_prepare_v2(p->db, "PRAGMA page_count", -1, &pStmt, 0);
-  if( rc ) goto dbtotxt_error;
-  rc = 0;
-  if( sqlite3_step(pStmt)!=SQLITE_ROW ) goto dbtotxt_error;
-  nPage = sqlite3_column_int64(pStmt, 0);
-  sqlite3_finalize(pStmt);
-  pStmt = 0;
-  if( nPage<1 ) goto dbtotxt_error;
-  rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
-  if( rc ) goto dbtotxt_error;
-  if( sqlite3_step(pStmt)!=SQLITE_ROW ){
-    zTail = "unk.db";
-  }else{
-    const char *zFilename = (const char*)sqlite3_column_text(pStmt, 2);
-    if( zFilename==0 || zFilename[0]==0 ) zFilename = "unk.db";
-    zTail = strrchr(zFilename, '/');
-#if defined(_WIN32)
-    if( zTail==0 ) zTail = strrchr(zFilename, '\\');
-#endif
-    if( zTail==0 ){
-      zTail = zFilename;
-    }else if( zTail[1]!=0 ){
-      zTail++;
-    }
-  }
-  zName = strdup(zTail);
-  shell_check_oom(zName);
-  cli_printf(p->out, "| size %lld pagesize %d filename %s\n",
-                  nPage*pgSz, pgSz, zName);
-  sqlite3_finalize(pStmt);
-  pStmt = 0;
-  rc = sqlite3_prepare_v2(p->db,
-           "SELECT pgno, data FROM sqlite_dbpage ORDER BY pgno", -1, &pStmt, 0);
-  if( rc ) goto dbtotxt_error;
-  while( sqlite3_step(pStmt)==SQLITE_ROW ){
-    sqlite3_int64 pgno = sqlite3_column_int64(pStmt, 0);
-    const u8 *aData = sqlite3_column_blob(pStmt, 1);
-    int seenPageLabel = 0;
-    for(i=0; iout, "| page %lld offset %lld\n",pgno,(pgno-1)*pgSz);
-        seenPageLabel = 1;
-      }
-      cli_printf(p->out, "|  %5d:", i);
-      for(j=0; j<16; j++) cli_printf(p->out, " %02x", aLine[j]);
-      cli_printf(p->out, "   ");
-      for(j=0; j<16; j++){
-        unsigned char c = (unsigned char)aLine[j];
-        cli_printf(p->out, "%c", bShow[c]);
-      }
-      cli_printf(p->out, "\n");
-    }
-  }
-  sqlite3_finalize(pStmt);
-  cli_printf(p->out, "| end %s\n", zName);
-  free(zName);
-  return 0;
-
-dbtotxt_error:
-  if( rc ){
-    cli_printf(stderr, "ERROR: %s\n", sqlite3_errmsg(p->db));
-  }
-  sqlite3_finalize(pStmt);
-  free(zName);
-  return 1;
-}
-
-/*
-** Print the given string as an error message.
-*/
-static void shellEmitError(const char *zErr){
-  cli_printf(stderr,"Error: %s\n", zErr);
-}
-/*
-** Print the current sqlite3_errmsg() value to stderr and return 1.
-*/
-static int shellDatabaseError(sqlite3 *db){
-  shellEmitError(sqlite3_errmsg(db));
-  return 1;
-}
-
-/*
-** Compare the pattern in zGlob[] against the text in z[].  Return TRUE
-** if they match and FALSE (0) if they do not match.
-**
-** Globbing rules:
-**
-**      '*'       Matches any sequence of zero or more characters.
-**
-**      '?'       Matches exactly one character.
-**
-**     [...]      Matches one character from the enclosed list of
-**                characters.
-**
-**     [^...]     Matches one character not in the enclosed list.
-**
-**      '#'       Matches any sequence of one or more digits with an
-**                optional + or - sign in front
-**
-**      ' '       Any span of whitespace matches any other span of
-**                whitespace.
-**
-** Extra whitespace at the end of z[] is ignored.
-*/
-static int testcase_glob(const char *zGlob, const char *z){
-  int c, c2;
-  int invert;
-  int seen;
-
-  while( (c = (*(zGlob++)))!=0 ){
-    if( IsSpace(c) ){
-      if( !IsSpace(*z) ) return 0;
-      while( IsSpace(*zGlob) ) zGlob++;
-      while( IsSpace(*z) ) z++;
-    }else if( c=='*' ){
-      while( (c=(*(zGlob++))) == '*' || c=='?' ){
-        if( c=='?' && (*(z++))==0 ) return 0;
-      }
-      if( c==0 ){
-        return 1;
-      }else if( c=='[' ){
-        while( *z && testcase_glob(zGlob-1,z)==0 ){
-          z++;
-        }
-        return (*z)!=0;
-      }
-      while( (c2 = (*(z++)))!=0 ){
-        while( c2!=c ){
-          c2 = *(z++);
-          if( c2==0 ) return 0;
-        }
-        if( testcase_glob(zGlob,z) ) return 1;
-      }
-      return 0;
-    }else if( c=='?' ){
-      if( (*(z++))==0 ) return 0;
-    }else if( c=='[' ){
-      int prior_c = 0;
-      seen = 0;
-      invert = 0;
-      c = *(z++);
-      if( c==0 ) return 0;
-      c2 = *(zGlob++);
-      if( c2=='^' ){
-        invert = 1;
-        c2 = *(zGlob++);
-      }
-      if( c2==']' ){
-        if( c==']' ) seen = 1;
-        c2 = *(zGlob++);
-      }
-      while( c2 && c2!=']' ){
-        if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
-          c2 = *(zGlob++);
-          if( c>=prior_c && c<=c2 ) seen = 1;
-          prior_c = 0;
-        }else{
-          if( c==c2 ){
-            seen = 1;
-          }
-          prior_c = c2;
-        }
-        c2 = *(zGlob++);
-      }
-      if( c2==0 || (seen ^ invert)==0 ) return 0;
-    }else if( c=='#' ){
-      if( (z[0]=='-' || z[0]=='+') && IsDigit(z[1]) ) z++;
-      if( !IsDigit(z[0]) ) return 0;
-      z++;
-      while( IsDigit(z[0]) ){ z++; }
-    }else{
-      if( c!=(*(z++)) ) return 0;
-    }
-  }
-  while( IsSpace(*z) ){ z++; }
-  return *z==0;
-}
-
-
-/*
-** Compare the string as a command-line option with either one or two
-** initial "-" characters.
-*/
-static int optionMatch(const char *zStr, const char *zOpt){
-  if( zStr[0]!='-' ) return 0;
-  zStr++;
-  if( zStr[0]=='-' ) zStr++;
-  return cli_strcmp(zStr, zOpt)==0;
-}
-
-/*
-** The input zFN is guaranteed to start with "file:" and is thus a URI
-** filename.  Extract the actual filename and return a pointer to that
-** filename in spaced obtained from sqlite3_malloc().
-**
-** The caller is responsible for freeing space using sqlite3_free() when
-** it has finished with the filename.
-*/
-static char *shellFilenameFromUri(const char *zFN){
-  char *zOut;
-  int i, j, d1, d2;
-
-  assert( cli_strncmp(zFN,"file:",5)==0 );
-  zOut = sqlite3_mprintf("%s", zFN+5);
-  shell_check_oom(zOut);
-  for(i=j=0; zOut[i]!=0 && zOut[i]!='?'; i++){
-    if( zOut[i]!='%' ){
-      zOut[j++] = zOut[i];
-      continue;
-    }
-    d1 = hexDigitValue(zOut[i+1]);
-    if( d1<0 ){
-      zOut[j] = 0;
-      break;
-    }
-    d2 = hexDigitValue(zOut[i+2]);
-    if( d2<0 ){
-      zOut[j] = 0;
-      break;
-    }
-    zOut[j++] = d1*16 + d2;
-    i += 2;
-  }
-  zOut[j] = 0;
-  return zOut;
-}
-
-/*
-** Delete a file.
-*/
-int shellDeleteFile(const char *zFilename){
-  int rc;
-#ifdef _WIN32
-  wchar_t *z = sqlite3_win32_utf8_to_unicode(zFilename);
-  rc = _wunlink(z);
-  sqlite3_free(z);
-#else
-  rc = unlink(zFilename);
-#endif
-  return rc;
-}
-
-/*
-** Try to delete the temporary file (if there is one) and free the
-** memory used to hold the name of the temp file.
-*/
-static void clearTempFile(ShellState *p){
-  if( p->zTempFile==0 ) return;
-  if( p->doXdgOpen ) return;
-  if( shellDeleteFile(p->zTempFile) ) return;
-  sqlite3_free(p->zTempFile);
-  p->zTempFile = 0;
-}
-
-/* Forward reference */
-static char *find_home_dir(int clearFlag);
-
-/*
-** Create a new temp file name with the given suffix.
-**
-** Because the classic temp folders like /tmp are no longer
-** accessible to web browsers, for security reasons, create the
-** temp file in the user's home directory.
-*/
-static void newTempFile(ShellState *p, const char *zSuffix){
-  char *zHome;          /* Home directory */
-  int i;                /* Loop counter */
-  sqlite3_uint64 r = 0; /* Integer with 64 bits of randomness */
-  char zRand[32];       /* Text string with 160 bits of randomness */
-#ifdef _WIN32
-  const char cDirSep = '\\';
-#else
-  const char cDirSep = '/';
-#endif
-
-  for(i=0; i<31; i++){
-    if( (i%12)==0 ) sqlite3_randomness(sizeof(r),&r);
-    zRand[i] = "0123456789abcdefghijklmnopqrstuvwxyz"[r%36];
-    r /= 36;
-  }
-  zRand[i] = 0;
-  clearTempFile(p);
-  sqlite3_free(p->zTempFile);
-  p->zTempFile = 0;
-  zHome = find_home_dir(0);
-  p->zTempFile = sqlite3_mprintf("%s%ctemp-%s.%s",
-                                 zHome,cDirSep,zRand,zSuffix);
-  shell_check_oom(p->zTempFile);
-}
-
-/*
-** The implementation of SQL scalar function fkey_collate_clause(), used
-** by the ".lint fkey-indexes" command. This scalar function is always
-** called with four arguments - the parent table name, the parent column name,
-** the child table name and the child column name.
-**
-**   fkey_collate_clause('parent-tab', 'parent-col', 'child-tab', 'child-col')
-**
-** If either of the named tables or columns do not exist, this function
-** returns an empty string. An empty string is also returned if both tables
-** and columns exist but have the same default collation sequence. Or,
-** if both exist but the default collation sequences are different, this
-** function returns the string " COLLATE ", where
-**  is the default collation sequence of the parent column.
-*/
-static void shellFkeyCollateClause(
-  sqlite3_context *pCtx,
-  int nVal,
-  sqlite3_value **apVal
-){
-  sqlite3 *db = sqlite3_context_db_handle(pCtx);
-  const char *zParent;
-  const char *zParentCol;
-  const char *zParentSeq;
-  const char *zChild;
-  const char *zChildCol;
-  const char *zChildSeq = 0;  /* Initialize to avoid false-positive warning */
-  int rc;
-
-  assert( nVal==4 );
-  zParent = (const char*)sqlite3_value_text(apVal[0]);
-  zParentCol = (const char*)sqlite3_value_text(apVal[1]);
-  zChild = (const char*)sqlite3_value_text(apVal[2]);
-  zChildCol = (const char*)sqlite3_value_text(apVal[3]);
-
-  sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
-  rc = sqlite3_table_column_metadata(
-      db, "main", zParent, zParentCol, 0, &zParentSeq, 0, 0, 0
-  );
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_table_column_metadata(
-        db, "main", zChild, zChildCol, 0, &zChildSeq, 0, 0, 0
-    );
-  }
-
-  if( rc==SQLITE_OK && sqlite3_stricmp(zParentSeq, zChildSeq) ){
-    char *z = sqlite3_mprintf(" COLLATE %s", zParentSeq);
-    sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
-    sqlite3_free(z);
-  }
-}
-
-
-/*
-** The implementation of dot-command ".lint fkey-indexes".
-*/
-static int lintFkeyIndexes(
-  ShellState *pState,             /* Current shell tool state */
-  char **azArg,                   /* Array of arguments passed to dot command */
-  int nArg                        /* Number of entries in azArg[] */
-){
-  sqlite3 *db = pState->db;       /* Database handle to query "main" db of */
-  int bVerbose = 0;               /* If -verbose is present */
-  int bGroupByParent = 0;         /* If -groupbyparent is present */
-  int i;                          /* To iterate through azArg[] */
-  const char *zIndent = "";       /* How much to indent CREATE INDEX by */
-  int rc;                         /* Return code */
-  sqlite3_stmt *pSql = 0;         /* Compiled version of SQL statement below */
-  FILE *out = pState->out;        /* Send output here */
-
-  /*
-  ** This SELECT statement returns one row for each foreign key constraint
-  ** in the schema of the main database. The column values are:
-  **
-  ** 0. The text of an SQL statement similar to:
-  **
-  **      "EXPLAIN QUERY PLAN SELECT 1 FROM child_table WHERE child_key=?"
-  **
-  **    This SELECT is similar to the one that the foreign keys implementation
-  **    needs to run internally on child tables. If there is an index that can
-  **    be used to optimize this query, then it can also be used by the FK
-  **    implementation to optimize DELETE or UPDATE statements on the parent
-  **    table.
-  **
-  ** 1. A GLOB pattern suitable for sqlite3_strglob(). If the plan output by
-  **    the EXPLAIN QUERY PLAN command matches this pattern, then the schema
-  **    contains an index that can be used to optimize the query.
-  **
-  ** 2. Human readable text that describes the child table and columns. e.g.
-  **
-  **       "child_table(child_key1, child_key2)"
-  **
-  ** 3. Human readable text that describes the parent table and columns. e.g.
-  **
-  **       "parent_table(parent_key1, parent_key2)"
-  **
-  ** 4. A full CREATE INDEX statement for an index that could be used to
-  **    optimize DELETE or UPDATE statements on the parent table. e.g.
-  **
-  **       "CREATE INDEX child_table_child_key ON child_table(child_key)"
-  **
-  ** 5. The name of the parent table.
-  **
-  ** These six values are used by the C logic below to generate the report.
-  */
-  const char *zSql =
-  "SELECT "
-    "     'EXPLAIN QUERY PLAN SELECT 1 FROM ' || quote(s.name) || ' WHERE '"
-    "  || group_concat(quote(s.name) || '.' || quote(f.[from]) || '=?' "
-    "  || fkey_collate_clause("
-    "       f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]),' AND ')"
-    ", "
-    "     'SEARCH ' || s.name || ' USING COVERING INDEX*('"
-    "  || group_concat('*=?', ' AND ') || ')'"
-    ", "
-    "     s.name  || '(' || group_concat(f.[from],  ', ') || ')'"
-    ", "
-    "     f.[table] || '(' || group_concat(COALESCE(f.[to], p.[name])) || ')'"
-    ", "
-    "     'CREATE INDEX ' || quote(s.name ||'_'|| group_concat(f.[from], '_'))"
-    "  || ' ON ' || quote(s.name) || '('"
-    "  || group_concat(quote(f.[from]) ||"
-    "        fkey_collate_clause("
-    "          f.[table], COALESCE(f.[to], p.[name]), s.name, f.[from]), ', ')"
-    "  || ');'"
-    ", "
-    "     f.[table] "
-    "FROM sqlite_schema AS s, pragma_foreign_key_list(s.name) AS f "
-    "LEFT JOIN pragma_table_info AS p ON (pk-1=seq AND p.arg=f.[table]) "
-    "GROUP BY s.name, f.id "
-    "ORDER BY (CASE WHEN ? THEN f.[table] ELSE s.name END)"
-  ;
-  const char *zGlobIPK = "SEARCH * USING INTEGER PRIMARY KEY (rowid=?)";
-
-  for(i=2; i1 && sqlite3_strnicmp("-verbose", azArg[i], n)==0 ){
-      bVerbose = 1;
-    }
-    else if( n>1 && sqlite3_strnicmp("-groupbyparent", azArg[i], n)==0 ){
-      bGroupByParent = 1;
-      zIndent = "    ";
-    }
-    else{
-      cli_printf(stderr,
-           "Usage: %s %s ?-verbose? ?-groupbyparent?\n", azArg[0], azArg[1]);
-      return SQLITE_ERROR;
-    }
-  }
-
-  /* Register the fkey_collate_clause() SQL function */
-  rc = sqlite3_create_function(db, "fkey_collate_clause", 4, SQLITE_UTF8,
-      0, shellFkeyCollateClause, 0, 0
-  );
-
-
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_prepare_v2(db, zSql, -1, &pSql, 0);
-  }
-  if( rc==SQLITE_OK ){
-    sqlite3_bind_int(pSql, 1, bGroupByParent);
-  }
-
-  if( rc==SQLITE_OK ){
-    int rc2;
-    char *zPrev = 0;
-    while( SQLITE_ROW==sqlite3_step(pSql) ){
-      int res = -1;
-      sqlite3_stmt *pExplain = 0;
-      const char *zEQP = (const char*)sqlite3_column_text(pSql, 0);
-      const char *zGlob = (const char*)sqlite3_column_text(pSql, 1);
-      const char *zFrom = (const char*)sqlite3_column_text(pSql, 2);
-      const char *zTarget = (const char*)sqlite3_column_text(pSql, 3);
-      const char *zCI = (const char*)sqlite3_column_text(pSql, 4);
-      const char *zParent = (const char*)sqlite3_column_text(pSql, 5);
-
-      if( zEQP==0 ) continue;
-      if( zGlob==0 ) continue;
-      rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
-      if( rc!=SQLITE_OK ) break;
-      if( SQLITE_ROW==sqlite3_step(pExplain) ){
-        const char *zPlan = (const char*)sqlite3_column_text(pExplain, 3);
-        res = zPlan!=0 && (  0==sqlite3_strglob(zGlob, zPlan)
-                          || 0==sqlite3_strglob(zGlobIPK, zPlan));
-      }
-      rc = sqlite3_finalize(pExplain);
-      if( rc!=SQLITE_OK ) break;
-
-      if( res<0 ){
-        cli_puts("Error: internal error", stderr);
-        break;
-      }else{
-        if( bGroupByParent
-        && (bVerbose || res==0)
-        && (zPrev==0 || sqlite3_stricmp(zParent, zPrev))
-        ){
-          cli_printf(out, "-- Parent table %s\n", zParent);
-          sqlite3_free(zPrev);
-          zPrev = sqlite3_mprintf("%s", zParent);
-        }
-
-        if( res==0 ){
-          cli_printf(out, "%s%s --> %s\n", zIndent, zCI, zTarget);
-        }else if( bVerbose ){
-          cli_printf(out,
-                "%s/* no extra indexes required for %s -> %s */\n",
-                zIndent, zFrom, zTarget
-          );
-        }
-      }
-    }
-    sqlite3_free(zPrev);
-
-    if( rc!=SQLITE_OK ){
-      cli_printf(stderr,"%s\n", sqlite3_errmsg(db));
-    }
-
-    rc2 = sqlite3_finalize(pSql);
-    if( rc==SQLITE_OK && rc2!=SQLITE_OK ){
-      rc = rc2;
-      cli_printf(stderr,"%s\n", sqlite3_errmsg(db));
-    }
-  }else{
-    cli_printf(stderr,"%s\n", sqlite3_errmsg(db));
-  }
-
-  return rc;
-}
-
-/*
-** Implementation of ".lint" dot command.
-*/
-static int lintDotCommand(
-  ShellState *pState,             /* Current shell tool state */
-  char **azArg,                   /* Array of arguments passed to dot command */
-  int nArg                        /* Number of entries in azArg[] */
-){
-  int n;
-  n = (nArg>=2 ? strlen30(azArg[1]) : 0);
-  if( n<1 || sqlite3_strnicmp(azArg[1], "fkey-indexes", n) ) goto usage;
-  return lintFkeyIndexes(pState, azArg, nArg);
-
- usage:
-  cli_printf(stderr,"Usage %s sub-command ?switches...?\n", azArg[0]);
-  cli_printf(stderr, "Where sub-commands are:\n");
-  cli_printf(stderr, "    fkey-indexes\n");
-  return SQLITE_ERROR;
-}
-
-static void shellPrepare(
-  sqlite3 *db,
-  int *pRc,
-  const char *zSql,
-  sqlite3_stmt **ppStmt
-){
-  *ppStmt = 0;
-  if( *pRc==SQLITE_OK ){
-    int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
-    if( rc!=SQLITE_OK ){
-      cli_printf(stderr,
-         "sql error: %s (%d)\n", sqlite3_errmsg(db), sqlite3_errcode(db));
-      *pRc = rc;
-    }
-  }
-}
-
-/*
-** Create a prepared statement using printf-style arguments for the SQL.
-*/
-static void shellPreparePrintf(
-  sqlite3 *db,
-  int *pRc,
-  sqlite3_stmt **ppStmt,
-  const char *zFmt,
-  ...
-){
-  *ppStmt = 0;
-  if( *pRc==SQLITE_OK ){
-    va_list ap;
-    char *z;
-    va_start(ap, zFmt);
-    z = sqlite3_vmprintf(zFmt, ap);
-    va_end(ap);
-    if( z==0 ){
-      *pRc = SQLITE_NOMEM;
-    }else{
-      shellPrepare(db, pRc, z, ppStmt);
-      sqlite3_free(z);
-    }
-  }
-}
-
-/* 
-** Finalize the prepared statement created using shellPreparePrintf().
-*/
-static void shellFinalize(
-  int *pRc,
-  sqlite3_stmt *pStmt
-){
-  if( pStmt ){
-    sqlite3 *db = sqlite3_db_handle(pStmt);
-    int rc = sqlite3_finalize(pStmt);
-    if( *pRc==SQLITE_OK ){
-      if( rc!=SQLITE_OK ){
-        cli_printf(stderr,"SQL error: %s\n", sqlite3_errmsg(db));
-      }
-      *pRc = rc;
-    }
-  }
-}
-
-#if !defined SQLITE_OMIT_VIRTUALTABLE
-/* Reset the prepared statement created using shellPreparePrintf().
-**
-** This routine is could be marked "static".  But it is not always used,
-** depending on compile-time options.  By omitting the "static", we avoid
-** nuisance compiler warnings about "defined but not used".
-*/
-void shellReset(
-  int *pRc,
-  sqlite3_stmt *pStmt
-){
-  int rc = sqlite3_reset(pStmt);
-  if( *pRc==SQLITE_OK ){
-    if( rc!=SQLITE_OK ){
-      sqlite3 *db = sqlite3_db_handle(pStmt);
-      cli_printf(stderr,"SQL error: %s\n", sqlite3_errmsg(db));
-    }
-    *pRc = rc;
-  }
-}
-#endif /* !defined SQLITE_OMIT_VIRTUALTABLE */
-
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
-/******************************************************************************
-** The ".archive" or ".ar" command.
-*/
-/*
-** Structure representing a single ".ar" command.
-*/
-typedef struct ArCommand ArCommand;
-struct ArCommand {
-  u8 eCmd;                        /* An AR_CMD_* value */
-  u8 bVerbose;                    /* True if --verbose */
-  u8 bZip;                        /* True if the archive is a ZIP */
-  u8 bDryRun;                     /* True if --dry-run */
-  u8 bAppend;                     /* True if --append */
-  u8 bGlob;                       /* True if --glob */
-  u8 fromCmdLine;                 /* Run from -A instead of .archive */
-  int nArg;                       /* Number of command arguments */
-  char *zSrcTable;                /* "sqlar", "zipfile($file)" or "zip" */
-  const char *zFile;              /* --file argument, or NULL */
-  const char *zDir;               /* --directory argument, or NULL */
-  char **azArg;                   /* Array of command arguments */
-  ShellState *p;                  /* Shell state */
-  FILE *out;                      /* Output to this stream */
-  sqlite3 *db;                    /* Database containing the archive */
-};
-
-/*
-** Print a usage message for the .ar command to stderr and return SQLITE_ERROR.
-*/
-static int arUsage(FILE *f){
-  showHelp(f,"archive");
-  return SQLITE_ERROR;
-}
-
-/*
-** Print an error message for the .ar command to stderr and return
-** SQLITE_ERROR.
-*/
-static int arErrorMsg(ArCommand *pAr, const char *zFmt, ...){
-  va_list ap;
-  char *z;
-  va_start(ap, zFmt);
-  z = sqlite3_vmprintf(zFmt, ap);
-  va_end(ap);
-  shellEmitError(z);
-  if( pAr->fromCmdLine ){
-    cli_puts("Use \"-A\" for more help\n", stderr);
-  }else{
-    cli_puts("Use \".archive --help\" for more help\n", stderr);
-  }
-  sqlite3_free(z);
-  return SQLITE_ERROR;
-}
-
-/*
-** Values for ArCommand.eCmd.
-*/
-#define AR_CMD_CREATE       1
-#define AR_CMD_UPDATE       2
-#define AR_CMD_INSERT       3
-#define AR_CMD_EXTRACT      4
-#define AR_CMD_LIST         5
-#define AR_CMD_HELP         6
-#define AR_CMD_REMOVE       7
-
-/*
-** Other (non-command) switches.
-*/
-#define AR_SWITCH_VERBOSE     8
-#define AR_SWITCH_FILE        9
-#define AR_SWITCH_DIRECTORY  10
-#define AR_SWITCH_APPEND     11
-#define AR_SWITCH_DRYRUN     12
-#define AR_SWITCH_GLOB       13
-
-static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){
-  switch( eSwitch ){
-    case AR_CMD_CREATE:
-    case AR_CMD_EXTRACT:
-    case AR_CMD_LIST:
-    case AR_CMD_REMOVE:
-    case AR_CMD_UPDATE:
-    case AR_CMD_INSERT:
-    case AR_CMD_HELP:
-      if( pAr->eCmd ){
-        return arErrorMsg(pAr, "multiple command options");
-      }
-      pAr->eCmd = eSwitch;
-      break;
-
-    case AR_SWITCH_DRYRUN:
-      pAr->bDryRun = 1;
-      break;
-    case AR_SWITCH_GLOB:
-      pAr->bGlob = 1;
-      break;
-    case AR_SWITCH_VERBOSE:
-      pAr->bVerbose = 1;
-      break;
-    case AR_SWITCH_APPEND:
-      pAr->bAppend = 1;
-      deliberate_fall_through; /* FALLTHRU */
-    case AR_SWITCH_FILE:
-      pAr->zFile = zArg;
-      break;
-    case AR_SWITCH_DIRECTORY:
-      pAr->zDir = zArg;
-      break;
-  }
-
-  return SQLITE_OK;
-}
-
-/*
-** Parse the command line for an ".ar" command. The results are written into
-** structure (*pAr). SQLITE_OK is returned if the command line is parsed
-** successfully, otherwise an error message is written to stderr and
-** SQLITE_ERROR returned.
-*/
-static int arParseCommand(
-  char **azArg,                   /* Array of arguments passed to dot command */
-  int nArg,                       /* Number of entries in azArg[] */
-  ArCommand *pAr                  /* Populate this object */
-){
-  struct ArSwitch {
-    const char *zLong;
-    char cShort;
-    u8 eSwitch;
-    u8 bArg;
-  } aSwitch[] = {
-    { "create",    'c', AR_CMD_CREATE,       0 },
-    { "extract",   'x', AR_CMD_EXTRACT,      0 },
-    { "insert",    'i', AR_CMD_INSERT,       0 },
-    { "list",      't', AR_CMD_LIST,         0 },
-    { "remove",    'r', AR_CMD_REMOVE,       0 },
-    { "update",    'u', AR_CMD_UPDATE,       0 },
-    { "help",      'h', AR_CMD_HELP,         0 },
-    { "verbose",   'v', AR_SWITCH_VERBOSE,   0 },
-    { "file",      'f', AR_SWITCH_FILE,      1 },
-    { "append",    'a', AR_SWITCH_APPEND,    1 },
-    { "directory", 'C', AR_SWITCH_DIRECTORY, 1 },
-    { "dryrun",    'n', AR_SWITCH_DRYRUN,    0 },
-    { "glob",      'g', AR_SWITCH_GLOB,      0 },
-  };
-  int nSwitch = sizeof(aSwitch) / sizeof(struct ArSwitch);
-  struct ArSwitch *pEnd = &aSwitch[nSwitch];
-
-  if( nArg<=1 ){
-    cli_printf(stderr, "Wrong number of arguments.  Usage:\n");
-    return arUsage(stderr);
-  }else{
-    char *z = azArg[1];
-    if( z[0]!='-' ){
-      /* Traditional style [tar] invocation */
-      int i;
-      int iArg = 2;
-      for(i=0; z[i]; i++){
-        const char *zArg = 0;
-        struct ArSwitch *pOpt;
-        for(pOpt=&aSwitch[0]; pOptcShort ) break;
-        }
-        if( pOpt==pEnd ){
-          return arErrorMsg(pAr, "unrecognized option: %c", z[i]);
-        }
-        if( pOpt->bArg ){
-          if( iArg>=nArg ){
-            return arErrorMsg(pAr, "option requires an argument: %c",z[i]);
-          }
-          zArg = azArg[iArg++];
-        }
-        if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR;
-      }
-      pAr->nArg = nArg-iArg;
-      if( pAr->nArg>0 ){
-        pAr->azArg = &azArg[iArg];
-      }
-    }else{
-      /* Non-traditional invocation */
-      int iArg;
-      for(iArg=1; iArgazArg = &azArg[iArg];
-          pAr->nArg = nArg-iArg;
-          break;
-        }
-        n = strlen30(z);
-
-        if( z[1]!='-' ){
-          int i;
-          /* One or more short options */
-          for(i=1; icShort ) break;
-            }
-            if( pOpt==pEnd ){
-              return arErrorMsg(pAr, "unrecognized option: %c", z[i]);
-            }
-            if( pOpt->bArg ){
-              if( i<(n-1) ){
-                zArg = &z[i+1];
-                i = n;
-              }else{
-                if( iArg>=(nArg-1) ){
-                  return arErrorMsg(pAr, "option requires an argument: %c",
-                                    z[i]);
-                }
-                zArg = azArg[++iArg];
-              }
-            }
-            if( arProcessSwitch(pAr, pOpt->eSwitch, zArg) ) return SQLITE_ERROR;
-          }
-        }else if( z[2]=='\0' ){
-          /* A -- option, indicating that all remaining command line words
-          ** are command arguments.  */
-          pAr->azArg = &azArg[iArg+1];
-          pAr->nArg = nArg-iArg-1;
-          break;
-        }else{
-          /* A long option */
-          const char *zArg = 0;             /* Argument for option, if any */
-          struct ArSwitch *pMatch = 0;      /* Matching option */
-          struct ArSwitch *pOpt;            /* Iterator */
-          for(pOpt=&aSwitch[0]; pOptzLong;
-            if( (n-2)<=strlen30(zLong) && 0==memcmp(&z[2], zLong, n-2) ){
-              if( pMatch ){
-                return arErrorMsg(pAr, "ambiguous option: %s",z);
-              }else{
-                pMatch = pOpt;
-              }
-            }
-          }
-
-          if( pMatch==0 ){
-            return arErrorMsg(pAr, "unrecognized option: %s", z);
-          }
-          if( pMatch->bArg ){
-            if( iArg>=(nArg-1) ){
-              return arErrorMsg(pAr, "option requires an argument: %s", z);
-            }
-            zArg = azArg[++iArg];
-          }
-          if( arProcessSwitch(pAr, pMatch->eSwitch, zArg) ) return SQLITE_ERROR;
-        }
-      }
-    }
-  }
-  if( pAr->eCmd==0 ){
-    cli_printf(stderr, "Required argument missing.  Usage:\n");
-    return arUsage(stderr);
-  }
-  return SQLITE_OK;
-}
-
-/*
-** This function assumes that all arguments within the ArCommand.azArg[]
-** array refer to archive members, as for the --extract, --list or --remove
-** commands. It checks that each of them are "present". If any specified
-** file is not present in the archive, an error is printed to stderr and an
-** error code returned. Otherwise, if all specified arguments are present
-** in the archive, SQLITE_OK is returned. Here, "present" means either an
-** exact equality when pAr->bGlob is false or a "name GLOB pattern" match
-** when pAr->bGlob is true.
-**
-** This function strips any trailing '/' characters from each argument.
-** This is consistent with the way the [tar] command seems to work on
-** Linux.
-*/
-static int arCheckEntries(ArCommand *pAr){
-  int rc = SQLITE_OK;
-  if( pAr->nArg ){
-    int i, j;
-    sqlite3_stmt *pTest = 0;
-    const char *zSel = (pAr->bGlob)
-      ? "SELECT name FROM %s WHERE glob($name,name)"
-      : "SELECT name FROM %s WHERE name=$name";
-
-    shellPreparePrintf(pAr->db, &rc, &pTest, zSel, pAr->zSrcTable);
-    j = sqlite3_bind_parameter_index(pTest, "$name");
-    for(i=0; inArg && rc==SQLITE_OK; i++){
-      char *z = pAr->azArg[i];
-      int n = strlen30(z);
-      int bOk = 0;
-      while( n>0 && z[n-1]=='/' ) n--;
-      z[n] = '\0';
-      sqlite3_bind_text(pTest, j, z, -1, SQLITE_STATIC);
-      if( SQLITE_ROW==sqlite3_step(pTest) ){
-        bOk = 1;
-      }
-      shellReset(&rc, pTest);
-      if( rc==SQLITE_OK && bOk==0 ){
-        cli_printf(stderr,"not found in archive: %s\n", z);
-        rc = SQLITE_ERROR;
-      }
-    }
-    shellFinalize(&rc, pTest);
-  }
-  return rc;
-}
-
-/*
-** Format a WHERE clause that can be used against the "sqlar" table to
-** identify all archive members that match the command arguments held
-** in (*pAr). Leave this WHERE clause in (*pzWhere) before returning.
-** The caller is responsible for eventually calling sqlite3_free() on
-** any non-NULL (*pzWhere) value. Here, "match" means strict equality
-** when pAr->bGlob is false and GLOB match when pAr->bGlob is true.
-*/
-static void arWhereClause(
-  int *pRc,
-  ArCommand *pAr,
-  char **pzWhere                  /* OUT: New WHERE clause */
-){
-  char *zWhere = 0;
-  if( *pRc==SQLITE_OK ){
-    if( pAr->nArg==0 ){
-      zWhere = sqlite3_mprintf("1");
-    }else{
-      char *z1 = sqlite3_mprintf(pAr->bGlob ? "" : "name IN(");
-      char *z2 = sqlite3_mprintf("");
-      const char *zSep1 = "";
-      const char *zSep2 = "";
-
-      int i;
-      for(i=0; inArg && z1 && z2; i++){
-        const char *z = pAr->azArg[i];
-        int n = strlen30(z);
-
-        if( pAr->bGlob ){
-          z1 = sqlite3_mprintf("%z%sname GLOB '%q'", z1, zSep2, z);
-          z2 = sqlite3_mprintf(
-              "%z%ssubstr(name,1,%d) GLOB '%q/'", z2, zSep2, n+1,z
-          );
-        }else{
-          z1 = sqlite3_mprintf("%z%s'%q'", z1, zSep1, z);
-          z2 = sqlite3_mprintf("%z%ssubstr(name,1,%d) = '%q/'",z2,zSep2,n+1,z);
-        }
-        zSep1 = ", ";
-        zSep2 = " OR ";
-      }
-      if( z1==0 || z2==0 ){
-        *pRc = SQLITE_NOMEM;
-      }else{
-        zWhere = sqlite3_mprintf("(%s%s OR (name GLOB '*/*' AND (%s))) ",
-            z1, pAr->bGlob==0 ? ")" : "", z2
-        );
-      }
-      sqlite3_free(z1);
-      sqlite3_free(z2);
-    }
-  }
-  *pzWhere = zWhere;
-}
-
-/*
-** Implementation of .ar "lisT" command.
-*/
-static int arListCommand(ArCommand *pAr){
-  const char *zSql = "SELECT %s FROM %s WHERE %s";
-  const char *azCols[] = {
-    "name",
-    "lsmode(mode), sz, datetime(mtime, 'unixepoch'), name"
-  };
-
-  char *zWhere = 0;
-  sqlite3_stmt *pSql = 0;
-  int rc;
-
-  rc = arCheckEntries(pAr);
-  arWhereClause(&rc, pAr, &zWhere);
-
-  shellPreparePrintf(pAr->db, &rc, &pSql, zSql, azCols[pAr->bVerbose],
-                     pAr->zSrcTable, zWhere);
-  if( pAr->bDryRun ){
-    cli_printf(pAr->out, "%s\n", sqlite3_sql(pSql));
-  }else{
-    while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
-      if( pAr->bVerbose ){
-        cli_printf(pAr->out, "%s % 10d  %s  %s\n",
-              sqlite3_column_text(pSql, 0), sqlite3_column_int(pSql, 1),
-              sqlite3_column_text(pSql, 2),sqlite3_column_text(pSql, 3));
-      }else{
-        cli_printf(pAr->out, "%s\n", sqlite3_column_text(pSql, 0));
-      }
-    }
-  }
-  shellFinalize(&rc, pSql);
-  sqlite3_free(zWhere);
-  return rc;
-}
-
-/*
-** Implementation of .ar "Remove" command.
-*/
-static int arRemoveCommand(ArCommand *pAr){
-  int rc = 0;
-  char *zSql = 0;
-  char *zWhere = 0;
-
-  if( pAr->nArg ){
-    /* Verify that args actually exist within the archive before proceeding.
-    ** And formulate a WHERE clause to match them.  */
-    rc = arCheckEntries(pAr);
-    arWhereClause(&rc, pAr, &zWhere);
-  }
-  if( rc==SQLITE_OK ){
-    zSql = sqlite3_mprintf("DELETE FROM %s WHERE %s;",
-                           pAr->zSrcTable, zWhere);
-    if( pAr->bDryRun ){
-      cli_printf(pAr->out, "%s\n", zSql);
-    }else{
-      char *zErr = 0;
-      rc = sqlite3_exec(pAr->db, "SAVEPOINT ar;", 0, 0, 0);
-      if( rc==SQLITE_OK ){
-        rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
-        if( rc!=SQLITE_OK ){
-          sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0);
-        }else{
-          rc = sqlite3_exec(pAr->db, "RELEASE ar;", 0, 0, 0);
-        }
-      }
-      if( zErr ){
-        cli_printf(stdout, "ERROR: %s\n", zErr); /* stdout? */
-        sqlite3_free(zErr);
-      }
-    }
-  }
-  sqlite3_free(zWhere);
-  sqlite3_free(zSql);
-  return rc;
-}
-
-/*
-** Implementation of .ar "eXtract" command.
-*/
-static int arExtractCommand(ArCommand *pAr){
-  const char *zSql1 =
-    "WITH dest(dpath,dlen) AS (SELECT realpath($dir),length(realpath($dir)))\n"
-    "SELECT ($dir || name),\n"
-    "       CASE WHEN $dryrun THEN 0\n"
-    "            ELSE writefile($dir||name, %s, mode, mtime) END\n"
-    "  FROM dest CROSS JOIN %s\n"
-    " WHERE (%s)\n"
-    "   AND (data IS NULL OR $pass==0)\n"                /* Dirs both passes */
-    "   AND dpath=substr(realpath($dir||name),1,dlen)\n" /* No escapes */
-    "   AND name NOT GLOB '*..[/\\]*'\n";                /* No /../ in paths */
-
-  const char *azExtraArg[] = {
-    "sqlar_uncompress(data, sz)",
-    "data"
-  };
-
-  sqlite3_stmt *pSql = 0;
-  int rc = SQLITE_OK;
-  char *zDir = 0;
-  char *zWhere = 0;
-  int i, j;
-
-  /* If arguments are specified, check that they actually exist within
-  ** the archive before proceeding. And formulate a WHERE clause to
-  ** match them.  */
-  rc = arCheckEntries(pAr);
-  arWhereClause(&rc, pAr, &zWhere);
-
-  if( rc==SQLITE_OK ){
-    if( pAr->zDir ){
-      zDir = sqlite3_mprintf("%s/", pAr->zDir);
-    }else{
-      zDir = sqlite3_mprintf("");
-    }
-    if( zDir==0 ) rc = SQLITE_NOMEM;
-  }
-
-  shellPreparePrintf(pAr->db, &rc, &pSql, zSql1,
-      azExtraArg[pAr->bZip], pAr->zSrcTable, zWhere
-  );
-
-  if( rc==SQLITE_OK ){
-    j = sqlite3_bind_parameter_index(pSql, "$dir");
-    sqlite3_bind_text(pSql, j, zDir, -1, SQLITE_STATIC);
-    j = sqlite3_bind_parameter_index(pSql, "$dryrun");
-    sqlite3_bind_int(pSql, j, pAr->bDryRun);
-
-    /* Run the SELECT statement twice
-    **   (0) writefile() all files and directories
-    **   (1) writefile() for directory again
-    ** The second pass is so that the timestamps for extracted directories
-    ** will be reset to the value in the archive, since populating them
-    ** in the first pass will have changed the timestamp. */
-    for(i=0; i<2; i++){
-      j = sqlite3_bind_parameter_index(pSql, "$pass");
-      sqlite3_bind_int(pSql, j, i);
-      if( pAr->bDryRun ){
-        cli_printf(pAr->out, "%s\n", sqlite3_sql(pSql));
-        if( pAr->bVerbose==0 ) break;
-      }
-      while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSql) ){
-        if( i==0 && pAr->bVerbose ){
-          cli_printf(pAr->out, "%s\n", sqlite3_column_text(pSql, 0));
-        }
-      }
-      if( pAr->bDryRun ) break;
-      shellReset(&rc, pSql);
-    }
-    shellFinalize(&rc, pSql);
-  }
-
-  sqlite3_free(zDir);
-  sqlite3_free(zWhere);
-  return rc;
-}
-
-/*
-** Run the SQL statement in zSql.  Or if doing a --dryrun, merely print it out.
-*/
-static int arExecSql(ArCommand *pAr, const char *zSql){
-  int rc;
-  if( pAr->bDryRun ){
-    cli_printf(pAr->out, "%s\n", zSql);
-    rc = SQLITE_OK;
-  }else{
-    char *zErr = 0;
-    rc = sqlite3_exec(pAr->db, zSql, 0, 0, &zErr);
-    if( zErr ){
-      cli_printf(stdout, "ERROR: %s\n", zErr);
-      sqlite3_free(zErr);
-    }
-  }
-  return rc;
-}
-
-
-/*
-** Implementation of .ar "create", "insert", and "update" commands.
-**
-**     create    ->     Create a new SQL archive
-**     insert    ->     Insert or reinsert all files listed
-**     update    ->     Insert files that have changed or that were not
-**                      previously in the archive
-**
-** Create the "sqlar" table in the database if it does not already exist.
-** Then add each file in the azFile[] array to the archive. Directories
-** are added recursively. If argument bVerbose is non-zero, a message is
-** printed on stdout for each file archived.
-**
-** The create command is the same as update, except that it drops
-** any existing "sqlar" table before beginning.  The "insert" command
-** always overwrites every file named on the command-line, where as
-** "update" only overwrites if the size or mtime or mode has changed.
-*/
-static int arCreateOrUpdateCommand(
-  ArCommand *pAr,                 /* Command arguments and options */
-  int bUpdate,                    /* true for a --create. */
-  int bOnlyIfChanged              /* Only update if file has changed */
-){
-  const char *zCreate =
-      "CREATE TABLE IF NOT EXISTS sqlar(\n"
-      "  name TEXT PRIMARY KEY,  -- name of the file\n"
-      "  mode INT,               -- access permissions\n"
-      "  mtime INT,              -- last modification time\n"
-      "  sz INT,                 -- original file size\n"
-      "  data BLOB               -- compressed content\n"
-      ")";
-  const char *zDrop = "DROP TABLE IF EXISTS sqlar";
-  const char *zInsertFmt[2] = {
-     "REPLACE INTO %s(name,mode,mtime,sz,data)\n"
-     "  SELECT\n"
-     "    %s,\n"
-     "    mode,\n"
-     "    mtime,\n"
-     "    CASE substr(lsmode(mode),1,1)\n"
-     "      WHEN '-' THEN length(data)\n"
-     "      WHEN 'd' THEN 0\n"
-     "      ELSE -1 END,\n"
-     "    sqlar_compress(data)\n"
-     "  FROM fsdir(%Q,%Q) AS disk\n"
-     "  WHERE lsmode(mode) NOT LIKE '?%%'%s;"
-     ,
-     "REPLACE INTO %s(name,mode,mtime,data)\n"
-     "  SELECT\n"
-     "    %s,\n"
-     "    mode,\n"
-     "    mtime,\n"
-     "    data\n"
-     "  FROM fsdir(%Q,%Q) AS disk\n"
-     "  WHERE lsmode(mode) NOT LIKE '?%%'%s;"
-  };
-  int i;                          /* For iterating through azFile[] */
-  int rc;                         /* Return code */
-  const char *zTab = 0;           /* SQL table into which to insert */
-  char *zSql;
-  char zTemp[50];
-  char *zExists = 0;
-
-  arExecSql(pAr, "PRAGMA page_size=512");
-  rc = arExecSql(pAr, "SAVEPOINT ar;");
-  if( rc!=SQLITE_OK ) return rc;
-  zTemp[0] = 0;
-  if( pAr->bZip ){
-    /* Initialize the zipfile virtual table, if necessary */
-    if( pAr->zFile ){
-      sqlite3_uint64 r;
-      sqlite3_randomness(sizeof(r),&r);
-      sqlite3_snprintf(sizeof(zTemp),zTemp,"zip%016llx",r);
-      zTab = zTemp;
-      zSql = sqlite3_mprintf(
-         "CREATE VIRTUAL TABLE temp.%s USING zipfile(%Q)",
-         zTab, pAr->zFile
-      );
-      rc = arExecSql(pAr, zSql);
-      sqlite3_free(zSql);
-    }else{
-      zTab = "zip";
-    }
-  }else{
-    /* Initialize the table for an SQLAR */
-    zTab = "sqlar";
-    if( bUpdate==0 ){
-      rc = arExecSql(pAr, zDrop);
-      if( rc!=SQLITE_OK ) goto end_ar_transaction;
-    }
-    rc = arExecSql(pAr, zCreate);
-  }
-  if( bOnlyIfChanged ){
-    zExists = sqlite3_mprintf(
-      " AND NOT EXISTS("
-          "SELECT 1 FROM %s AS mem"
-          " WHERE mem.name=disk.name"
-          " AND mem.mtime=disk.mtime"
-          " AND mem.mode=disk.mode)", zTab);
-  }else{
-    zExists = sqlite3_mprintf("");
-  }
-  if( zExists==0 ) rc = SQLITE_NOMEM;
-  for(i=0; inArg && rc==SQLITE_OK; i++){
-    char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab,
-        pAr->bVerbose ? "shell_putsnl(name)" : "name",
-        pAr->azArg[i], pAr->zDir, zExists);
-    rc = arExecSql(pAr, zSql2);
-    sqlite3_free(zSql2);
-  }
-end_ar_transaction:
-  if( rc!=SQLITE_OK ){
-    sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0);
-  }else{
-    rc = arExecSql(pAr, "RELEASE ar;");
-    if( pAr->bZip && pAr->zFile ){
-      zSql = sqlite3_mprintf("DROP TABLE %s", zTemp);
-      arExecSql(pAr, zSql);
-      sqlite3_free(zSql);
-    }
-  }
-  sqlite3_free(zExists);
-  return rc;
-}
-
-/*
-** Implementation of ".ar" dot command.
-*/
-static int arDotCommand(
-  ShellState *pState,          /* Current shell tool state */
-  int fromCmdLine,             /* True if -A command-line option, not .ar cmd */
-  char **azArg,                /* Array of arguments passed to dot command */
-  int nArg                     /* Number of entries in azArg[] */
-){
-  ArCommand cmd;
-  int rc;
-  memset(&cmd, 0, sizeof(cmd));
-  cmd.fromCmdLine = fromCmdLine;
-  rc = arParseCommand(azArg, nArg, &cmd);
-  if( rc==SQLITE_OK ){
-    int eDbType = SHELL_OPEN_UNSPEC;
-    cmd.p = pState;
-    cmd.out = pState->out;
-    cmd.db = pState->db;
-    if( cmd.zFile ){
-      eDbType = deduceDatabaseType(cmd.zFile, 1, 0);
-    }else{
-      eDbType = pState->openMode;
-    }
-    if( eDbType==SHELL_OPEN_ZIPFILE ){
-      if( cmd.eCmd==AR_CMD_EXTRACT || cmd.eCmd==AR_CMD_LIST ){
-        if( cmd.zFile==0 ){
-          cmd.zSrcTable = sqlite3_mprintf("zip");
-        }else{
-          cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile);
-        }
-      }
-      cmd.bZip = 1;
-    }else if( cmd.zFile ){
-      int flags;
-      if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS;
-      if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_INSERT
-           || cmd.eCmd==AR_CMD_REMOVE || cmd.eCmd==AR_CMD_UPDATE ){
-        flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
-      }else{
-        flags = SQLITE_OPEN_READONLY;
-      }
-      cmd.db = 0;
-      if( cmd.bDryRun ){
-        cli_printf(cmd.out, "-- open database '%s'%s\n", cmd.zFile,
-              eDbType==SHELL_OPEN_APPENDVFS ? " using 'apndvfs'" : "");
-      }
-      rc = sqlite3_open_v2(cmd.zFile, &cmd.db, flags,
-             eDbType==SHELL_OPEN_APPENDVFS ? "apndvfs" : 0);
-      if( rc!=SQLITE_OK ){
-        cli_printf(stderr, "cannot open file: %s (%s)\n",
-                        cmd.zFile, sqlite3_errmsg(cmd.db));
-        goto end_ar_command;
-      }
-      sqlite3_fileio_init(cmd.db, 0, 0);
-      sqlite3_sqlar_init(cmd.db, 0, 0);
-      sqlite3_create_function(cmd.db, "shell_putsnl", 1, SQLITE_UTF8, cmd.p,
-                              shellPutsFunc, 0, 0);
-
-    }
-    if( cmd.zSrcTable==0 && cmd.bZip==0 && cmd.eCmd!=AR_CMD_HELP ){
-      if( cmd.eCmd!=AR_CMD_CREATE
-       && sqlite3_table_column_metadata(cmd.db,0,"sqlar","name",0,0,0,0,0)
-      ){
-        cli_printf(stderr, "database does not contain an 'sqlar' table\n");
-        rc = SQLITE_ERROR;
-        goto end_ar_command;
-      }
-      cmd.zSrcTable = sqlite3_mprintf("sqlar");
-    }
-
-    switch( cmd.eCmd ){
-      case AR_CMD_CREATE:
-        rc = arCreateOrUpdateCommand(&cmd, 0, 0);
-        break;
-
-      case AR_CMD_EXTRACT:
-        rc = arExtractCommand(&cmd);
-        break;
-
-      case AR_CMD_LIST:
-        rc = arListCommand(&cmd);
-        break;
-
-      case AR_CMD_HELP:
-        arUsage(pState->out);
-        break;
-
-      case AR_CMD_INSERT:
-        rc = arCreateOrUpdateCommand(&cmd, 1, 0);
-        break;
-
-      case AR_CMD_REMOVE:
-        rc = arRemoveCommand(&cmd);
-        break;
-
-      default:
-        assert( cmd.eCmd==AR_CMD_UPDATE );
-        rc = arCreateOrUpdateCommand(&cmd, 1, 1);
-        break;
-    }
-  }
-end_ar_command:
-  if( cmd.db!=pState->db ){
-    close_db(cmd.db);
-  }
-  sqlite3_free(cmd.zSrcTable);
-
-  return rc;
-}
-/* End of the ".archive" or ".ar" command logic
-*******************************************************************************/
-#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) */
-
-#if SQLITE_SHELL_HAVE_RECOVER
-
-/*
-** This function is used as a callback by the recover extension. Simply
-** print the supplied SQL statement to stdout.
-*/
-static int recoverSqlCb(void *pCtx, const char *zSql){
-  ShellState *pState = (ShellState*)pCtx;
-  cli_printf(pState->out, "%s;\n", zSql);
-  return SQLITE_OK;
-}
-
-/*
-** This function is called to recover data from the database. A script
-** to construct a new database containing all recovered data is output
-** on stream pState->out.
-*/
-static int recoverDatabaseCmd(ShellState *pState, int nArg, char **azArg){
-  int rc = SQLITE_OK;
-  const char *zRecoveryDb = "";   /* Name of "recovery" database.  Debug only */
-  const char *zLAF = "lost_and_found";
-  int bFreelist = 1;              /* 0 if --ignore-freelist is specified */
-  int bRowids = 1;                /* 0 if --no-rowids */
-  sqlite3_recover *p = 0;
-  int i = 0;
-
-  for(i=1; iout, azArg[0]);
-      return 1;
-    }
-  }
-
-  p = sqlite3_recover_init_sql(
-      pState->db, "main", recoverSqlCb, (void*)pState
-  );
-
-  if( !pState->bSafeMode ){
-    sqlite3_recover_config(p, 789, (void*)zRecoveryDb);  /* Debug use only */
-  }
-  sqlite3_recover_config(p, SQLITE_RECOVER_LOST_AND_FOUND, (void*)zLAF);
-  sqlite3_recover_config(p, SQLITE_RECOVER_ROWIDS, (void*)&bRowids);
-  sqlite3_recover_config(p, SQLITE_RECOVER_FREELIST_CORRUPT,(void*)&bFreelist);
-
-  cli_printf(pState->out, ".dbconfig defensive off\n");
-  sqlite3_recover_run(p);
-  if( sqlite3_recover_errcode(p)!=SQLITE_OK ){
-    const char *zErr = sqlite3_recover_errmsg(p);
-    int errCode = sqlite3_recover_errcode(p);
-    cli_printf(stderr,"sql error: %s (%d)\n", zErr, errCode);
-  }
-  rc = sqlite3_recover_finish(p);
-  return rc;
-}
-#endif /* SQLITE_SHELL_HAVE_RECOVER */
-
-/*
-** Implementation of ".intck STEPS_PER_UNLOCK" command.
-*/
-static int intckDatabaseCmd(ShellState *pState, i64 nStepPerUnlock){
-  sqlite3_intck *p = 0;
-  int rc = SQLITE_OK;
-
-  rc = sqlite3_intck_open(pState->db, "main", &p);
-  if( rc==SQLITE_OK ){
-    i64 nStep = 0;
-    i64 nError = 0;
-    const char *zErr = 0;
-    while( SQLITE_OK==sqlite3_intck_step(p) ){
-      const char *zMsg = sqlite3_intck_message(p);
-      if( zMsg ){
-        cli_printf(pState->out, "%s\n", zMsg);
-        nError++;
-      }
-      nStep++;
-      if( nStepPerUnlock && (nStep % nStepPerUnlock)==0 ){
-        sqlite3_intck_unlock(p);
-      }
-    }
-    rc = sqlite3_intck_error(p, &zErr);
-    if( zErr ){
-      cli_printf(stderr,"%s\n", zErr);
-    }
-    sqlite3_intck_close(p);
-
-    cli_printf(pState->out, "%lld steps, %lld errors\n", nStep, nError);
-  }
-
-  return rc;
-}
-
-/*
- * zAutoColumn(zCol, &db, ?) => Maybe init db, add column zCol to it.
- * zAutoColumn(0, &db, ?) => (db!=0) Form columns spec for CREATE TABLE,
- *   close db and set it to 0, and return the columns spec, to later
- *   be sqlite3_free()'ed by the caller.
- * The return is 0 when either:
- *   (a) The db was not initialized and zCol==0 (There are no columns.)
- *   (b) zCol!=0  (Column was added, db initialized as needed.)
- * The 3rd argument, pRenamed, references an out parameter. If the
- * pointer is non-zero, its referent will be set to a summary of renames
- * done if renaming was necessary, or set to 0 if none was done. The out
- * string (if any) must be sqlite3_free()'ed by the caller.
- */
-#ifdef SHELL_DEBUG
-#define rc_err_oom_die(rc) \
-  if( rc==SQLITE_NOMEM ) shell_check_oom(0); \
-  else if(!(rc==SQLITE_OK||rc==SQLITE_DONE)) \
-    cli_printf(stderr,"E:%d\n",rc), assert(0)
-#else
-static void rc_err_oom_die(int rc){
-  if( rc==SQLITE_NOMEM ) shell_check_oom(0);
-  assert(rc==SQLITE_OK||rc==SQLITE_DONE);
-}
-#endif
-
-#ifdef SHELL_COLFIX_DB /* If this is set, the DB can be in a file. */
-static char zCOL_DB[] = SHELL_STRINGIFY(SHELL_COLFIX_DB);
-#else  /* Otherwise, memory is faster/better for the transient DB. */
-static const char *zCOL_DB = ":memory:";
-#endif
-
-/* Define character (as C string) to separate generated column ordinal
- * from protected part of incoming column names. This defaults to "_"
- * so that incoming column identifiers that did not need not be quoted
- * remain usable without being quoted. It must be one character.
- */
-#ifndef SHELL_AUTOCOLUMN_SEP
-# define AUTOCOLUMN_SEP "_"
-#else
-# define AUTOCOLUMN_SEP SHELL_STRINGIFY(SHELL_AUTOCOLUMN_SEP)
-#endif
-
-static char *zAutoColumn(const char *zColNew, sqlite3 **pDb, char **pzRenamed){
-  /* Queries and D{D,M}L used here */
-  static const char * const zTabMake = "\
-CREATE TABLE ColNames(\
- cpos INTEGER PRIMARY KEY,\
- name TEXT, nlen INT, chop INT, reps INT, suff TEXT);\
-CREATE VIEW RepeatedNames AS \
-SELECT DISTINCT t.name FROM ColNames t \
-WHERE t.name COLLATE NOCASE IN (\
- SELECT o.name FROM ColNames o WHERE o.cpos<>t.cpos\
-);\
-";
-  static const char * const zTabFill = "\
-INSERT INTO ColNames(name,nlen,chop,reps,suff)\
- VALUES(iif(length(?1)>0,?1,'?'),max(length(?1),1),0,0,'')\
-";
-  static const char * const zHasDupes = "\
-SELECT count(DISTINCT (substring(name,1,nlen-chop)||suff) COLLATE NOCASE)\
- 1, printf('%c%0*d', '"AUTOCOLUMN_SEP"', $1, cpos), '')"
-#else /* ...RENAME_MINIMAL_ONE_PASS */
-"WITH Lzn(nlz) AS (" /* Find minimum extraneous leading 0's for uniqueness */
-"  SELECT 0 AS nlz"
-"  UNION"
-"  SELECT nlz+1 AS nlz FROM Lzn"
-"  WHERE EXISTS("
-"   SELECT 1"
-"   FROM ColNames t, ColNames o"
-"   WHERE"
-"    iif(t.name IN (SELECT * FROM RepeatedNames),"
-"     printf('%s"AUTOCOLUMN_SEP"%s',"
-"      t.name, substring(printf('%.*c%0.*d',nlz+1,'0',$1,t.cpos),2)),"
-"     t.name"
-"    )"
-"    ="
-"    iif(o.name IN (SELECT * FROM RepeatedNames),"
-"     printf('%s"AUTOCOLUMN_SEP"%s',"
-"      o.name, substring(printf('%.*c%0.*d',nlz+1,'0',$1,o.cpos),2)),"
-"     o.name"
-"    )"
-"    COLLATE NOCASE"
-"    AND o.cpos<>t.cpos"
-"   GROUP BY t.cpos"
-"  )"
-") UPDATE Colnames AS t SET"
-" chop = 0," /* No chopping, never touch incoming names. */
-" suff = iif(name IN (SELECT * FROM RepeatedNames),"
-"  printf('"AUTOCOLUMN_SEP"%s', substring("
-"   printf('%.*c%0.*d',(SELECT max(nlz) FROM Lzn)+1,'0',1,t.cpos),2)),"
-"  ''"
-" )"
-#endif
-    ;
-  static const char * const zCollectVar = "\
-SELECT\
- '('||x'0a'\
- || group_concat(\
-  cname||' ANY',\
-  ','||iif((cpos-1)%4>0, ' ', x'0a'||' '))\
- ||')' AS ColsSpec \
-FROM (\
- SELECT cpos, printf('\"%w\"',printf('%!.*s%s', nlen-chop,name,suff)) AS cname \
- FROM ColNames ORDER BY cpos\
-)";
-  static const char * const zRenamesDone =
-    "SELECT group_concat("
-    " printf('\"%w\" to \"%w\"',name,printf('%!.*s%s', nlen-chop, name, suff)),"
-    " ','||x'0a')"
-    "FROM ColNames WHERE suff<>'' OR chop!=0"
-    ;
-  int rc;
-  sqlite3_stmt *pStmt = 0;
-  assert(pDb!=0);
-  if( zColNew ){
-    /* Add initial or additional column. Init db if necessary. */
-    if( *pDb==0 ){
-      if( SQLITE_OK!=sqlite3_open(zCOL_DB, pDb) ) return 0;
-#ifdef SHELL_COLFIX_DB
-      if(*zCOL_DB!=':')
-        sqlite3_exec(*pDb,"drop table if exists ColNames;"
-                     "drop view if exists RepeatedNames;",0,0,0);
-#endif
-#undef SHELL_COLFIX_DB
-      rc = sqlite3_exec(*pDb, zTabMake, 0, 0, 0);
-      rc_err_oom_die(rc);
-    }
-    assert(*pDb!=0);
-    rc = sqlite3_prepare_v2(*pDb, zTabFill, -1, &pStmt, 0);
-    rc_err_oom_die(rc);
-    rc = sqlite3_bind_text(pStmt, 1, zColNew, -1, 0);
-    rc_err_oom_die(rc);
-    rc = sqlite3_step(pStmt);
-    rc_err_oom_die(rc);
-    sqlite3_finalize(pStmt);
-    return 0;
-  }else if( *pDb==0 ){
-    return 0;
-  }else{
-    /* Formulate the columns spec, close the DB, zero *pDb. */
-    char *zColsSpec = 0;
-    int hasDupes = db_int(*pDb, "%s", zHasDupes);
-    int nDigits = (hasDupes)? db_int(*pDb, "%s", zColDigits) : 0;
-    if( hasDupes ){
-#ifdef SHELL_COLUMN_RENAME_CLEAN
-      rc = sqlite3_exec(*pDb, zDedoctor, 0, 0, 0);
-      rc_err_oom_die(rc);
-#endif
-      rc = sqlite3_exec(*pDb, zSetReps, 0, 0, 0);
-      rc_err_oom_die(rc);
-      rc = sqlite3_prepare_v2(*pDb, zRenameRank, -1, &pStmt, 0);
-      rc_err_oom_die(rc);
-      sqlite3_bind_int(pStmt, 1, nDigits);
-      rc = sqlite3_step(pStmt);
-      sqlite3_finalize(pStmt);
-      if( rc!=SQLITE_DONE ) rc_err_oom_die(SQLITE_NOMEM);
-    }
-    assert(db_int(*pDb, "%s", zHasDupes)==0); /* Consider: remove this */
-    rc = sqlite3_prepare_v2(*pDb, zCollectVar, -1, &pStmt, 0);
-    rc_err_oom_die(rc);
-    rc = sqlite3_step(pStmt);
-    if( rc==SQLITE_ROW ){
-      zColsSpec = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
-    }else{
-      zColsSpec = 0;
-    }
-    if( pzRenamed!=0 ){
-      if( !hasDupes ) *pzRenamed = 0;
-      else{
-        sqlite3_finalize(pStmt);
-        if( SQLITE_OK==sqlite3_prepare_v2(*pDb, zRenamesDone, -1, &pStmt, 0)
-            && SQLITE_ROW==sqlite3_step(pStmt) ){
-          *pzRenamed = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
-        }else
-          *pzRenamed = 0;
-      }
-    }
-    sqlite3_finalize(pStmt);
-    sqlite3_close(*pDb);
-    *pDb = 0;
-    return zColsSpec;
-  }
-}
-
-/*
-** Check if the sqlite_schema table contains one or more virtual tables. If
-** parameter zLike is not NULL, then it is an SQL expression that the
-** sqlite_schema row must also match. If one or more such rows are found,
-** print the following warning to the output:
-**
-** WARNING: Script requires that SQLITE_DBCONFIG_DEFENSIVE be disabled
-*/
-static int outputDumpWarning(ShellState *p, const char *zLike){
-  int rc = SQLITE_OK;
-  sqlite3_stmt *pStmt = 0;
-  shellPreparePrintf(p->db, &rc, &pStmt,
-    "SELECT 1 FROM sqlite_schema o WHERE "
-    "sql LIKE 'CREATE VIRTUAL TABLE%%' AND (%s)", zLike ? zLike : "true"
-  );
-  if( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
-    cli_puts("/* WARNING: "
-          "Script requires that SQLITE_DBCONFIG_DEFENSIVE be disabled */\n",
-          p->out
-    );
-  }
-  shellFinalize(&rc, pStmt);
-  return rc;
-}
-
-/*
-** Fault-Simulator state and logic.
-*/
-static struct {
-  int iId;           /* ID that triggers a simulated fault.  -1 means "any" */
-  int iErr;          /* The error code to return on a fault */
-  int iCnt;          /* Trigger the fault only if iCnt is already zero */
-  int iInterval;     /* Reset iCnt to this value after each fault */
-  int eVerbose;      /* When to print output */
-  int nHit;          /* Number of hits seen so far */
-  int nRepeat;       /* Turn off after this many hits.  0 for never */
-  int nSkip;         /* Skip this many before first fault */
-} faultsim_state = {-1, 0, 0, 0, 0, 0, 0, 0};
-
-/*
-** This is the fault-sim callback
-*/
-static int faultsim_callback(int iArg){
-  if( faultsim_state.iId>0 && faultsim_state.iId!=iArg ){
-    return SQLITE_OK;
-  }
-  if( faultsim_state.iCnt ){
-    if( faultsim_state.iCnt>0 ) faultsim_state.iCnt--;
-    if( faultsim_state.eVerbose>=2 ){
-      cli_printf(stdout, 
-         "FAULT-SIM id=%d no-fault (cnt=%d)\n", iArg, faultsim_state.iCnt);
-    }
-    return SQLITE_OK;
-  }
-  if( faultsim_state.eVerbose>=1 ){
-    cli_printf(stdout, 
-         "FAULT-SIM id=%d returns %d\n", iArg, faultsim_state.iErr);
-  }
-  faultsim_state.iCnt = faultsim_state.iInterval;
-  faultsim_state.nHit++;
-  if( faultsim_state.nRepeat>0 && faultsim_state.nRepeat<=faultsim_state.nHit ){
-    faultsim_state.iCnt = -1;
-  }
-  return faultsim_state.iErr;
-}
-
-/*
-** pickStr(zArg, &zErr, zS1, zS2, ..., "");
-**
-** Try to match zArg against zS1, zS2, and so forth until the first
-** emptry string.  Return the index of the match or -1 if none is found.
-** If no match is found, and &zErr is not NULL, then write into
-** zErr a message describing the valid choices.
-*/
-static int pickStr(const char *zArg, char **pzErr, ...){
-  int i, n;
-  const char *z;
-  sqlite3_str *pMsg;
-  va_list ap;
-  va_start(ap, pzErr);
-  i = 0;
-  while( (z = va_arg(ap,const char*))!=0 && z[0]!=0 ){
-    if( cli_strcmp(zArg, z)==0 ) return i;
-    i++;
-  }
-  va_end(ap);
-  if( pzErr==0 ) return -1;
-  n = i;
-  pMsg = sqlite3_str_new(0);
-  va_start(ap, pzErr);
-  sqlite3_str_appendall(pMsg, "should be");
-  i = 0;
-  while( (z = va_arg(ap, const char*))!=0 && z[0]!=0 ){
-    if( i==n-1 ){
-      sqlite3_str_append(pMsg,", or",4);
-    }else if( i>0 ){
-      sqlite3_str_append(pMsg, ",", 1);
-    }
-    sqlite3_str_appendf(pMsg, " %s", z);
-    i++;
-  }
-  va_end(ap);
-  *pzErr = sqlite3_str_finish(pMsg);
-  return -1;
-}
-
-/*
-** DOT-COMMAND: .import
-**
-** USAGE: .import [OPTIONS] FILE TABLE
-**
-** Import CSV or similar text from FILE into TABLE.  If TABLE does
-** not exist, it is created using the first row of FILE as the column
-** names.  If FILE begins with "|" then it is a command that is run
-** and the output from the command is used as the input data.  If
-** FILE begins with "<<" followed by a label, then content is read from
-** the script until the first line that matches the label.
-**
-** The content of FILE is interpreted using RFC-4180 ("CSV") quoting
-** rules unless the current mode is "ascii" or "tabs" or unless one
-** the --ascii option is used.
-**
-** The column and row separators must be single ASCII characters.  If
-** multiple characters or a Unicode character are specified for the
-** separators, then only the first byte of the separator is used.  Except,
-** if the row separator is \n and the mode is not --ascii, then \r\n is
-** understood as a row separator too.
-**
-** Options:
-**   --ascii         Do not use RFC-4180 quoting.  Use \037 and \036
-**                   as column and row separators on input, unless other
-**                   delimiters are specified using --colsep and/or --rowsep
-**   --colsep CHAR   Use CHAR as the column separator.
-**   --csv           Input is standard RFC-4180 CSV.
-**   --esc CHAR      Use CHAR as an escape character in unquoted CSV inputs.
-**   --qesc CHAR     Use CHAR as an escape character in quoted CSV inputs.
-**   --rowsep CHAR   Use CHAR as the row separator.
-**   --schema S      When creating TABLE, put it in schema S
-**   --skip N        Ignore the first N rows of input
-**   -v              Verbose mode
-*/
-static int dotCmdImport(ShellState *p){
-  int nArg = p->dot.nArg;     /* Number of arguments */
-  char **azArg = p->dot.azArg;/* Argument list */
-  char *zTable = 0;           /* Insert data into this table */
-  char *zSchema = 0;          /* Schema of zTable */
-  char *zFile = 0;            /* Name of file to extra content from */
-  sqlite3_stmt *pStmt = NULL; /* A statement */
-  int nCol;                   /* Number of columns in the table */
-  i64 nByte;                  /* Number of bytes in an SQL string */
-  int i, j;                   /* Loop counters */
-  int needCommit;             /* True to COMMIT or ROLLBACK at end */
-  char *zSql = 0;             /* An SQL statement */
-  ImportCtx sCtx;             /* Reader context */
-  char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
-  int eVerbose = 0;           /* Larger for more console output */
-  i64 nSkip = 0;              /* Initial lines to skip */
-  i64 iLineOffset = 0;        /* Offset to the first line of input */
-  char *zCreate = 0;          /* CREATE TABLE statement text */
-  int rc;                     /* Result code */
-
-  failIfSafeMode(p, "cannot run .import in safe mode");
-  memset(&sCtx, 0, sizeof(sCtx));
-  if( p->mode.eMode==MODE_Ascii ){
-    xRead = ascii_read_one_field;
-  }else{
-    xRead = csv_read_one_field;
-  }
-  for(i=1; imode.spec.zColumnSep && p->mode.spec.zColumnSep[0]!=0 ){
-      sCtx.cColSep = p->mode.spec.zColumnSep[0];
-    }else{
-      sCtx.cColSep = ',';
-    }
-  }
-  if( (sCtx.cColSep & 0x80)!=0 ){
-    eputz("Error: .import column separator must be ASCII\n");
-    return 1;
-  }
-  if( sCtx.cRowSep==0 ){
-    if( p->mode.spec.zRowSep && p->mode.spec.zRowSep[0]!=0 ){
-      sCtx.cRowSep = p->mode.spec.zRowSep[0];
-    }else{
-      sCtx.cRowSep = '\n';
-    }
-  }
-  if( sCtx.cRowSep=='\r' && xRead!=ascii_read_one_field ){
-    sCtx.cRowSep = '\n';
-  }
-  if( (sCtx.cRowSep & 0x80)!=0 ){
-    eputz("Error: .import row separator must be ASCII\n");
-    return 1;
-  }
-  sCtx.zFile = zFile;
-  sCtx.nLine = 1;
-  if( sCtx.zFile[0]=='|' ){
-#ifdef SQLITE_OMIT_POPEN
-    eputz("Error: pipes are not supported in this OS\n");
-    return 1;
-#else
-    sCtx.in = sqlite3_popen(sCtx.zFile+1, "r");
-    sCtx.zFile = "";
-    sCtx.xCloser = pclose;
-#endif
-  }else if( sCtx.zFile[0]=='<' && sCtx.zFile[1]=='<' && sCtx.zFile[2]!=0 ){
-    /* Input text comes from subsequent lines of script until the zFile
-    ** delimiter */
-    int nEndMark = strlen30(zFile)-2;
-    char *zEndMark = &zFile[2];
-    sqlite3_str *pContent = sqlite3_str_new(p->db);
-    int ckEnd = 1;
-    i64 iStart = p->lineno;
-    char zLine[2000];
-    sCtx.zFile = p->zInFile;
-    sCtx.nLine = p->lineno+1;
-    iLineOffset = p->lineno;
-    while( sqlite3_fgets(zLine,sizeof(zLine),p->in) ){
-      if( ckEnd && cli_strncmp(zLine,zEndMark,nEndMark)==0 ){
-        ckEnd = 2;
-        if( strchr(zLine,'\n') ) p->lineno++;
-        break;
-      }
-      if( strchr(zLine,'\n') ){
-        p->lineno++;
-        ckEnd = 1;
-      }else{
-        ckEnd = 0;
-      }
-      sqlite3_str_appendall(pContent, zLine);
-    }
-    sCtx.zIn = sqlite3_str_finish(pContent);
-    if( sCtx.zIn==0 ){
-      sCtx.zIn = sqlite3_mprintf("");
-    }
-    if( ckEnd<2 ){
-      i64 savedLn = p->lineno;
-      p->lineno = iStart;
-      dotCmdError(p, 0, 0,"Content terminator \"%s\" not found.",zEndMark);
-      p->lineno = savedLn;
-      import_cleanup(&sCtx);
-      return 1;
-    }
-  }else{
-    sCtx.in = sqlite3_fopen(sCtx.zFile, "rb");
-    sCtx.xCloser = fclose;
-  }
-  if( sCtx.in==0 && sCtx.zIn==0 ){
-    dotCmdError(p, 0, 0, "cannot open \"%s\"", zFile);
-    import_cleanup(&sCtx);
-    return 1;
-  }
-  if( eVerbose>=1 ){
-    char zSep[2];
-    zSep[1] = 0;
-    zSep[0] = sCtx.cColSep;
-    cli_puts("Column separator ", p->out);
-    output_c_string(p->out, zSep);
-    cli_puts(", row separator ", p->out);
-    zSep[0] = sCtx.cRowSep;
-    output_c_string(p->out, zSep);
-    cli_puts("\n", p->out);
-  }
-  sCtx.z = sqlite3_malloc64(120);
-  if( sCtx.z==0 ){
-    import_cleanup(&sCtx);
-    shell_out_of_memory();
-  }
-  /* Below, resources must be freed before exit. */
-  while( nSkip>0 ){
-    nSkip--;
-    while( xRead(&sCtx) && sCtx.cTerm==sCtx.cColSep ){}
-  }
-  import_append_char(&sCtx, 0);    /* To ensure sCtx.z is allocated */
-  if( sqlite3_table_column_metadata(p->db, zSchema, zTable,0,0,0,0,0,0) 
-   && 0==db_int(p->db, "SELECT count(*) FROM \"%w\".sqlite_schema"
-                       " WHERE name=%Q AND type='view'",
-                       zSchema ? zSchema : "main", zTable)
-  ){
-    /* Table does not exist.  Create it. */
-    sqlite3 *dbCols = 0;
-    char *zRenames = 0;
-    char *zColDefs;
-    zCreate = sqlite3_mprintf("CREATE TABLE \"%w\".\"%w\"", 
-                  zSchema ? zSchema : "main", zTable);
-    while( xRead(&sCtx) ){
-      zAutoColumn(sCtx.z, &dbCols, 0);
-      if( sCtx.cTerm!=sCtx.cColSep ) break;
-    }
-    zColDefs = zAutoColumn(0, &dbCols, &zRenames);
-    if( zRenames!=0 ){
-      cli_printf((stdin_is_interactive && p->in==stdin)? p->out : stderr,
-            "Columns renamed during .import %s due to duplicates:\n"
-            "%s\n", sCtx.zFile, zRenames);
-      sqlite3_free(zRenames);
-    }
-    assert(dbCols==0);
-    if( zColDefs==0 ){
-      cli_printf(stderr,"%s: empty file\n", sCtx.zFile);
-      import_cleanup(&sCtx);
-      sqlite3_free(zCreate);
-      return 1;
-    }
-    zCreate = sqlite3_mprintf("%z%z\n", zCreate, zColDefs);
-    if( zCreate==0 ){
-      import_cleanup(&sCtx);
-      shell_out_of_memory();
-    }
-    if( eVerbose>=1 ){
-      cli_printf(p->out, "%s\n", zCreate);
-    }
-    rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
-    if( rc ){
-      cli_printf(stderr,
-           "%s failed:\n%s\n", zCreate, sqlite3_errmsg(p->db));
-    }
-    sqlite3_free(zCreate);
-    zCreate = 0;
-    if( rc ){
-      import_cleanup(&sCtx);
-      return 1;
-    }
-  }
-  zSql = sqlite3_mprintf("SELECT count(*) FROM pragma_table_info(%Q,%Q);",
-                         zTable, zSchema);
-  if( zSql==0 ){
-    import_cleanup(&sCtx);
-    shell_out_of_memory();
-  }
-  rc =  sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-  sqlite3_free(zSql);
-  zSql = 0;
-  if( rc ){
-    if (pStmt) sqlite3_finalize(pStmt);
-    shellDatabaseError(p->db);
-    import_cleanup(&sCtx);
-    return 1;
-  }
-  if( sqlite3_step(pStmt)==SQLITE_ROW ){
-    nCol = sqlite3_column_int(pStmt, 0);
-  }else{
-    nCol = 0;
-  }
-  sqlite3_finalize(pStmt);
-  pStmt = 0;
-  if( nCol==0 ) return 0; /* no columns, no error */
-
-  nByte = 64                 /* space for "INSERT INTO", "VALUES(", ")\0" */
-        + (zSchema ? strlen(zSchema)*2 + 2: 0)  /* Quoted schema name */
-        + strlen(zTable)*2 + 2                  /* Quoted table name */
-        + nCol*2;            /* Space for ",?" for each column */
-  zSql = sqlite3_malloc64( nByte );
-  if( zSql==0 ){
-    import_cleanup(&sCtx);
-    shell_out_of_memory();
-  }
-  if( zSchema ){
-    sqlite3_snprintf(nByte, zSql, "INSERT INTO \"%w\".\"%w\" VALUES(?", 
-                     zSchema, zTable);
-  }else{
-    sqlite3_snprintf(nByte, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
-  }
-  j = strlen30(zSql);
-  for(i=1; i=2 ){
-    cli_printf(p->out, "Insert using: %s\n", zSql);
-  }
-  rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-  sqlite3_free(zSql);
-  zSql = 0;
-  if( rc ){
-    shellDatabaseError(p->db);
-    if (pStmt) sqlite3_finalize(pStmt);
-    import_cleanup(&sCtx);
-    return 1;
-  }
-  needCommit = sqlite3_get_autocommit(p->db);
-  if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
-  do{
-    int startLine = sCtx.nLine;
-    for(i=0; imode.eMode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
-      /*
-      ** For CSV mode, per RFC 4180, accept EOF in lieu of final
-      ** record terminator but only for last field of multi-field row.
-      ** (If there are too few fields, it's not valid CSV anyway.)
-      */
-      if( z==0 && (xRead==csv_read_one_field) && i==nCol-1 && i>0 ){
-        z = "";
-      }
-      sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
-      if( i=nCol ){
-      sqlite3_step(pStmt);
-      rc = sqlite3_reset(pStmt);
-      if( rc!=SQLITE_OK ){
-        cli_printf(stderr,"%s:%d: INSERT failed: %s\n",
-              sCtx.zFile, startLine, sqlite3_errmsg(p->db));
-        sCtx.nErr++;
-        if( bail_on_error ) break;
-      }else{
-        sCtx.nRow++;
-      }
-    }
-  }while( sCtx.cTerm!=EOF );
-
-  import_cleanup(&sCtx);
-  sqlite3_finalize(pStmt);
-  if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
-  if( eVerbose>0 ){
-    cli_printf(p->out,
-          "Added %d rows with %d errors using %d lines of input\n",
-          sCtx.nRow, sCtx.nErr, sCtx.nLine-1-iLineOffset);
-  }
-  return sCtx.nErr ? 1 : 0;
-}
-
-
-/*
-** This function computes what to show the user about the configured
-** titles (or column-names).  Output is an integer between 0 and 3:
-**
-**    0:     The titles do not matter.  Never show anything.
-**    1:     Show  "--titles off"
-**    2:     Show  "--titles on"
-**    3:     Show  "--title VALUE"  where VALUE is an encoding method
-**             to use, one of: plain sql csv html tcl json
-**
-** Inputs are:
-**
-**    spec.bTitles   (bT)     Whether or not to show the titles
-**    spec.eTitle    (eT)     The actual encoding to be used for titles
-**    ModeInfo.bHdr  (bH)     Default value for spec.bTitles
-**    ModeInfo.eHdr  (eH)     Default value for spec.eTitle
-**    bAll                    Whether the -v option is used
-*/
-static int modeTitleDsply(ShellState *p, int bAll){
-  int eMode = p->mode.eMode;
-  const ModeInfo *pI = &aModeInfo[eMode];
-  int bT = p->mode.spec.bTitles;
-  int eT = p->mode.spec.eTitle;
-  int bH = pI->bHdr;
-  int eH = pI->eHdr;
-
-  /* Variable "v" is the truth table that will determine the answer
-  **
-  **                   Actual encoding is different from default 
-  **                            vvvvvvvv                                    */
-  sqlite3_uint64 v = UINT64_C(0x0133013311220102);
-  /*                            ^^^^    ^^^^
-  **                   Upper 2-byte groups for when ON/OFF disagrees with
-  **                   the default.                                         */
-
-  if( bH==0 ) return 0;  /* Header not appliable.  Ex: off, count */
-
-  if( eT==0 ) eT = eH;   /* Fill in missing spec.eTitle */
-  if( bT==0 ) bT = bH;   /* Fill in missing spec.bTitles */
-
-  if( eT!=eH ) v >>= 32; /* Encoding disagree in upper 4-bytes */
-  if( bT!=bH ) v >>= 16; /* ON/OFF disagree in upper 2-byte pairs */
-  if( bT<2 ) v >>= 8;    /* ON in even bytes, OFF in odd bytes (1st byte 0) */
-  if( !bAll ) v >>= 4;   /* bAll values are in the lower half-byte */
-
-  return v & 3;          /* Return the selected truth-table entry */
-}
-
-/*
-** DOT-COMMAND:  .mode
-**
-** USAGE: .mode [MODE] [OPTIONS]
-**
-** Change the output mode to MODE and/or apply OPTIONS to the output mode.
-** Arguments are processed from left to right.  If no arguments, show the
-** current output mode and relevant options.
-**
-** Options:
-**   --align STRING           Set the alignment of text in columnar modes
-**                            String consists of characters 'L', 'C', 'R'
-**                            meaning "left", "centered", and "right", with
-**                            one letter per column starting from the left.
-**                            Unspecified alignment defaults to 'L'.
-**   --blob-quote ARG         ARG can be "auto", "text", "sql", "hex", "tcl",
-**                            "json", or "size".  Default is "auto".
-**   --border on|off          Show outer border on "box" and "table" modes.
-**   --charlimit N            Set the maximum number of output characters to
-**                            show for any single SQL value to N. Longer values
-**                            truncated. Zero means "no limit".
-**   --colsep STRING          Use STRING as the column separator
-**   --escape ESC             Enable/disable escaping of control characters
-**                            found in the output. ESC can be "off", "ascii",
-**                            or "symbol".
-**   --linelimit N            Set the maximum number of output lines to show for
-**                            any single SQL value to N. Longer values are
-**                            truncated. Zero means "no limit". Only works
-**                            in "line" mode and in columnar modes.
-**   --limits L,C,T           Shorthand for "--linelimit L --charlimit C
-**                            --titlelimit T". The ",T" can be omitted in which
-**                            case the --titlelimit is unchanged.  The argument
-**                            can also be "off" to mean "0,0,0" or "on" to
-**                            mean "5,300,20".
-**   --list                   List available modes
-**   --multiinsert N          In "insert" mode, put multiple rows on a single
-**                            INSERT statement until the size exceeds N bytes.
-**   --null STRING            Render SQL NULL values as the given string
-**   --once                   Setting changes to the right are reverted after
-**                            the next SQL command.
-**   --quote ARG              Enable/disable quoting of text. ARG can be
-**                            "off", "on", "sql", "relaxed", "csv", "html",
-**                            "tcl", or "json". "off" means show the text as-is.
-**                            "on" is an alias for "sql".
-**   --reset                  Changes all mode settings back to their default.
-**   --rowsep STRING          Use STRING as the row separator
-**   --sw|--screenwidth N     Declare the screen width of the output device
-**                            to be N characters.  An attempt may be made to
-**                            wrap output text to fit within this limit. Zero
-**                            means "no limit".  Or N can be "auto" to set the
-**                            width automatically.
-**   --tablename NAME         Set the name of the table for "insert" mode.
-**   --tag NAME               Save mode to the left as NAME.
-**   --textjsonb BOOLEAN      If enabled, JSONB text is displayed as text JSON.
-**   --title ARG              Whether or not to show column headers, and if so
-**                            how to encode them.  ARG can be "off", "on",
-**                            "sql", "csv", "html", "tcl", or "json".
-**   --titlelimit N           Limit the length of column titles to N characters.
-**   -v|--verbose             Verbose output
-**   --widths LIST            Set the columns widths for columnar modes. The
-**                            argument is a list of integers, one for each
-**                            column. A "0" width means use a dynamic width
-**                            based on the actual width of data. If there are
-**                            fewer entries in LIST than columns, "0" is used
-**                            for the unspecified widths.
-**   --wordwrap BOOLEAN       Enable/disable word wrapping
-**   --wrap N                 Wrap columns wider than N characters
-**   --ww                     Shorthand for "--wordwrap on"
-*/
-static int dotCmdMode(ShellState *p){
-  int nArg = p->dot.nArg;     /* Number of arguments */
-  char **azArg = p->dot.azArg;/* Argument list */
-  int eMode = -1;             /* New mode value, or -1 for none */
-  int iMode = -1;             /* Index of the argument that is the mode name */
-  int i;                      /* Loop counter */
-  int k;                      /* Misc index variable */
-  int chng = 0;               /* True if anything has changed */
-  int bAll = 0;               /* Show all details of the mode */
-
-  for(i=1; i=0
-     && eMode!=MODE_Www
-    ){
-      iMode = i;
-      modeChange(p, eMode);
-      /* (Legacy) If the mode is MODE_Insert and the next argument
-      ** is not an option, then the next argument must be the table
-      ** name.
-      */
-      if( i+1mode.spec.zTableName, azArg[i]);
-      }
-      chng = 1;
-    }else if( optionMatch(z,"align") ){
-      char *zAlign;
-      int nAlign;
-      int nErr = 0;
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      i++;
-      zAlign = azArg[i];
-      nAlign = 0x3fff & strlen(zAlign);
-      free(p->mode.spec.aAlign);
-      p->mode.spec.aAlign = malloc(nAlign);
-      shell_check_oom(p->mode.spec.aAlign);
-      for(k=0; kmode.spec.aAlign[k] = c;
-      }
-      p->mode.spec.nAlign = nAlign;
-      chng = 1;
-      if( nErr ){
-        dotCmdError(p, i, "bad alignment string",
-             "Should contain only characters L, C, and R.");
-        return 1;
-      }
-    }else if( pickStr(z,0,"-blob","-blob-quote","")>=0 ){
-      if( (++i)>=nArg ){
-        dotCmdError(p, i-1, "missing argument", 0);
-        return 1;
-      }
-      k = pickStr(azArg[i], 0,
-                    "auto", "text", "sql", "hex", "tcl", "json", "size", "");
-        /*           0       1       2      3      4      5       6
-        ** Must match QRF_BLOB_xxxx values.  See also tag-20251124a */
-      if( k>=0 ){
-        p->mode.spec.eBlob = k & 0xff;
-      }
-      chng = 1;
-    }else if( optionMatch(z,"border") ){
-      if( (++i)>=nArg ){
-        dotCmdError(p, i-1, "missing argument", 0);
-        return 1;
-      }
-      k = pickStr(azArg[i], 0, "auto", "off", "on", "");
-      if( k>=0 ){
-        p->mode.spec.bBorder = k & 0x3;
-      }
-      chng = 1;
-    }else if( 0<=(k=pickStr(z,0,
-                  "-charlimit","-linelimit","-titlelimit","-multiinsert","")) ){
-      int w;   /*  0            1            2             3 */
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      w = integerValue(azArg[++i]);
-      switch( k ){
-        case 0:   p->mode.spec.nCharLimit = w;    break;
-        case 1:   p->mode.spec.nLineLimit = w;    break;
-        case 2:   p->mode.spec.nTitleLimit = w;   break;
-        default:  p->mode.spec.nMultiInsert = w;  break;
-      }
-      chng = 1;
-    }else if( 0<=(k=pickStr(z,0,"-tablename","-rowsep","-colsep","-null","")) ){
-                            /*   0            1         2         3 */
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      i++;
-      switch( k ){
-        case 0: modeSetStr(&p->mode.spec.zTableName, azArg[i]); break;
-        case 1: modeSetStr(&p->mode.spec.zRowSep, azArg[i]);    break;
-        case 2: modeSetStr(&p->mode.spec.zColumnSep, azArg[i]); break;
-        case 3: modeSetStr(&p->mode.spec.zNull, azArg[i]);      break;
-      }
-      chng = 1;
-    }else if( optionMatch(z,"escape") ){
-      /* See similar code at tag-20250224-1 */
-      char *zErr = 0;
-      if( (++i)>=nArg ){
-        dotCmdError(p, i-1, "missing argument", 0);
-        return 1;
-      }                       /*  0     1       2  <-- One less than QRF_ESC_ */
-      k = pickStr(azArg[i],&zErr,"off","ascii","symbol","");
-      if( k<0 ){
-        dotCmdError(p, i, "unknown escape type", "%s", zErr);
-        sqlite3_free(zErr);
-        return 1;
-      }
-      p->mode.spec.eEsc = k+1;
-      chng = 1;
-    }else if( optionMatch(z,"limits") ){
-      if( (++i)>=nArg ){
-        dotCmdError(p, i-1, "missing argument", 0);
-        return 1;
-      }
-      k = pickStr(azArg[i],0,"on","off","");
-      if( k==0 ){
-        p->mode.spec.nLineLimit = DFLT_LINE_LIMIT;
-        p->mode.spec.nCharLimit = DFLT_CHAR_LIMIT;
-        p->mode.spec.nTitleLimit = DFLT_TITLE_LIMIT;
-      }else if( k==1 ){
-        p->mode.spec.nLineLimit = 0;
-        p->mode.spec.nCharLimit = 0;
-        p->mode.spec.nTitleLimit = 0;
-      }else{
-        int L, C, T = 0;
-        int nNum = sscanf(azArg[i], "%d,%d,%d", &L, &C, &T);
-        if( nNum<2 || L<0 || C<0 || T<0){
-          dotCmdError(p, i, "bad argument", "Should be \"L,C,T\" where L, C"
-                            " and T are unsigned integers");
-          return 1;
-        }        
-        p->mode.spec.nLineLimit = L;
-        p->mode.spec.nCharLimit = C;
-        if( nNum==3 ) p->mode.spec.nTitleLimit = T;
-      }
-      chng = 1;
-    }else if( optionMatch(z,"list") ){
-      int ii;
-      cli_puts("available modes:", p->out);
-      for(ii=0; iiout, " %s", aModeInfo[ii].zName);
-      }
-      for(ii=0; iinSavedModes; ii++){
-        cli_printf(p->out, " %s", p->aSavedModes[ii].zTag);
-      }
-      cli_puts(" batch tty\n", p->out);
-      chng = 1;  /* Not really a change, but we still want to suppress the
-                 ** "current mode" output */
-    }else if( optionMatch(z,"once") ){
-      p->nPopMode = 0;
-      modePush(p);
-      p->nPopMode = 1;
-    }else if( optionMatch(z,"noquote") ){
-      /* (undocumented legacy) --noquote always turns quoting off */
-      p->mode.spec.eText = QRF_TEXT_Plain;
-      p->mode.spec.eBlob = QRF_BLOB_Auto;
-      chng = 1;
-    }else if( optionMatch(z,"quote") ){
-      if( i+10 || strcmp(azArg[i+1],"off")==0 || modeFind(p, azArg[i+1])<0)
-      ){
-        /* --quote is followed by an argument other that is not an option
-        ** or a mode name.  See it must be a boolean or a keyword to describe
-        ** how to set quoting. */
-        i++;
-        if( (k = pickStr(azArg[i],0,"no","yes","0","1",""))>=0 ){
-          k &= 1;   /* 0 for "off".  1 for "on". */
-        }else{
-          char *zErr = 0;
-          k = pickStr(azArg[i],&zErr,
-                 "off","on","sql","csv","html","tcl","json","relaxed","");
-              /*  0     1    2     3     4      5     6      7   */
-          if( k<0 ){
-            dotCmdError(p, i, "unknown", "%z", zErr);
-            return 1;
-          }
-        }
-      }else{
-        /* (Legacy) no following boolean argument.  Turn quoting on */ 
-        k = 1;
-      }
-      switch( k ){
-        case 1:  /* on */
-          modeSetStr(&p->mode.spec.zNull, "NULL");
-          /* Fall through */
-        case 2:  /* sql */
-          p->mode.spec.eText = QRF_TEXT_Sql;
-          break;
-        case 3:  /* csv */
-          p->mode.spec.eText = QRF_TEXT_Csv;
-          break;
-        case 4:  /* html */
-          p->mode.spec.eText = QRF_TEXT_Html;
-          break;
-        case 5:  /* tcl */
-          p->mode.spec.eText = QRF_TEXT_Tcl;
-          break;
-        case 6:  /* json */
-          p->mode.spec.eText = QRF_TEXT_Json;
-          break;
-        case 7:  /* relaxed */
-          p->mode.spec.eText = QRF_TEXT_Relaxed;
-          break;
-        default: /* off */
-          p->mode.spec.eText = QRF_TEXT_Plain;
-          break;
-      }
-      chng = 1;
-    }else if( optionMatch(z,"reset") ){
-      int saved_eMode = p->mode.eMode;
-      modeFree(&p->mode);
-      modeChange(p, saved_eMode);
-    }else if( optionMatch(z,"screenwidth") || optionMatch(z,"sw") ){
-      if( (++i)>=nArg ){
-        dotCmdError(p, i-1, "missing argument", 0);
-        return 1;
-      }
-      k = pickStr(azArg[i],0,"off","auto","");
-      if( k==0 ){
-        p->mode.bAutoScreenWidth = 0;
-        p->mode.spec.nScreenWidth = 0;
-      }else if( k==1 ){
-        p->mode.bAutoScreenWidth = 1;
-      }else{
-        i64 w = integerValue(azArg[i]);
-        p->mode.bAutoScreenWidth = 0;
-        if( w<0 ) w = 0;
-        if( w>QRF_MAX_WIDTH ) w = QRF_MAX_WIDTH;
-        p->mode.spec.nScreenWidth = w;
-      }
-      chng = 1;
-    }else if( optionMatch(z,"tag") ){
-      size_t nByte;
-      int n;
-      const char *zTag;
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      zTag = azArg[++i];
-      if( modeFind(p, zTag)>=0 ){
-        dotCmdError(p, i, "mode already exists", 0);
-        return 1;
-      }
-      if( p->nSavedModes > MODE_N_USER ){
-        dotCmdError(p, i-1, "cannot add more modes", 0);
-        return 1;
-      }
-      n = p->nSavedModes++;
-      nByte = sizeof(p->aSavedModes[0]);
-      nByte *= n+1;
-      p->aSavedModes = realloc( p->aSavedModes, nByte );
-      shell_check_oom(p->aSavedModes);
-      p->aSavedModes[n].zTag = strdup(zTag);
-      shell_check_oom(p->aSavedModes[n].zTag);
-      modeDup(&p->aSavedModes[n].mode, &p->mode);
-      chng = 1;
-    }else if( optionMatch(z,"textjsonb") ){
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      p->mode.spec.bTextJsonb = booleanValue(azArg[++i]) ? QRF_Yes : QRF_No;
-      chng = 1;
-    }else if( optionMatch(z,"titles") || optionMatch(z,"title") ){
-      char *zErr = 0;
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      k = pickStr(azArg[++i],&zErr,
-              "off","on","plain","sql","csv","html","tcl","json","");
-          /*   0     1    2       3     4     5     6      7 */
-      if( k<0 ){
-        dotCmdError(p, i, "bad --titles value","%z", zErr);
-        return 1;
-      }
-      p->mode.spec.bTitles = k>=1 ? QRF_Yes : QRF_No;
-      p->mode.mFlags &= ~MFLG_HDR;
-      p->mode.spec.eTitle = k>1 ? k-1 : aModeInfo[p->mode.eMode].eHdr;
-      chng = 1;
-    }else if( optionMatch(z,"widths") || optionMatch(z,"width") ){
-      int nWidth = 0;
-      short int *aWidth;
-      const char *zW;
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      zW = azArg[++i];
-      /* Every width value takes at least 2 bytes in the input string to
-      ** specify, so strlen(zW) bytes should be plenty of space to hold the
-      ** result. */
-      aWidth = malloc( strlen(zW) );
-      while( IsSpace(zW[0]) ) zW++;
-      while( zW[0] ){
-        int w = 0;
-        int nDigit = 0;
-        k = zW[0]=='-' && IsDigit(zW[1]);
-        while( IsDigit(zW[k]) ){
-          w = w*10 + zW[k] - '0';
-          if( w>QRF_MAX_WIDTH ){
-            dotCmdError(p,i+1,"width too big",
-                        "Maximum column width is %d", QRF_MAX_WIDTH);
-            free(aWidth);
-            return 1;
-          }
-          nDigit++;
-          k++;
-        }
-        if( nDigit==0 ){
-          dotCmdError(p,i+1,"syntax error",
-                      "should be a comma-separated list if integers");
-          free(aWidth);
-          return 1;
-        }
-        if( zW[0]=='-' ) w = -w;
-        aWidth[nWidth++] = w;
-        zW += k;
-        if( zW[0]==',' ) zW++;
-        while( IsSpace(zW[0]) ) zW++;
-      }
-      free(p->mode.spec.aWidth);
-      p->mode.spec.aWidth = aWidth;
-      p->mode.spec.nWidth = nWidth;
-      chng = 1;
-    }else if( optionMatch(z,"wrap") ){
-      int w;
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      w = integerValue(azArg[++i]);
-      if( w<(-QRF_MAX_WIDTH) ) w = -QRF_MAX_WIDTH;
-      if( w>QRF_MAX_WIDTH ) w = QRF_MAX_WIDTH;
-      p->mode.spec.nWrap = w;
-      chng = 1;
-    }else if( optionMatch(z,"ww") ){
-      p->mode.spec.bWordWrap = QRF_Yes;
-      chng = 1;
-    }else if( optionMatch(z,"wordwrap") ){
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      p->mode.spec.bWordWrap = (u8)booleanValue(azArg[++i]) ? QRF_Yes : QRF_No;
-      chng = 1;
-    }else if( optionMatch(z,"v") || optionMatch(z,"verbose") ){
-      bAll = 1;
-    }else if( z[0]=='-' ){
-      dotCmdError(p, i, "bad option", "Use \".help .mode\" for more info");
-      return 1;
-    }else{
-      dotCmdError(p, i, iMode>0?"bad argument":"unknown mode",
-                  "Use \".help .mode\" for more info");
-      return 1;
-    }
-  }
-  if( !chng || bAll ){
-    const ModeInfo *pI = aModeInfo + p->mode.eMode;
-    sqlite3_str *pDesc = sqlite3_str_new(p->db);
-    char *zDesc;
-    const char *zSetting;
-
-    if( p->nPopMode ) sqlite3_str_appendall(pDesc, "--once ");
-    sqlite3_str_appendall(pDesc,pI->zName);
-    if( bAll || (p->mode.spec.nAlign && pI->eCx==2) ){
-      int ii;
-      sqlite3_str_appendall(pDesc, " --align \"");
-      for(ii=0; iimode.spec.nAlign; ii++){
-        unsigned char a = p->mode.spec.aAlign[ii];
-        sqlite3_str_appendchar(pDesc, 1, "LLCR"[a&3]);
-      }
-      sqlite3_str_append(pDesc, "\"", 1);
-    }
-    if( bAll
-     || (p->mode.spec.bBorder==QRF_No) != ((pI->mFlg&1)!=0)
-    ){
-      sqlite3_str_appendf(pDesc," --border %s",
-             p->mode.spec.bBorder==QRF_No ? "off" : "on");
-    }
-    if( bAll || p->mode.spec.eBlob!=QRF_BLOB_Auto ){
-      const char *azBQuote[] =
-           { "auto", "text", "sql", "hex", "tcl", "json", "size" };
-      /*      0       1       2      3      4      5       6
-      ** Must match QRF_BLOB_xxxx values.  See all instances of tag-20251124a */
-      u8 e = p->mode.spec.eBlob;
-      sqlite3_str_appendf(pDesc, " --blob-quote %s", azBQuote[e]);
-    }
-    zSetting = aModeStr[pI->eCSep];
-    if( bAll || (zSetting && cli_strcmp(zSetting,p->mode.spec.zColumnSep)!=0) ){
-      sqlite3_str_appendf(pDesc, " --colsep ");
-      append_c_string(pDesc, p->mode.spec.zColumnSep);
-    }
-    if( bAll || p->mode.spec.eEsc!=QRF_Auto ){
-      sqlite3_str_appendf(pDesc, " --escape %s",qrfEscNames[p->mode.spec.eEsc]);
-    }
-    if( bAll
-     || (p->mode.spec.nLineLimit>0 && pI->eCx>0)
-     || p->mode.spec.nCharLimit>0
-     || (p->mode.spec.nTitleLimit>0 && pI->eCx>0)
-    ){
-      if( p->mode.spec.nLineLimit==0
-       && p->mode.spec.nCharLimit==0
-       && p->mode.spec.nTitleLimit==0
-      ){
-        sqlite3_str_appendf(pDesc, " --limits off");
-      }else if( p->mode.spec.nLineLimit==DFLT_LINE_LIMIT
-       && p->mode.spec.nCharLimit==DFLT_CHAR_LIMIT
-       && p->mode.spec.nTitleLimit==DFLT_TITLE_LIMIT
-      ){
-        sqlite3_str_appendf(pDesc, " --limits on");
-      }else{
-        sqlite3_str_appendf(pDesc, " --limits %d,%d,%d",
-           p->mode.spec.nLineLimit, p->mode.spec.nCharLimit,
-           p->mode.spec.nTitleLimit);
-      }
-    }
-    if( bAll
-     || (p->mode.spec.nMultiInsert && p->mode.spec.eStyle==QRF_STYLE_Insert)
-    ){
-      sqlite3_str_appendf(pDesc, " --multiinsert %u",
-                          p->mode.spec.nMultiInsert);
-    }
-    zSetting = aModeStr[pI->eNull];
-    if( bAll || (zSetting && cli_strcmp(zSetting,p->mode.spec.zNull)!=0) ){
-      sqlite3_str_appendf(pDesc, " --null ");
-      append_c_string(pDesc, p->mode.spec.zNull);
-    }
-    if( bAll 
-     || (pI->eText!=p->mode.spec.eText && (pI->eText>1 || p->mode.spec.eText>1))
-    ){
-      sqlite3_str_appendf(pDesc," --quote %s",qrfQuoteNames[p->mode.spec.eText]);
-    }
-    zSetting = aModeStr[pI->eRSep];
-    if( bAll || (zSetting && cli_strcmp(zSetting,p->mode.spec.zRowSep)!=0) ){
-      sqlite3_str_appendf(pDesc, " --rowsep ");
-      append_c_string(pDesc, p->mode.spec.zRowSep);
-    }
-    if( bAll
-     || (pI->eCx && (p->mode.spec.nScreenWidth>0 || p->mode.bAutoScreenWidth))
-    ){
-      if( p->mode.bAutoScreenWidth ){
-        sqlite3_str_appendall(pDesc, " --sw auto");
-      }else{
-        sqlite3_str_appendf(pDesc," --sw %d",
-                            p->mode.spec.nScreenWidth);
-      }
-    }
-    if( bAll || p->mode.eMode==MODE_Insert ){
-      sqlite3_str_appendf(pDesc," --tablename ");
-      append_c_string(pDesc, p->mode.spec.zTableName);
-    }
-    if( bAll || p->mode.spec.bTextJsonb ){
-      sqlite3_str_appendf(pDesc," --textjsonb %s",
-             p->mode.spec.bTextJsonb==QRF_Yes ? "on" : "off");
-    }
-    k = modeTitleDsply(p, bAll);
-    if( k==1 ){
-      sqlite3_str_appendall(pDesc, " --titles off");
-    }else if( k==2 ){
-      sqlite3_str_appendall(pDesc, " --titles on");
-    }else if( k==3 ){
-      static const char *azTitle[] =
-          { "plain", "sql", "csv", "html", "tcl", "json"};
-      sqlite3_str_appendf(pDesc, " --titles %s",
-                   azTitle[p->mode.spec.eTitle-1]);
-    }    
-    if( p->mode.spec.nWidth>0 && (bAll || pI->eCx==2) ){
-      int ii;
-      const char *zSep = " --widths ";
-      for(ii=0; iimode.spec.nWidth; ii++){
-        sqlite3_str_appendf(pDesc, "%s%d", zSep, (int)p->mode.spec.aWidth[ii]);
-        zSep = ",";
-      }
-    }else if( bAll ){
-      sqlite3_str_appendall(pDesc, " --widths \"\"");
-    }
-    if( bAll || (pI->eCx>0 && p->mode.spec.bWordWrap) ){
-      if( bAll ){
-        sqlite3_str_appendf(pDesc, " --wordwrap %s",
-          p->mode.spec.bWordWrap==QRF_Yes ? "on" : "off");
-      }
-      if( p->mode.spec.nWrap ){
-        sqlite3_str_appendf(pDesc, " --wrap %d", p->mode.spec.nWrap);
-      }
-      if( !bAll ) sqlite3_str_append(pDesc, " --ww", 5);
-    }
-    zDesc = sqlite3_str_finish(pDesc);
-    cli_printf(p->out, ".mode %s\n", zDesc);
-    fflush(p->out);
-    sqlite3_free(zDesc);
-  }
-  return 0;
-}
-
-/*
-** DOT-COMMAND: .output
-** USAGE: .output [OPTIONS] [FILE]
-**
-** Begin redirecting output to FILE.  Or if FILE is omitted, revert
-** to sending output to the console.  If FILE begins with "|" then
-** the remainder of file is taken as a pipe and output is directed
-** into that pipe.  If FILE is "memory" then output is captured in an
-** internal memory buffer.  If FILE is "off" then output is redirected
-** into /dev/null or the equivalent.
-**
-** Options:
-**   --bom             Prepend a byte-order mark to the output
-**   -e                Accumulate output in a temporary text file then
-**                     launch a text editor when the redirection ends.
-**   --error-prefix X  Use X as the left-margin prefix for error messages.
-**                     Set to an empty string to restore the default.
-**   --keep            Keep redirecting output to its current destination.
-**                     Use this option in combination with --show or
-**                     with --error-prefix when you do not want to stop
-**                     a current redirection.
-**   --plain           Use plain text rather than HTML tables with -w
-**   --show            Show output text captured by .testcase or by
-**                     redirecting to "memory".
-**   -w                Show the output in a web browser.  Output is
-**                     written into a temporary HTML file until the
-**                     redirect ends, then the web browser is launched.
-**                     Query results  are shown as HTML tables, unless
-**                     the --plain is used too.
-**   -x                Show the output in a spreadsheet.  Output is
-**                     written to a temp file as CSV then the spreadsheet
-**                     is launched when
-**
-** DOT-COMMAND: .once
-** USAGE: .once [OPTIONS] FILE ...
-**
-** Write the output for the next line of SQL or the next dot-command into
-** FILE.  If FILE begins with "|" then it is a program into which output
-** is written. The FILE argument should be omitted if one of the -e, -w,
-** or -x options is used.
-**
-** Options:
-**   -e                Capture output into a temporary file then bring up
-**                     a text editor on that temporary file.
-**   --plain           Use plain text rather than HTML tables with -w
-**   -w                Capture output into an HTML file then bring up that
-**                     file in a web browser
-**   -x                Show the output in a spreadsheet.  Output is
-**                     written to a temp file as CSV then the spreadsheet
-**                     is launched when
-**
-** DOT-COMMAND: .excel
-** Shorthand for ".once -x"
-**
-** DOT-COMMAND: .www [--plain]
-** Shorthand for ".once -w" or ".once --plain -w"
-*/
-static int dotCmdOutput(ShellState *p){
-  int nArg = p->dot.nArg;        /* Number of arguments */
-  char **azArg = p->dot.azArg;   /* Text of the arguments */
-  char *zFile = 0;               /* The FILE argument */
-  int i;                  /* Loop counter */
-  int eMode = 0;          /* 0: .outout/.once, 'x'=.excel, 'w'=.www */
-  int bOnce = 0;          /* 0: .output, 1: .once, 2: .excel/.www */
-  int bPlain = 0;         /* --plain option */
-  int bKeep = 0;          /* Keep redirecting */
-  static const char *zBomUtf8 = "\357\273\277";
-  const char *zBom = 0;
-  char c = azArg[0][0];
-  int n = strlen30(azArg[0]);
-
-  failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
-  if( c=='e' ){
-    eMode = 'x';
-    bOnce = 2;
-  }else if( c=='w' ){
-    eMode = 'w';
-    bOnce = 2;
-  }else if( n>=2 && cli_strncmp(azArg[0],"once",n)==0 ){
-    bOnce = 1;
-  }
-  for(i=1; i=nArg ){
-          dotCmdError(p, i, "missing argument", 0);
-          return 1;
-        }
-        free(p->zErrPrefix);
-        i++;
-        p->zErrPrefix = azArg[i][0]==0 ? 0 : strdup(azArg[i]);
-      }else{
-        dotCmdError(p, i, "unknown option", 0);
-        sqlite3_free(zFile);
-        return 1;
-      }
-    }else if( zFile==0 && eMode==0 ){
-      if( bKeep ){
-        dotCmdError(p, i, "incompatible with prior options",0);
-        goto dotCmdOutput_error;
-      }
-      if( cli_strcmp(z, "memory")==0 && bOnce ){
-        dotCmdError(p, 0, "cannot redirect to \"memory\"", 0);
-        goto dotCmdOutput_error;
-      }
-      if( cli_strcmp(z, "off")==0 ){
-#ifdef _WIN32
-        zFile = sqlite3_mprintf("nul");
-#else
-        zFile = sqlite3_mprintf("/dev/null");
-#endif
-      }else{
-        zFile = sqlite3_mprintf("%s", z);
-      }
-      if( zFile && zFile[0]=='|' ){
-        while( i+1nPopOutput = 2;
-  }else{
-    p->nPopOutput = 0;
-  }
-  if( !bKeep ) output_reset(p);
-#ifndef SQLITE_NOHAVE_SYSTEM
-  if( eMode=='e' || eMode=='x' || eMode=='w' ){
-    p->doXdgOpen = 1;
-    modePush(p);
-    if( eMode=='x' ){
-      /* spreadsheet mode.  Output as CSV. */
-      newTempFile(p, "csv");
-      p->mode.mFlags &= ~MFLG_ECHO;
-      p->mode.eMode = MODE_Csv;
-      modeSetStr(&p->mode.spec.zColumnSep, SEP_Comma);
-      modeSetStr(&p->mode.spec.zRowSep, SEP_CrLf);
-#ifdef _WIN32
-      zBom = zBomUtf8;  /* Always include the BOM on Windows, as Excel does
-                        ** not work without it. */
-#endif
-    }else if( eMode=='w' ){
-      /* web-browser mode. */
-      newTempFile(p, "html");
-      if( !bPlain ) p->mode.eMode = MODE_Www;
-    }else{
-      /* text editor mode */
-      newTempFile(p, "txt");
-    }
-    sqlite3_free(zFile);
-    zFile = sqlite3_mprintf("%s", p->zTempFile);
-  }
-#endif /* SQLITE_NOHAVE_SYSTEM */
-  if( !bKeep ) shell_check_oom(zFile);
-  if( bKeep ){
-    /* no-op */
-  }else if( cli_strcmp(zFile,"memory")==0 ){
-    if( cli_output_capture ){
-      sqlite3_str_free(cli_output_capture);
-    }
-    cli_output_capture = sqlite3_str_new(0);
-  }else if( zFile[0]=='|' ){
-#ifdef SQLITE_OMIT_POPEN
-    eputz("Error: pipes are not supported in this OS\n");
-    output_redir(p, stdout);
-    goto dotCmdOutput_error;
-#else
-    FILE *pfPipe = sqlite3_popen(zFile + 1, "w");
-    if( pfPipe==0 ){
-      assert( stderr!=NULL );
-      cli_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
-      goto dotCmdOutput_error;
-    }else{
-      output_redir(p, pfPipe);
-      if( zBom ) cli_puts(zBom, pfPipe);
-      sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
-    }
-#endif
-  }else{
-    FILE *pfFile = output_file_open(p, zFile);
-    if( pfFile==0 ){
-      if( cli_strcmp(zFile,"off")!=0 ){
-       assert( stderr!=NULL );
-       cli_printf(stderr,"Error: cannot write to \"%s\"\n", zFile);
-      }
-      goto dotCmdOutput_error;
-    } else {
-      output_redir(p, pfFile);
-      if( zBom ) cli_puts(zBom, pfFile);
-      if( bPlain && eMode=='w' ){
-        cli_puts(
-          "\n\n\n",
-          pfFile
-        );
-      }
-      sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
-    }
-  }
-  sqlite3_free(zFile);
-  return 0;
-
-dotCmdOutput_error:
-  sqlite3_free(zFile);
-  return 1;
-}
-
-/*
-** DOT-COMMAND: .check
-** USAGE: .check [OPTIONS] PATTERN
-**
-** Verify results of commands since the most recent .testcase command.
-** Restore output to the console, unless --keep is used.
-**
-** If PATTERN starts with "<<ENDMARK" then the actual pattern is taken from
-** subsequent lines of text up to the first line that begins with ENDMARK.
-** All pattern lines and the ENDMARK are discarded.
-**
-** Options:
-**   --exact                Do an exact comparison including leading and
-**                          trailing whitespace.
-**   --glob                 Treat PATTERN as a GLOB
-**   --keep                 Do not reset the testcase.  More .check commands
-**                          will follow.
-**   --notglob              Output should not match PATTERN
-**   --show                 Write testcase output to the screen, for debugging.
-*/
-static int dotCmdCheck(ShellState *p){
-  int nArg = p->dot.nArg;            /* Number of arguments */
-  char **azArg = p->dot.azArg;       /* Text of the arguments */
-  int i;                             /* Loop counter */
-  int k;                             /* Result of pickStr() */
-  char *zTest;                       /* Textcase result */
-  int bKeep = 0;                     /* --keep option */
-  char *zCheck = 0;                  /* PATTERN argument */
-  char *zPattern = 0;                /* Actual test pattern */
-  int eCheck = 0;                    /* 1: --glob,  2: --notglob,  3: --exact */
-  int isOk;                          /* True if results are OK */
-  sqlite3_int64 iStart = p->lineno;  /* Line number of .check statement */
-
-  if( p->zTestcase[0]==0 ){
-    dotCmdError(p, 0, "no .testcase is active", 0);
-    return 1;
-  }
-  for(i=1; i<nArg; i++){
-    char *z = azArg[i];
-    if( z[0]=='-' && z[1]=='-' && z[2]!=0 ) z++;
-    if( cli_strcmp(z,"-keep")==0 ){
-      bKeep = 1;
-    }else if( cli_strcmp(z,"-show")==0 ){
-      if( cli_output_capture ){
-        sqlite3_fprintf(stdout, "%s", sqlite3_str_value(cli_output_capture));
-      }
-      bKeep = 1;
-    }else if( z[0]=='-'
-          && (k = pickStr(&z[1],0,"glob","notglob","exact",""))>=0
-    ){
-      if( eCheck && eCheck!=k+1 ){
-        dotCmdError(p, i, "incompatible with prior options",0);
-        return 1;
-      }
-      eCheck = k+1;
-    }else if( zCheck ){
-      dotCmdError(p, i, "unknown option", 0);
-      return 1;
-    }else{
-      zCheck = azArg[i];
-    }
-  }
-  if( zCheck==0 ){
-    dotCmdError(p, 0, "no PATTERN specified", 0);
-    return 1;
-  }
-  if( cli_output_capture && sqlite3_str_length(cli_output_capture) ){
-    zTest = sqlite3_str_value(cli_output_capture);
-    shell_check_oom(zTest);
-  }else{
-    zTest = "";
-  }
-  p->nTestRun++;
-  if( zCheck[0]=='<' && zCheck[1]=='<' && zCheck[2]!=0 ){
-    int nCheck = strlen30(zCheck);
-    sqlite3_str *pPattern = sqlite3_str_new(p->db);
-    char zLine[2000];
-    while( sqlite3_fgets(zLine,sizeof(zLine),p->in) ){
-      if( strchr(zLine,'\n') ) p->lineno++;
-      if( cli_strncmp(&zCheck[2],zLine,nCheck-2)==0 ) break;
-      sqlite3_str_appendall(pPattern, zLine);
-    }
-    zPattern = sqlite3_str_finish(pPattern);
-    if( zPattern==0 ){
-      zPattern = sqlite3_mprintf("");
-    }
-  }else{
-    zPattern = zCheck;
-  }
-  shell_check_oom(zPattern);
-  switch( eCheck ){
-    case 1: {
-      char *zGlob = sqlite3_mprintf("*%s*", zPattern);
-      isOk = testcase_glob(zGlob, zTest)!=0;
-      sqlite3_free(zGlob);
-      break;
-    }
-    case 2: {
-      char *zGlob = sqlite3_mprintf("*%s*", zPattern);
-      isOk = testcase_glob(zGlob, zTest)==0;
-      sqlite3_free(zGlob);
-      break;
-    }
-    case 3: {
-      isOk = cli_strcmp(zTest,zPattern)==0;
-      break;
-    }
-    default: {
-      /* Skip leading and trailing \n and \r on both pattern and test output */
-      const char *z1 = zPattern;
-      const char *z2 = zTest;
-      size_t n1, n2;
-      while( z1[0]=='\n' || z1[0]=='\r' ) z1++;
-      n1 = strlen(z1);
-      while( n1>0 && (z1[n1-1]=='\n' || z1[n1-1]=='\r') ) n1--;
-      while( z2[0]=='\n' || z2[0]=='\r' ) z2++;
-      n2 = strlen(z2);
-      while( n2>0 && (z2[n2-1]=='\n' || z2[n2-1]=='\r') ) n2--;
-      isOk = n1==n2 && memcmp(z1,z2,n1)==0;
-      break;
-    }
-  }
-  if( !isOk ){
-    sqlite3_fprintf(stderr,
-          "%s:%lld: .check failed for testcase %s\n",
-        p->zInFile, iStart, p->zTestcase);
-    p->nTestErr++;
-    sqlite3_fprintf(stderr, "Expected: [%s]\n", zPattern);
-    sqlite3_fprintf(stderr, "Got:      [%s]\n", zTest);
-  }
-  if( zPattern!=zCheck ){
-    sqlite3_free(zPattern);
-  }
-  if( !bKeep ){
-    output_reset(p);
-    p->zTestcase[0] = 0;
-  }
-  return 0;
-}
-
-/*
-** DOT-COMMAND: .testcase
-** USAGE: .testcase [OPTIONS] NAME
-**
-** Start a new test case identified by NAME.  All output
-** through the next ".check" command is captured for comparison. See the
-** ".check" commandn for additional informatioon.
-**
-** Options:
-**   --error-prefix TEXT       Change error message prefix text to TEXT
-*/
-static int dotCmdTestcase(ShellState *p){
-  int nArg = p->dot.nArg;        /* Number of arguments */
-  char **azArg = p->dot.azArg;   /* Text of the arguments */
-  int i;                         /* Loop counter */
-  const char *zName = 0;         /* Testcase name */
-
-  for(i=1; i<nArg; i++){
-    char *z = azArg[i];
-    if( z[0]=='-' && z[1]=='-' && z[2]!=0 ) z++;
-    if( optionMatch(z,"error-prefix") ){
-      if( i+1>=nArg ){
-        dotCmdError(p, i, "missing argument", 0);
-        return 1;
-      }
-      free(p->zErrPrefix);
-      i++;
-      p->zErrPrefix = azArg[i][0]==0 ? 0 : strdup(azArg[i]);
-    }else if( zName ){
-      dotCmdError(p, i, "unknown option", 0);
-      return 1;
-    }else{
-      zName = azArg[i];
-    }
-  }
-  output_reset(p);
-  if( cli_output_capture ){
-    sqlite3_str_free(cli_output_capture);
-  }
-  cli_output_capture = sqlite3_str_new(0);
-  if( zName ){
-    sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s", zName);
-  }else{
-    sqlite3_snprintf(sizeof(p->zTestcase), p->zTestcase, "%s:%lld",
-                     p->zInFile, p->lineno);
-  }
-  return 0;
-}
-
-/*
-** Enlarge the space allocated in p->dot so that it can hold more
-** than nArg parsed command-line arguments.
-*/
-static void parseDotRealloc(ShellState *p, int nArg){
-  p->dot.nAlloc = nArg+22;
-  p->dot.azArg = realloc(p->dot.azArg,p->dot.nAlloc*sizeof(char*));
-  shell_check_oom(p->dot.azArg);
-  p->dot.aiOfst = realloc(p->dot.aiOfst,p->dot.nAlloc*sizeof(int));
-  shell_check_oom(p->dot.aiOfst);
-  p->dot.abQuot = realloc(p->dot.abQuot,p->dot.nAlloc);
-  shell_check_oom(p->dot.abQuot);
-}
-
-
-/*
-** Parse input line zLine up into individual arguments.  Retain the
-** parse in the p->dot substructure.
-*/
-static void parseDotCmdArgs(const char *zLine, ShellState *p){
-  char *z;
-  int h = 1;
-  int nArg = 0;
-  size_t szLine;
-
-  p->dot.zOrig = zLine;
-  free(p->dot.zCopy);
-  z = p->dot.zCopy = strdup(zLine);
-  shell_check_oom(z);
-  szLine = strlen(z);
-  while( szLine>0 && IsSpace(z[szLine-1]) ) szLine--;
-  if( szLine>0 && z[szLine-1]==';' ){
-    szLine--;
-    while( szLine>0 && IsSpace(z[szLine-1]) ) szLine--;
-  }
-  z[szLine] = 0;
-  parseDotRealloc(p, 2);
-  while( z[h] ){
-    while( IsSpace(z[h]) ){ h++; }
-    if( z[h]==0 ) break;
-    if( nArg+2>p->dot.nAlloc ){
-      parseDotRealloc(p, nArg);
-    }
-    if( z[h]=='\'' || z[h]=='"' ){
-      int delim = z[h++];
-      p->dot.abQuot[nArg] = 1;
-      p->dot.azArg[nArg] = &z[h];
-      p->dot.aiOfst[nArg] = h;
-      while( z[h] && z[h]!=delim ){
-        if( z[h]=='\\' && delim=='"' && z[h+1]!=0 ) h++;
-        h++;
-      }
-      if( z[h]==delim ){
-        z[h++] = 0;
-      }
-      if( delim=='"' ) resolve_backslashes(p->dot.azArg[nArg]);
-    }else{
-      p->dot.abQuot[nArg] = 0;
-      p->dot.azArg[nArg] = &z[h];
-      p->dot.aiOfst[nArg] = h;
-      while( z[h] && !IsSpace(z[h]) ){ h++; }
-      if( z[h] ) z[h++] = 0;
-    }
-    nArg++;
-  }
-  p->dot.nArg = nArg;
-  p->dot.azArg[nArg] = 0;
-}
-
-/*
-** If an input line begins with "." then invoke this routine to
-** process that line.
-**
-** Return 1 on error, 2 to exit, and 0 otherwise.
-*/
-static int do_meta_command(const char *zLine, ShellState *p){
-  int nArg;
-  int n, c;
-  int rc = 0;
-  char **azArg;
-
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_AUTHORIZATION)
-  if( p->expert.pExpert ){
-    expertFinish(p, 1, 0);
-  }
-#endif
-
-  /* Parse the input line into tokens stored in p->dot.
-  */
-  parseDotCmdArgs(zLine, p);
-  nArg = p->dot.nArg;
-  azArg = p->dot.azArg;
-
-  /* Process the input line.
-  */
-  if( nArg==0 ) return 0; /* no tokens, no error */
-  n = strlen30(azArg[0]);
-  c = azArg[0][0];
-  clearTempFile(p);
-
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  if( c=='a' && cli_strncmp(azArg[0], "auth", n)==0 ){
-    if( nArg!=2 ){
-      cli_printf(stderr, "Usage: .auth ON|OFF\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    open_db(p, 0);
-    if( booleanValue(azArg[1]) ){
-      sqlite3_set_authorizer(p->db, shellAuth, p);
-    }else if( p->bSafeModePersist ){
-      sqlite3_set_authorizer(p->db, safeModeAuth, p);
-    }else{
-      sqlite3_set_authorizer(p->db, 0, 0);
-    }
-  }else
-#endif
-
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB) \
-  && !defined(SQLITE_SHELL_FIDDLE)
-  if( c=='a' && cli_strncmp(azArg[0], "archive", n)==0 ){
-    open_db(p, 0);
-    failIfSafeMode(p, "cannot run .archive in safe mode");
-    rc = arDotCommand(p, 0, azArg, nArg);
-  }else
-#endif
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( (c=='b' && n>=3 && cli_strncmp(azArg[0], "backup", n)==0)
-   || (c=='s' && n>=3 && cli_strncmp(azArg[0], "save", n)==0)
-  ){
-    const char *zDestFile = 0;
-    const char *zDb = 0;
-    sqlite3 *pDest;
-    sqlite3_backup *pBackup;
-    int j;
-    int bAsync = 0;
-    const char *zVfs = 0;
-    failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
-    for(j=1; j<nArg; j++){
-      const char *z = azArg[j];
-      if( z[0]=='-' ){
-        if( z[1]=='-' ) z++;
-        if( cli_strcmp(z, "-append")==0 ){
-          zVfs = "apndvfs";
-        }else
-        if( cli_strcmp(z, "-async")==0 ){
-          bAsync = 1;
-        }else
-        {
-          dotCmdError(p, j, "unknown option", "should be -append or -async");
-          return 1;
-        }
-      }else if( zDestFile==0 ){
-        zDestFile = azArg[j];
-      }else if( zDb==0 ){
-        zDb = zDestFile;
-        zDestFile = azArg[j];
-      }else{
-        cli_printf(stderr, "Usage: .backup ?DB? ?OPTIONS? FILENAME\n");
-        return 1;
-      }
-    }
-    if( zDestFile==0 ){
-      cli_printf(stderr, "missing FILENAME argument on .backup\n");
-      return 1;
-    }
-    if( zDb==0 ) zDb = "main";
-    rc = sqlite3_open_v2(zDestFile, &pDest,
-                  SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs);
-    if( rc!=SQLITE_OK ){
-      cli_printf(stderr,"Error: cannot open \"%s\"\n", zDestFile);
-      close_db(pDest);
-      return 1;
-    }
-    if( bAsync ){
-      sqlite3_exec(pDest, "PRAGMA synchronous=OFF; PRAGMA journal_mode=OFF;",
-                   0, 0, 0);
-    }
-    open_db(p, 0);
-    pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
-    if( pBackup==0 ){
-      shellDatabaseError(pDest);
-      close_db(pDest);
-      return 1;
-    }
-    while(  (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
-    sqlite3_backup_finish(pBackup);
-    if( rc==SQLITE_DONE ){
-      rc = 0;
-    }else{
-      shellDatabaseError(pDest);
-      rc = 1;
-    }
-    close_db(pDest);
-  }else
-#endif /* !defined(SQLITE_SHELL_FIDDLE) */
-
-  if( c=='b' && n>=3 && cli_strncmp(azArg[0], "bail", n)==0 ){
-    if( nArg==2 ){
-      bail_on_error = booleanValue(azArg[1]);
-    }else{
-      eputz("Usage: .bail on|off\n");
-      rc = 1;
-    }
-  }else
-
-  /* Undocumented.  Legacy only.  See "crlf" below */
-  if( c=='b' && n>=3 && cli_strncmp(azArg[0], "binary", n)==0 ){
-    eputz("The \".binary\" command is deprecated.\n");
-    rc = 1;
-  }else
-
-  /* The undocumented ".breakpoint" command causes a call to the no-op
-  ** routine named test_breakpoint().
-  */
-  if( c=='b' && n>=3 && cli_strncmp(azArg[0], "breakpoint", n)==0 ){
-    test_breakpoint();
-  }else
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( c=='c' && cli_strcmp(azArg[0],"cd")==0 ){
-    failIfSafeMode(p, "cannot run .cd in safe mode");
-    if( nArg==2 ){
-#if defined(_WIN32) || defined(WIN32)
-      wchar_t *z = sqlite3_win32_utf8_to_unicode(azArg[1]);
-      rc = !SetCurrentDirectoryW(z);
-      sqlite3_free(z);
-#else
-      rc = chdir(azArg[1]);
-#endif
-      if( rc ){
-        cli_printf(stderr,"Cannot change to directory \"%s\"\n", azArg[1]);
-        rc = 1;
-      }
-    }else{
-      eputz("Usage: .cd DIRECTORY\n");
-      rc = 1;
-    }
-  }else
-#endif /* !defined(SQLITE_SHELL_FIDDLE) */
-
-  if( c=='c' && n>=3 && cli_strncmp(azArg[0], "changes", n)==0 ){
-    if( nArg==2 ){
-      setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
-    }else{
-      eputz("Usage: .changes on|off\n");
-      rc = 1;
-    }
-  }else
-
-  /* Cancel output redirection, if it is currently set (by .testcase)
-  ** Then read the content of the testcase-out.txt file and compare against
-  ** azArg[1].  If there are differences, report an error and exit.
-  */
-  if( c=='c' && n>=3 && cli_strncmp(azArg[0], "check", n)==0 ){
-    rc = dotCmdCheck(p);
-  }else
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( c=='c' && cli_strncmp(azArg[0], "clone", n)==0 ){
-    failIfSafeMode(p, "cannot run .clone in safe mode");
-    if( nArg==2 ){
-      tryToClone(p, azArg[1]);
-    }else{
-      eputz("Usage: .clone FILENAME\n");
-      rc = 1;
-    }
-  }else
-#endif /* !defined(SQLITE_SHELL_FIDDLE) */
-
-  if( c=='c' && cli_strncmp(azArg[0], "connection", n)==0 ){
-    if( nArg==1 ){
-      /* List available connections */
-      int i;
-      for(i=0; i<ArraySize(p->aAuxDb); i++){
-        const char *zFile = p->aAuxDb[i].zDbFilename;
-        if( p->aAuxDb[i].db==0 && p->pAuxDb!=&p->aAuxDb[i] ){
-          zFile = "(not open)";
-        }else if( zFile==0 ){
-          zFile = "(memory)";
-        }else if( zFile[0]==0 ){
-          zFile = "(temporary-file)";
-        }
-        if( p->pAuxDb == &p->aAuxDb[i] ){
-          cli_printf(stdout, "ACTIVE %d: %s\n", i, zFile);
-        }else if( p->aAuxDb[i].db!=0 ){
-          cli_printf(stdout, "       %d: %s\n", i, zFile);
-        }
-      }
-    }else if( nArg==2 && IsDigit(azArg[1][0]) && azArg[1][1]==0 ){
-      int i = azArg[1][0] - '0';
-      if( p->pAuxDb != &p->aAuxDb[i] && i>=0 && i<ArraySize(p->aAuxDb) ){
-        p->pAuxDb->db = p->db;
-        p->pAuxDb = &p->aAuxDb[i];
-        globalDb = p->db = p->pAuxDb->db;
-        p->pAuxDb->db = 0;
-      }
-    }else if( nArg==3 && cli_strcmp(azArg[1], "close")==0
-           && IsDigit(azArg[2][0]) && azArg[2][1]==0 ){
-      int i = azArg[2][0] - '0';
-      if( i<0 || i>=ArraySize(p->aAuxDb) ){
-        /* No-op */
-      }else if( p->pAuxDb == &p->aAuxDb[i] ){
-        eputz("cannot close the active database connection\n");
-        rc = 1;
-      }else if( p->aAuxDb[i].db ){
-        session_close_all(p, i);
-        close_db(p->aAuxDb[i].db);
-        p->aAuxDb[i].db = 0;
-      }
-    }else{
-      eputz("Usage: .connection [close] [CONNECTION-NUMBER]\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='c' && n==4
-   && (cli_strncmp(azArg[0], "crlf", n)==0
-       || cli_strncmp(azArg[0], "crnl",n)==0)
-  ){
-    if( nArg==2 ){
-#ifdef _WIN32
-      if( booleanValue(azArg[1]) ){
-        p->mode.mFlags |= MFLG_CRLF;
-      }else{
-        p->mode.mFlags &= ~MFLG_CRLF;
-      }
-#else
-      p->mode.mFlags &= ~MFLG_CRLF;
-#endif
-    }
-    cli_printf(stderr, "crlf is %s\n", 
-       (p->mode.mFlags & MFLG_CRLF)!=0 ? "ON" : "OFF");
-  }else
-
-  if( c=='d' && n>1 && cli_strncmp(azArg[0], "databases", n)==0 ){
-    char **azName = 0;
-    int nName = 0;
-    sqlite3_stmt *pStmt;
-    int i;
-    open_db(p, 0);
-    rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
-    if( rc ){
-      shellDatabaseError(p->db);
-      rc = 1;
-    }else{
-      while( sqlite3_step(pStmt)==SQLITE_ROW ){
-        const char *zSchema = (const char *)sqlite3_column_text(pStmt,1);
-        const char *zFile = (const char*)sqlite3_column_text(pStmt,2);
-        if( zSchema==0 || zFile==0 ) continue;
-        azName = sqlite3_realloc64(azName, (nName+1)*2*sizeof(char*));
-        shell_check_oom(azName);
-        azName[nName*2] = strdup(zSchema);
-        azName[nName*2+1] = strdup(zFile);
-        nName++;
-      }
-    }
-    sqlite3_finalize(pStmt);
-    for(i=0; i<nName; i++){
-      int eTxn = sqlite3_txn_state(p->db, azName[i*2]);
-      int bRdonly = sqlite3_db_readonly(p->db, azName[i*2]);
-      const char *z = azName[i*2+1];
-      cli_printf(p->out, "%s: %s %s%s\n",
-            azName[i*2], z && z[0] ? z : "\"\"", bRdonly ? "r/o" : "r/w",
-            eTxn==SQLITE_TXN_NONE ? "" :
-            eTxn==SQLITE_TXN_READ ? " read-txn" : " write-txn");
-      free(azName[i*2]);
-      free(azName[i*2+1]);
-    }
-    sqlite3_free(azName);
-  }else
-
-  if( c=='d' && n>=3 && cli_strncmp(azArg[0], "dbconfig", n)==0 ){
-    static const struct DbConfigChoices {
-      const char *zName;
-      int op;
-    } aDbConfig[] = {
-        { "attach_create",      SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE  },
-        { "attach_write",       SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE   },
-        { "comments",           SQLITE_DBCONFIG_ENABLE_COMMENTS       },
-        { "defensive",          SQLITE_DBCONFIG_DEFENSIVE             },
-        { "dqs_ddl",            SQLITE_DBCONFIG_DQS_DDL               },
-        { "dqs_dml",            SQLITE_DBCONFIG_DQS_DML               },
-        { "enable_fkey",        SQLITE_DBCONFIG_ENABLE_FKEY           },
-        { "enable_qpsg",        SQLITE_DBCONFIG_ENABLE_QPSG           },
-        { "enable_trigger",     SQLITE_DBCONFIG_ENABLE_TRIGGER        },
-        { "enable_view",        SQLITE_DBCONFIG_ENABLE_VIEW           },
-        { "fts3_tokenizer",     SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER },
-        { "fp_digits",          SQLITE_DBCONFIG_FP_DIGITS             },
-        { "legacy_alter_table", SQLITE_DBCONFIG_LEGACY_ALTER_TABLE    },
-        { "legacy_file_format", SQLITE_DBCONFIG_LEGACY_FILE_FORMAT    },
-        { "load_extension",     SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION },
-        { "no_ckpt_on_close",   SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      },
-        { "reset_database",     SQLITE_DBCONFIG_RESET_DATABASE        },
-        { "reverse_scanorder",  SQLITE_DBCONFIG_REVERSE_SCANORDER     },
-        { "stmt_scanstatus",    SQLITE_DBCONFIG_STMT_SCANSTATUS       },
-        { "trigger_eqp",        SQLITE_DBCONFIG_TRIGGER_EQP           },
-        { "trusted_schema",     SQLITE_DBCONFIG_TRUSTED_SCHEMA        },
-        { "writable_schema",    SQLITE_DBCONFIG_WRITABLE_SCHEMA       },
-    };
-    int ii, v;
-    open_db(p, 0);
-    for(ii=0; ii<ArraySize(aDbConfig); ii++){
-      if( nArg>1 && cli_strcmp(azArg[1], aDbConfig[ii].zName)!=0 ) continue;
-      if( nArg>=3 ){
-        if( aDbConfig[ii].op==SQLITE_DBCONFIG_FP_DIGITS ){
-          sqlite3_db_config(p->db, aDbConfig[ii].op, atoi(azArg[2]), 0);
-        }else{
-          sqlite3_db_config(p->db, aDbConfig[ii].op, booleanValue(azArg[2]), 0);
-        }
-      }
-      sqlite3_db_config(p->db, aDbConfig[ii].op, -1, &v);
-      if( aDbConfig[ii].op==SQLITE_DBCONFIG_FP_DIGITS ){
-        cli_printf(p->out, "%19s %d\n", aDbConfig[ii].zName, v);
-      }else{
-        cli_printf(p->out, "%19s %s\n",
-                        aDbConfig[ii].zName, v ? "on" : "off");
-      }
-      if( nArg>1 ) break;
-    }
-    if( nArg>1 && ii==ArraySize(aDbConfig) ){
-      dotCmdError(p, 1, "unknown dbconfig",
-         "Enter \".dbconfig\" with no arguments for a list");
-    }
-  }else
-
-#if SQLITE_SHELL_HAVE_RECOVER
-  if( c=='d' && n>=3 && cli_strncmp(azArg[0], "dbinfo", n)==0 ){
-    rc = shell_dbinfo_command(p, nArg, azArg);
-  }else
-
-  if( c=='r' && cli_strncmp(azArg[0], "recover", n)==0 ){
-    open_db(p, 0);
-    rc = recoverDatabaseCmd(p, nArg, azArg);
-  }else
-#endif /* SQLITE_SHELL_HAVE_RECOVER */
-
-  if( c=='d' && cli_strncmp(azArg[0], "dump", n)==0 ){
-    char *zLike = 0;
-    char *zSql;
-    int i;
-    int savedShellFlags = p->shellFlgs;
-    Mode saved_mode;
-    ShellClearFlag(p,
-       SHFLG_PreserveRowid|SHFLG_DumpDataOnly|SHFLG_DumpNoSys);
-    for(i=1; i<nArg; i++){
-      if( azArg[i][0]=='-' ){
-        const char *z = azArg[i]+1;
-        if( z[0]=='-' ) z++;
-        if( cli_strcmp(z,"preserve-rowids")==0 ){
-#ifdef SQLITE_OMIT_VIRTUALTABLE
-          dotCmdError(p, i, "unable",
-            "The --preserve-rowids option is not compatible"
-                " with SQLITE_OMIT_VIRTUALTABLE");
-          rc = 1;
-          sqlite3_free(zLike);
-          goto meta_command_exit;
-#else
-          ShellSetFlag(p, SHFLG_PreserveRowid);
-#endif
-        }else
-        if( cli_strcmp(z,"newlines")==0 ){
-          /*ShellSetFlag(p, SHFLG_Newlines);*/
-        }else
-        if( cli_strcmp(z,"data-only")==0 ){
-          ShellSetFlag(p, SHFLG_DumpDataOnly);
-        }else
-        if( cli_strcmp(z,"nosys")==0 ){
-          ShellSetFlag(p, SHFLG_DumpNoSys);
-        }else
-        {
-          dotCmdError(p, i, "unknown option", 0);
-          rc = 1;
-          sqlite3_free(zLike);
-          goto meta_command_exit;
-        }
-      }else{
-        /* azArg[i] contains a LIKE pattern. This ".dump" request should
-        ** only dump data for tables for which either the table name matches
-        ** the LIKE pattern, or the table appears to be a shadow table of
-        ** a virtual table for which the name matches the LIKE pattern.
-        */
-        char *zExpr = sqlite3_mprintf(
-            "name LIKE %Q ESCAPE '\\' OR EXISTS ("
-            "  SELECT 1 FROM sqlite_schema WHERE "
-            "    name LIKE %Q ESCAPE '\\' AND"
-            "    sql LIKE 'CREATE VIRTUAL TABLE%%' AND"
-            "    substr(o.name, 1, length(name)+1) == (name||'_')"
-            ")", azArg[i], azArg[i]
-        );
-
-        if( zLike ){
-          zLike = sqlite3_mprintf("%z OR %z", zLike, zExpr);
-        }else{
-          zLike = zExpr;
-        }
-      }
-    }
-
-    open_db(p, 0);
-
-    modeDup(&saved_mode, &p->mode);
-    outputDumpWarning(p, zLike);
-    if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
-      /* When playing back a "dump", the content might appear in an order
-      ** which causes immediate foreign key constraints to be violated.
-      ** So disable foreign-key constraint enforcement to prevent problems. */
-      cli_puts("PRAGMA foreign_keys=OFF;\n", p->out);
-      cli_puts("BEGIN TRANSACTION;\n", p->out);
-    }
-    p->writableSchema = 0;
-    p->mode.spec.bTitles = QRF_No;
-    /* Set writable_schema=ON since doing so forces SQLite to initialize
-    ** as much of the schema as it can even if the sqlite_schema table is
-    ** corrupt. */
-    sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
-    p->nErr = 0;
-    if( zLike==0 ) zLike = sqlite3_mprintf("true");
-    zSql = sqlite3_mprintf(
-      "SELECT name, type, sql FROM sqlite_schema AS o "
-      "WHERE (%s) AND type=='table'"
-      "  AND sql NOT NULL"
-      " ORDER BY tbl_name='sqlite_sequence', rowid",
-      zLike
-    );
-    run_schema_dump_query(p,zSql);
-    sqlite3_free(zSql);
-    if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
-      zSql = sqlite3_mprintf(
-        "SELECT sql FROM sqlite_schema AS o "
-        "WHERE (%s) AND sql NOT NULL"
-        "  AND type IN ('index','trigger','view') "
-        "ORDER BY type COLLATE NOCASE DESC",
-        zLike
-      );
-      run_table_dump_query(p, zSql);
-      sqlite3_free(zSql);
-    }
-    sqlite3_free(zLike);
-    if( p->writableSchema ){
-      cli_puts("PRAGMA writable_schema=OFF;\n", p->out);
-      p->writableSchema = 0;
-    }
-    sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
-    sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
-    if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
-      cli_puts(p->nErr?"ROLLBACK; -- due to errors\n":"COMMIT;\n", p->out);
-    }
-    p->shellFlgs = savedShellFlags;
-    modeFree(&p->mode);
-    p->mode = saved_mode;
-    rc = p->nErr>0;
-  }else
-
-  if( c=='e' && cli_strncmp(azArg[0], "echo", n)==0 ){
-    if( nArg==2 ){
-      if( booleanValue(azArg[1]) ){
-        p->mode.mFlags |= MFLG_ECHO;
-      }else{
-        p->mode.mFlags &= ~MFLG_ECHO;
-      }
-    }else{
-      eputz("Usage: .echo on|off\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='d' && n>=3 && cli_strncmp(azArg[0], "dbtotxt", n)==0 ){
-    open_db(p, 0);
-    rc = shell_dbtotxt_command(p, nArg, azArg);
-  }else
-
-  if( c=='e' && cli_strncmp(azArg[0], "eqp", n)==0 ){
-    if( nArg==2 ){
-      if( p->mode.autoEQPtrace ){
-        if( p->db ) sqlite3_exec(p->db, "PRAGMA vdbe_trace=OFF;", 0, 0, 0);
-        p->mode.autoEQPtrace = 0;
-      }
-      if( cli_strcmp(azArg[1],"full")==0 ){
-        p->mode.autoEQP = AUTOEQP_full;
-      }else if( cli_strcmp(azArg[1],"trigger")==0 ){
-        p->mode.autoEQP = AUTOEQP_trigger;
-#ifdef SQLITE_DEBUG
-      }else if( cli_strcmp(azArg[1],"trace")==0 ){
-        p->mode.autoEQP = AUTOEQP_full;
-        p->mode.autoEQPtrace = 1;
-        open_db(p, 0);
-        sqlite3_exec(p->db, "SELECT name FROM sqlite_schema LIMIT 1", 0, 0, 0);
-        sqlite3_exec(p->db, "PRAGMA vdbe_trace=ON;", 0, 0, 0);
-#endif
-      }else{
-        p->mode.autoEQP = (u8)booleanValue(azArg[1]);
-      }
-    }else{
-      eputz("Usage: .eqp off|on|trace|trigger|full\n");
-      rc = 1;
-    }
-  }else
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( c=='e' && cli_strncmp(azArg[0], "exit", n)==0 ){
-    if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) cli_exit(rc);
-    rc = 2;
-  }else
-#endif
-
-  /* The ".explain" command is automatic now.  It is largely pointless.  It
-  ** retained purely for backwards compatibility */
-  if( c=='e' && cli_strncmp(azArg[0], "explain", n)==0 ){
-    if( nArg>=2 ){
-      if( cli_strcmp(azArg[1],"auto")==0 ){
-        p->mode.autoExplain = 1;
-      }else{
-        p->mode.autoExplain = booleanValue(azArg[1]);
-      }
-    }
-  }else
-
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_AUTHORIZATION)
-  if( c=='e' && cli_strncmp(azArg[0], "expert", n)==0 ){
-    if( p->bSafeMode ){
-      cli_printf(stderr,
-            "Cannot run experimental commands such as \"%s\" in safe mode\n",
-            azArg[0]);
-      rc = 1;
-    }else{
-      open_db(p, 0);
-      expertDotCommand(p, azArg, nArg);
-    }
-  }else
-#endif
-
-  if( c=='f' && cli_strncmp(azArg[0], "filectrl", n)==0 ){
-    static const struct {
-       const char *zCtrlName;   /* Name of a test-control option */
-       int ctrlCode;            /* Integer code for that option */
-       const char *zUsage;      /* Usage notes */
-    } aCtrl[] = {
-      { "chunk_size",     SQLITE_FCNTL_CHUNK_SIZE,      "SIZE"           },
-      { "data_version",   SQLITE_FCNTL_DATA_VERSION,    ""               },
-      { "has_moved",      SQLITE_FCNTL_HAS_MOVED,       ""               },
-      { "lock_timeout",   SQLITE_FCNTL_LOCK_TIMEOUT,    "MILLISEC"       },
-      { "persist_wal",    SQLITE_FCNTL_PERSIST_WAL,     "[BOOLEAN]"      },
-   /* { "pragma",         SQLITE_FCNTL_PRAGMA,          "NAME ARG"       },*/
-      { "psow",       SQLITE_FCNTL_POWERSAFE_OVERWRITE, "[BOOLEAN]"      },
-      { "reserve_bytes",  SQLITE_FCNTL_RESERVE_BYTES,   "[N]"            },
-      { "size_limit",     SQLITE_FCNTL_SIZE_LIMIT,      "[LIMIT]"        },
-      { "tempfilename",   SQLITE_FCNTL_TEMPFILENAME,    ""               },
-   /* { "win32_av_retry", SQLITE_FCNTL_WIN32_AV_RETRY,  "COUNT DELAY"    },*/
-    };
-    int filectrl = -1;
-    int iCtrl = -1;
-    sqlite3_int64 iRes = 0;  /* Integer result to display if rc2==1 */
-    int isOk = 0;            /* 0: usage  1: %lld  2: no-result */
-    int n2, i;
-    const char *zCmd = 0;
-    const char *zSchema = 0;
-
-    open_db(p, 0);
-    zCmd = nArg>=2 ? azArg[1] : "help";
-
-    if( zCmd[0]=='-'
-     && (cli_strcmp(zCmd,"--schema")==0 || cli_strcmp(zCmd,"-schema")==0)
-     && nArg>=4
-    ){
-      zSchema = azArg[2];
-      for(i=3; i<nArg; i++) azArg[i-2] = azArg[i];
-      nArg -= 2;
-      zCmd = azArg[1];
-    }
-
-    /* The argument can optionally begin with "-" or "--" */
-    if( zCmd[0]=='-' && zCmd[1] ){
-      zCmd++;
-      if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
-    }
-
-    /* --help lists all file-controls */
-    if( cli_strcmp(zCmd,"help")==0 ){
-      cli_puts("Available file-controls:\n", p->out);
-      for(i=0; i<ArraySize(aCtrl); i++){
-        cli_printf(p->out,
-               "  .filectrl %s %s\n", aCtrl[i].zCtrlName, aCtrl[i].zUsage);
-      }
-      rc = 1;
-      goto meta_command_exit;
-    }
-
-    /* convert filectrl text option to value. allow any unique prefix
-    ** of the option name, or a numerical value. */
-    n2 = strlen30(zCmd);
-    for(i=0; i<ArraySize(aCtrl); i++){
-      if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
-        if( filectrl<0 ){
-          filectrl = aCtrl[i].ctrlCode;
-          iCtrl = i;
-        }else{
-          cli_printf(stderr,"Error: ambiguous file-control: \"%s\"\n"
-                "Use \".filectrl --help\" for help\n", zCmd);
-          rc = 1;
-          goto meta_command_exit;
-        }
-      }
-    }
-    if( filectrl<0 ){
-      cli_printf(stderr,"Error: unknown file-control: %s\n"
-            "Use \".filectrl --help\" for help\n", zCmd);
-    }else{
-      switch(filectrl){
-        case SQLITE_FCNTL_SIZE_LIMIT: {
-          if( nArg!=2 && nArg!=3 ) break;
-          iRes = nArg==3 ? integerValue(azArg[2]) : -1;
-          sqlite3_file_control(p->db, zSchema, SQLITE_FCNTL_SIZE_LIMIT, &iRes);
-          isOk = 1;
-          break;
-        }
-        case SQLITE_FCNTL_LOCK_TIMEOUT:
-        case SQLITE_FCNTL_CHUNK_SIZE: {
-          int x;
-          if( nArg!=3 ) break;
-          x = (int)integerValue(azArg[2]);
-          sqlite3_file_control(p->db, zSchema, filectrl, &x);
-          isOk = 2;
-          break;
-        }
-        case SQLITE_FCNTL_PERSIST_WAL:
-        case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
-          int x;
-          if( nArg!=2 && nArg!=3 ) break;
-          x = nArg==3 ? booleanValue(azArg[2]) : -1;
-          sqlite3_file_control(p->db, zSchema, filectrl, &x);
-          iRes = x;
-          isOk = 1;
-          break;
-        }
-        case SQLITE_FCNTL_DATA_VERSION:
-        case SQLITE_FCNTL_HAS_MOVED: {
-          int x;
-          if( nArg!=2 ) break;
-          sqlite3_file_control(p->db, zSchema, filectrl, &x);
-          iRes = x;
-          isOk = 1;
-          break;
-        }
-        case SQLITE_FCNTL_TEMPFILENAME: {
-          char *z = 0;
-          if( nArg!=2 ) break;
-          sqlite3_file_control(p->db, zSchema, filectrl, &z);
-          if( z ){
-            cli_printf(p->out, "%s\n", z);
-            sqlite3_free(z);
-          }
-          isOk = 2;
-          break;
-        }
-        case SQLITE_FCNTL_RESERVE_BYTES: {
-          int x;
-          if( nArg>=3 ){
-            x = atoi(azArg[2]);
-            sqlite3_file_control(p->db, zSchema, filectrl, &x);
-          }
-          x = -1;
-          sqlite3_file_control(p->db, zSchema, filectrl, &x);
-          cli_printf(p->out, "%d\n", x);
-          isOk = 2;
-          break;
-        }
-      }
-    }
-    if( isOk==0 && iCtrl>=0 ){
-      cli_printf(p->out, "Usage: .filectrl %s %s\n",
-                      zCmd, aCtrl[iCtrl].zUsage);
-      rc = 1;
-    }else if( isOk==1 ){
-      char zBuf[100];
-      sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", iRes);
-      cli_printf(p->out, "%s\n", zBuf);
-    }
-  }else
-
-  if( c=='f' && cli_strncmp(azArg[0], "fullschema", n)==0 ){
-    ShellState data;
-    int doStats = 0;
-    int hasStat[5];
-    int flgs = 0;
-    char *zSql;
-    if( nArg==2 && optionMatch(azArg[1], "indent") ){
-      nArg = 1;
-    }
-    if( nArg!=1 ){
-      eputz("Usage: .fullschema ?--indent?\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    open_db(p, 0);
-    zSql = sqlite3_mprintf(
-       "SELECT shell_format_schema(sql,%d) FROM"
-       "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
-       "     FROM sqlite_schema UNION ALL"
-       "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_schema) "
-       "WHERE type!='meta' AND sql NOTNULL"
-       "  AND name NOT LIKE 'sqlite__%%' ESCAPE '_' "
-       "ORDER BY x", flgs);
-    memcpy(&data, p, sizeof(data));
-    data.mode.spec.bTitles = QRF_No;
-    data.mode.eMode = MODE_List;
-    data.mode.spec.eText = QRF_TEXT_Plain;
-    data.mode.spec.nCharLimit = 0;
-    data.mode.spec.zRowSep = "\n";
-    rc = shell_exec(&data,zSql,0);
-    sqlite3_free(zSql);
-    if( rc==SQLITE_OK ){
-      sqlite3_stmt *pStmt;
-      memset(hasStat, 0, sizeof(hasStat));
-      rc = sqlite3_prepare_v2(p->db,
-               "SELECT substr(name,12,1) FROM sqlite_schema"
-               " WHERE name GLOB 'sqlite_stat[134]'",
-               -1, &pStmt, 0);
-      if( rc==SQLITE_OK ){
-        while( sqlite3_step(pStmt)==SQLITE_ROW ){
-          int k = sqlite3_column_int(pStmt,0);
-          assert( k==1 || k==3 || k==4 );
-          hasStat[k] = 1;
-          doStats = 1;
-        }
-      }
-      sqlite3_finalize(pStmt);
-    }
-    if( doStats==0 ){
-      cli_puts("/* No STAT tables available */\n", p->out);
-    }else{
-      cli_puts("ANALYZE sqlite_schema;\n", p->out);
-      data.mode.eMode = MODE_Insert;
-      if( hasStat[1] ){
-        data.mode.spec.zTableName = "sqlite_stat1";
-        shell_exec(&data, "SELECT * FROM sqlite_stat1", 0);
-      }
-      if( hasStat[4] ){
-        data.mode.spec.zTableName = "sqlite_stat4";
-        shell_exec(&data, "SELECT * FROM sqlite_stat4", 0);
-      }
-      cli_puts("ANALYZE sqlite_schema;\n", p->out);
-    }
-  }else
-
-  if( c=='h' && cli_strncmp(azArg[0], "headers", n)==0 ){
-    if( nArg==2 ){
-      p->mode.spec.bTitles = booleanValue(azArg[1]) ? QRF_Yes : QRF_No;
-      p->mode.mFlags |= MFLG_HDR;
-      p->mode.spec.eTitle = aModeInfo[p->mode.eMode].eHdr;
-    }else{
-      eputz("Usage: .headers on|off\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='h' && cli_strncmp(azArg[0], "help", n)==0 ){
-    if( nArg>=2 ){
-      n = showHelp(p->out, azArg[1]);
-      if( n==0 ){
-        cli_printf(p->out, "Nothing matches '%s'\n", azArg[1]);
-      }
-    }else{
-      showHelp(p->out, 0);
-    }
-  }else
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( c=='i' && cli_strncmp(azArg[0], "import", n)==0 ){
-    rc = dotCmdImport(p);
-  }else
-#endif /* !defined(SQLITE_SHELL_FIDDLE) */
-
-#ifndef SQLITE_UNTESTABLE
-  if( c=='i' && cli_strncmp(azArg[0], "imposter", n)==0 ){
-    char *zSql;
-    char *zCollist = 0;
-    sqlite3_stmt *pStmt;
-    int tnum = 0;
-    int isWO = 0;  /* True if making an imposter of a WITHOUT ROWID table */
-    int lenPK = 0; /* Length of the PRIMARY KEY string for isWO tables */
-    int i;
-    if( !(nArg==3 || (nArg==2 && sqlite3_stricmp(azArg[1],"off")==0)) ){
-      eputz("Usage: .imposter INDEX IMPOSTER\n"
-            "       .imposter off\n");
-      /* Also allowed, but not documented:
-      **
-      **    .imposter TABLE IMPOSTER
-      **
-      ** where TABLE is a WITHOUT ROWID table.  In that case, the
-      ** imposter is another WITHOUT ROWID table with the columns in
-      ** storage order. */
-      rc = 1;
-      goto meta_command_exit;
-    }
-    open_db(p, 0);
-    if( nArg==2 ){
-      sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 1);
-      goto meta_command_exit;
-    }
-    zSql = sqlite3_mprintf(
-      "SELECT rootpage, 0 FROM sqlite_schema"
-      " WHERE type='index' AND lower(name)=lower('%q')"
-      "UNION ALL "
-      "SELECT rootpage, 1 FROM sqlite_schema"
-      " WHERE type='table' AND lower(name)=lower('%q')"
-      "   AND sql LIKE '%%without%%rowid%%'",
-      azArg[1], azArg[1]
-    );
-    sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-    sqlite3_free(zSql);
-    if( sqlite3_step(pStmt)==SQLITE_ROW ){
-      tnum = sqlite3_column_int(pStmt, 0);
-      isWO = sqlite3_column_int(pStmt, 1);
-    }
-    sqlite3_finalize(pStmt);
-    zSql = sqlite3_mprintf("PRAGMA index_xinfo='%q'", azArg[1]);
-    rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-    sqlite3_free(zSql);
-    i = 0;
-    while( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
-      char zLabel[20];
-      const char *zCol = (const char*)sqlite3_column_text(pStmt,2);
-      i++;
-      if( zCol==0 ){
-        if( sqlite3_column_int(pStmt,1)==-1 ){
-          zCol = "_ROWID_";
-        }else{
-          sqlite3_snprintf(sizeof(zLabel),zLabel,"expr%d",i);
-          zCol = zLabel;
-        }
-      }
-      if( isWO && lenPK==0 && sqlite3_column_int(pStmt,5)==0 && zCollist ){
-        lenPK = (int)strlen(zCollist);
-      }
-      if( zCollist==0 ){
-        zCollist = sqlite3_mprintf("\"%w\"", zCol);
-      }else{
-        zCollist = sqlite3_mprintf("%z,\"%w\"", zCollist, zCol);
-      }
-    }
-    sqlite3_finalize(pStmt);
-    if( i==0 || tnum==0 ){
-      cli_printf(stderr,"no such index: \"%s\"\n", azArg[1]);
-      rc = 1;
-      sqlite3_free(zCollist);
-      goto meta_command_exit;
-    }
-    if( lenPK==0 ) lenPK = 100000;
-    zSql = sqlite3_mprintf(
-          "CREATE TABLE \"%w\"(%s,PRIMARY KEY(%.*s))WITHOUT ROWID",
-          azArg[2], zCollist, lenPK, zCollist);
-    sqlite3_free(zCollist);
-    rc = sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 2, tnum);
-    if( rc==SQLITE_OK ){
-      rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
-      sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->db, "main", 0, 0);
-      if( rc ){
-        cli_printf(stderr,
-              "Error in [%s]: %s\n", zSql, sqlite3_errmsg(p->db));
-      }else{
-        cli_printf(stdout, "%s;\n", zSql);
-      }
-    }else{
-      cli_printf(stderr,"SQLITE_TESTCTRL_IMPOSTER returns %d\n", rc);
-      rc = 1;
-    }
-    sqlite3_free(zSql);
-  }else
-#endif /* !defined(SQLITE_OMIT_TEST_CONTROL) */
-
-  if( c=='i' && (cli_strncmp(azArg[0], "indices", n)==0
-                 || cli_strncmp(azArg[0], "indexes", n)==0)
-  ){
-    sqlite3_str *pSql;
-    int i;
-    int allFlag = 0;
-    int sysFlag = 0;
-    int exprFlag = 0;
-    int debugFlag = 0;  /* Undocument --debug flag */
-    const char *zPattern = 0;
-    const char *zSep = "WHERE";
-
-    for(i=1; i<nArg; i++){
-      if( azArg[i][0]=='-' ){
-        const char *z = azArg[i]+1;
-        if( z[0]=='-' ) z++;
-        if( cli_strcmp(z,"all")==0 || cli_strcmp(z,"a")==0 ){
-          allFlag = 1;
-        }else
-        if( cli_strcmp(z,"sys")==0 ){
-          sysFlag = 1;
-          allFlag = 0;
-        }else
-        if( cli_strcmp(z,"expr")==0 ){
-          exprFlag = 1;
-          allFlag = 0;
-        }else
-        if( cli_strcmp(z,"debug")==0 ){
-          debugFlag = 1;
-        }else
-        {
-          dotCmdError(p, i, "unknown option", 0);
-          rc = 1;
-          goto meta_command_exit;
-        }
-      }else if( zPattern==0 ){
-        zPattern = azArg[i];
-      }else{
-        dotCmdError(p, i, "unknown argument", 0);
-        rc = 1;
-        goto meta_command_exit;
-      }
-    }
-
-    open_db(p, 0);
-    pSql = sqlite3_str_new(p->db);
-    sqlite3_str_appendf(pSql,
-      "SELECT if(t.schema='main',i.name,t.schema||'.'||i.name)\n"
-      "FROM pragma_table_list t, pragma_index_list(t.name,t.schema) i\n"
-    );
-    if( exprFlag ){
-      allFlag = 0;
-      sqlite3_str_appendf(pSql,
-        "%s (EXISTS(SELECT 1 FROM pragma_index_xinfo(i.name) WHERE cid=-2)\n"
-        "       OR\n"
-        "       EXISTS(SELECT cid FROM pragma_table_xinfo(t.name) WHERE hidden=2"
-        " INTERSECT "
-        " SELECT cid FROM pragma_index_info(i.name)))\n", zSep);
-      zSep = "AND";
-    }
-    if( sysFlag ){
-      sqlite3_str_appendf(pSql,
-           "%s i.name LIKE 'sqlite__autoindex__%%' ESCAPE '_'\n", zSep);
-      zSep = "AND";
-    }else if( !allFlag ){
-      sqlite3_str_appendf(pSql,
-           "%s i.name NOT LIKE 'sqlite__%%' ESCAPE '_'\n", zSep);
-      zSep = "AND";
-    }
-    if( zPattern ){
-      sqlite3_str_appendf(pSql, "%s i.name LIKE '%%%q%%'\n", zSep, zPattern);
-    }
-    sqlite3_str_appendf(pSql, "ORDER BY 1");
-
-    /* Run the SQL statement in "split" mode. */
-    if( debugFlag ){
-      cli_printf(stdout,"%s;\n", sqlite3_str_value(pSql));
-    }else{
-      modePush(p);
-      modeChange(p, MODE_Split);
-      shell_exec(p, sqlite3_str_value(pSql), 0);
-      modePop(p);
-    }
-    sqlite3_str_free(pSql);
-  }else
-
-  if( c=='i' && cli_strncmp(azArg[0], "intck", n)==0 ){
-    i64 iArg = 0;
-    if( nArg==2 ){
-      iArg = integerValue(azArg[1]);
-      if( iArg==0 ) iArg = -1;
-    }
-    if( (nArg!=1 && nArg!=2) || iArg<0 ){
-      cli_printf(stderr,"%s","Usage: .intck STEPS_PER_UNLOCK\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    open_db(p, 0);
-    rc = intckDatabaseCmd(p, iArg);
-  }else
-
-#ifdef SQLITE_ENABLE_IOTRACE
-  if( c=='i' && cli_strncmp(azArg[0], "iotrace", n)==0 ){
-    SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
-    if( iotrace && iotrace!=stdout ) fclose(iotrace);
-    iotrace = 0;
-    if( nArg<2 ){
-      sqlite3IoTrace = 0;
-    }else if( cli_strcmp(azArg[1], "-")==0 ){
-      sqlite3IoTrace = iotracePrintf;
-      iotrace = stdout;
-    }else{
-      iotrace = sqlite3_fopen(azArg[1], "w");
-      if( iotrace==0 ){
-        cli_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
-        sqlite3IoTrace = 0;
-        rc = 1;
-      }else{
-        sqlite3IoTrace = iotracePrintf;
-      }
-    }
-  }else
-#endif
-
-  if( c=='l' && n>=5 && cli_strncmp(azArg[0], "limits", n)==0 ){
-    static const struct {
-       const char *zLimitName;   /* Name of a limit */
-       int limitCode;            /* Integer code for that limit */
-    } aLimit[] = {
-      { "length",                SQLITE_LIMIT_LENGTH                    },
-      { "sql_length",            SQLITE_LIMIT_SQL_LENGTH                },
-      { "column",                SQLITE_LIMIT_COLUMN                    },
-      { "expr_depth",            SQLITE_LIMIT_EXPR_DEPTH                },
-      { "parser_depth",          SQLITE_LIMIT_PARSER_DEPTH              },
-      { "compound_select",       SQLITE_LIMIT_COMPOUND_SELECT           },
-      { "vdbe_op",               SQLITE_LIMIT_VDBE_OP                   },
-      { "function_arg",          SQLITE_LIMIT_FUNCTION_ARG              },
-      { "attached",              SQLITE_LIMIT_ATTACHED                  },
-      { "like_pattern_length",   SQLITE_LIMIT_LIKE_PATTERN_LENGTH       },
-      { "variable_number",       SQLITE_LIMIT_VARIABLE_NUMBER           },
-      { "trigger_depth",         SQLITE_LIMIT_TRIGGER_DEPTH             },
-      { "worker_threads",        SQLITE_LIMIT_WORKER_THREADS            },
-    };
-    int i, n2;
-    open_db(p, 0);
-    if( nArg==1 ){
-      for(i=0; i<ArraySize(aLimit); i++){
-        cli_printf(stdout, "%20s %d\n", aLimit[i].zLimitName,
-              sqlite3_limit(p->db, aLimit[i].limitCode, -1));
-      }
-    }else if( nArg>3 ){
-      eputz("Usage: .limit NAME ?NEW-VALUE?\n");
-      rc = 1;
-      goto meta_command_exit;
-    }else{
-      int iLimit = -1;
-      n2 = strlen30(azArg[1]);
-      for(i=0; i<ArraySize(aLimit); i++){
-        if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
-          if( iLimit<0 ){
-            iLimit = i;
-          }else{
-            cli_printf(stderr,"ambiguous limit: \"%s\"\n", azArg[1]);
-            rc = 1;
-            goto meta_command_exit;
-          }
-        }
-      }
-      if( iLimit<0 ){
-        cli_printf(stderr,"unknown limit: \"%s\"\n"
-              "enter \".limits\" with no arguments for a list.\n",
-              azArg[1]);
-        rc = 1;
-        goto meta_command_exit;
-      }
-      if( nArg==3 ){
-        sqlite3_limit(p->db, aLimit[iLimit].limitCode,
-                      (int)integerValue(azArg[2]));
-      }else{
-        cli_printf(stdout, "%20s %d\n", aLimit[iLimit].zLimitName,
-              sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
-      }
-    }
-  }else
-
-  if( c=='l' && n>2 && cli_strncmp(azArg[0], "lint", n)==0 ){
-    open_db(p, 0);
-    lintDotCommand(p, azArg, nArg);
-  }else
-
-#if !defined(SQLITE_OMIT_LOAD_EXTENSION) && !defined(SQLITE_SHELL_FIDDLE)
-  if( c=='l' && cli_strncmp(azArg[0], "load", n)==0 ){
-    const char *zFile, *zProc;
-    char *zErrMsg = 0;
-    failIfSafeMode(p, "cannot run .load in safe mode");
-    if( nArg<2 || azArg[1][0]==0 ){
-      /* Must have a non-empty FILE. (Will not load self.) */
-      eputz("Usage: .load FILE ?ENTRYPOINT?\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    zFile = azArg[1];
-    zProc = nArg>=3 ? azArg[2] : 0;
-    open_db(p, 0);
-    rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
-    if( rc!=SQLITE_OK ){
-      shellEmitError(zErrMsg);
-      sqlite3_free(zErrMsg);
-      rc = 1;
-    }
-  }else
-#endif
-
-  if( c=='l' && cli_strncmp(azArg[0], "log", n)==0 ){
-    if( nArg!=2 ){
-      eputz("Usage: .log FILENAME\n");
-      rc = 1;
-    }else{
-      const char *zFile = azArg[1];
-      if( p->bSafeMode
-       && cli_strcmp(zFile,"on")!=0
-       && cli_strcmp(zFile,"off")!=0
-      ){
-        sputz(stdout, "cannot set .log to anything other"
-              " than \"on\" or \"off\"\n");
-        zFile = "off";
-      }
-      output_file_close(p->pLog);
-      if( cli_strcmp(zFile,"on")==0 ) zFile = "stdout";
-      p->pLog = output_file_open(p, zFile);
-    }
-  }else
-
-  if( c=='m' && cli_strncmp(azArg[0], "mode", n)==0 ){
-    rc = dotCmdMode(p);
-  }else
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( c=='n' && cli_strcmp(azArg[0], "nonce")==0 ){
-    if( nArg!=2 ){
-      eputz("Usage: .nonce NONCE\n");
-      rc = 1;
-    }else if( p->zNonce==0 || cli_strcmp(azArg[1],p->zNonce)!=0 ){
-      cli_printf(stderr,"line %lld: incorrect nonce: \"%s\"\n",
-            p->lineno, azArg[1]);
-      cli_exit(1);
-    }else{
-      p->bSafeMode = 0;
-      return 0;  /* Return immediately to bypass the safe mode reset
-                 ** at the end of this procedure */
-    }
-  }else
-#endif /* !defined(SQLITE_SHELL_FIDDLE) */
-
-  if( c=='n' && cli_strncmp(azArg[0], "nullvalue", n)==0 ){
-    if( nArg==2 ){
-      modeSetStr(&p->mode.spec.zNull, azArg[1]);
-    }else{
-      eputz("Usage: .nullvalue STRING\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='o' && cli_strncmp(azArg[0], "open", n)==0 && n>=2 ){
-    const char *zFN = 0;     /* Pointer to constant filename */
-    char *zNewFilename = 0;  /* Name of the database file to open */
-    int iName = 1;           /* Index in azArg[] of the filename */
-    int newFlag = 0;         /* True to delete file before opening */
-    int openMode = SHELL_OPEN_UNSPEC;
-    int openFlags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
-
-    if( p->bSafeMode ) openFlags = SQLITE_OPEN_READONLY;
-
-    /* Check for command-line arguments */
-    for(iName=1; iName<nArg; iName++){
-      const char *z = azArg[iName];
-#ifndef SQLITE_SHELL_FIDDLE
-      if( optionMatch(z,"new") ){
-        newFlag = 1;
-#ifdef SQLITE_HAVE_ZLIB
-      }else if( optionMatch(z, "zip") && !p->bSafeMode ){
-        openMode = SHELL_OPEN_ZIPFILE;
-#endif
-      }else if( optionMatch(z, "append") && !p->bSafeMode ){
-        openMode = SHELL_OPEN_APPENDVFS;
-      }else if( optionMatch(z, "readonly") ){
-        openFlags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
-        openFlags |= SQLITE_OPEN_READONLY;
-      }else if( optionMatch(z, "exclusive") ){
-        openFlags |= SQLITE_OPEN_EXCLUSIVE;
-      }else if( optionMatch(z, "ifexists") ){
-        openFlags &= ~(SQLITE_OPEN_CREATE);
-      }else if( optionMatch(z, "nofollow") ){
-        openFlags |= SQLITE_OPEN_NOFOLLOW;
-#ifndef SQLITE_OMIT_DESERIALIZE
-      }else if( optionMatch(z, "deserialize") ){
-        openMode = SHELL_OPEN_DESERIALIZE;
-      }else if( optionMatch(z, "hexdb") ){
-        openMode = SHELL_OPEN_HEXDB;
-      }else if( optionMatch(z, "normal") ){
-        openMode = SHELL_OPEN_NORMAL;
-      }else if( optionMatch(z, "maxsize") && iName+1<nArg ){
-        p->szMax = integerValue(azArg[++iName]);
-#endif /* SQLITE_OMIT_DESERIALIZE */
-      }else
-#endif /* !SQLITE_SHELL_FIDDLE */
-      if( z[0]=='-' ){
-        cli_printf(stderr,"unknown option: %s\n", z);
-        rc = 1;
-        goto meta_command_exit;
-      }else if( zFN ){
-        cli_printf(stderr,"extra argument: \"%s\"\n", z);
-        rc = 1;
-        goto meta_command_exit;
-      }else{
-        zFN = z;
-      }
-    }
-
-    /* Close the existing database */
-    session_close_all(p, -1);
-    close_db(p->db);
-    p->db = 0;
-    p->pAuxDb->zDbFilename = 0;
-    sqlite3_free(p->pAuxDb->zFreeOnClose);
-    p->pAuxDb->zFreeOnClose = 0;
-    p->openMode = openMode;
-    p->openFlags = openFlags;
-    p->szMax = 0;
-
-    /* If a filename is specified, try to open it first */
-    if( zFN || p->openMode==SHELL_OPEN_HEXDB ){
-      if( newFlag && zFN && !p->bSafeMode ){
-        if( cli_strncmp(zFN,"file:",5)==0 ){
-          char *zDel = shellFilenameFromUri(zFN);
-          shell_check_oom(zDel);
-          shellDeleteFile(zDel);
-          sqlite3_free(zDel);
-        }else{
-          shellDeleteFile(zFN);
-        }
-      }
-#ifndef SQLITE_SHELL_FIDDLE
-      if( p->bSafeMode
-       && p->openMode!=SHELL_OPEN_HEXDB
-       && zFN
-       && cli_strcmp(zFN,":memory:")!=0
-      ){
-        failIfSafeMode(p, "cannot open disk-based database files in safe mode");
-      }
-#else
-      /* WASM mode has its own sandboxed pseudo-filesystem. */
-#endif
-      if( zFN ){
-        zNewFilename = sqlite3_mprintf("%s", zFN);
-        shell_check_oom(zNewFilename);
-      }else{
-        zNewFilename = 0;
-      }
-      p->pAuxDb->zDbFilename = zNewFilename;
-      open_db(p, OPEN_DB_KEEPALIVE);
-      if( p->db==0 ){
-        cli_printf(stderr,"Error: cannot open '%s'\n", zNewFilename);
-        sqlite3_free(zNewFilename);
-      }else{
-        p->pAuxDb->zFreeOnClose = zNewFilename;
-      }
-    }
-    if( p->db==0 ){
-      /* As a fall-back open a TEMP database */
-      p->pAuxDb->zDbFilename = 0;
-      open_db(p, 0);
-    }
-  }else
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( (c=='o'
-        && (cli_strncmp(azArg[0], "output", n)==0
-            || cli_strncmp(azArg[0], "once", n)==0))
-   || (c=='e' && n==5 && cli_strcmp(azArg[0],"excel")==0)
-   || (c=='w' && n==3 && cli_strcmp(azArg[0],"www")==0)
-  ){
-    rc = dotCmdOutput(p);
-  }else
-#endif /* !defined(SQLITE_SHELL_FIDDLE) */
-
-  if( c=='p' && n>=3 && cli_strncmp(azArg[0], "parameter", n)==0 ){
-    open_db(p,0);
-    if( nArg<=1 ) goto parameter_syntax_error;
-
-    /* .parameter clear
-    ** Clear all bind parameters by dropping the TEMP table that holds them.
-    */
-    if( nArg==2 && cli_strcmp(azArg[1],"clear")==0 ){
-      sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;",
-                   0, 0, 0);
-    }else
-
-    /* .parameter list
-    ** List all bind parameters.
-    */
-    if( nArg==2 && cli_strcmp(azArg[1],"list")==0 ){
-      sqlite3_stmt *pStmt = 0;
-      int rx;
-      int len = 0;
-      rx = sqlite3_prepare_v2(p->db,
-             "SELECT max(length(key)) "
-             "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
-      if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
-        len = sqlite3_column_int(pStmt, 0);
-        if( len>40 ) len = 40;
-      }
-      sqlite3_finalize(pStmt);
-      pStmt = 0;
-      if( len ){
-        rx = sqlite3_prepare_v2(p->db,
-             "SELECT key, quote(value) "
-             "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
-        while( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
-          cli_printf(p->out,
-                "%-*s %s\n", len, sqlite3_column_text(pStmt,0),
-                sqlite3_column_text(pStmt,1));
-        }
-        sqlite3_finalize(pStmt);
-      }
-    }else
-
-    /* .parameter init
-    ** Make sure the TEMP table used to hold bind parameters exists.
-    ** Create it if necessary.
-    */
-    if( nArg==2 && cli_strcmp(azArg[1],"init")==0 ){
-      bind_table_init(p);
-    }else
-
-    /* .parameter set NAME VALUE
-    ** Set or reset a bind parameter.  NAME should be the full parameter
-    ** name exactly as it appears in the query.  (ex: $abc, @def).  The
-    ** VALUE can be in either SQL literal notation, or if not it will be
-    ** understood to be a text string.
-    */
-    if( nArg==4 && cli_strcmp(azArg[1],"set")==0 ){
-      int rx;
-      char *zSql;
-      sqlite3_stmt *pStmt;
-      const char *zKey = azArg[2];
-      const char *zValue = azArg[3];
-      bind_table_init(p);
-      zSql = sqlite3_mprintf(
-                  "REPLACE INTO temp.sqlite_parameters(key,value)"
-                  "VALUES(%Q,%s);", zKey, zValue);
-      shell_check_oom(zSql);
-      pStmt = 0;
-      rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-      sqlite3_free(zSql);
-      if( rx!=SQLITE_OK ){
-        sqlite3_finalize(pStmt);
-        pStmt = 0;
-        zSql = sqlite3_mprintf(
-                   "REPLACE INTO temp.sqlite_parameters(key,value)"
-                   "VALUES(%Q,%Q);", zKey, zValue);
-        shell_check_oom(zSql);
-        rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-        sqlite3_free(zSql);
-        if( rx!=SQLITE_OK ){
-          cli_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db));
-          sqlite3_finalize(pStmt);
-          pStmt = 0;
-          rc = 1;
-        }
-      }
-      bind_prepared_stmt(p, pStmt);
-      sqlite3_step(pStmt);
-      sqlite3_finalize(pStmt);
-    }else
-
-    /* .parameter unset NAME
-    ** Remove the NAME binding from the parameter binding table, if it
-    ** exists.
-    */
-    if( nArg==3 && cli_strcmp(azArg[1],"unset")==0 ){
-      char *zSql = sqlite3_mprintf(
-          "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]);
-      shell_check_oom(zSql);
-      sqlite3_exec(p->db, zSql, 0, 0, 0);
-      sqlite3_free(zSql);
-    }else
-    /* If no command name matches, show a syntax error */
-    parameter_syntax_error:
-    showHelp(p->out, "parameter");
-  }else
-
-  if( c=='p' && n>=3 && cli_strncmp(azArg[0], "print", n)==0 ){
-    int i;
-    for(i=1; i<nArg; i++){
-      if( i>1 ) cli_puts(" ", p->out);
-      cli_puts(azArg[i], p->out);
-    }
-    cli_puts("\n", p->out);
-  }else
-
-#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
-  if( c=='p' && n>=3 && cli_strncmp(azArg[0], "progress", n)==0 ){
-    int i;
-    int nn = 0;
-    p->flgProgress = 0;
-    p->mxProgress = 0;
-    p->nProgress = 0;
-    for(i=1; i<nArg; i++){
-      const char *z = azArg[i];
-      if( z[0]=='-' ){
-        z++;
-        if( z[0]=='-' ) z++;
-        if( cli_strcmp(z,"quiet")==0 || cli_strcmp(z,"q")==0 ){
-          p->flgProgress |= SHELL_PROGRESS_QUIET;
-          continue;
-        }
-        if( cli_strcmp(z,"reset")==0 ){
-          p->flgProgress |= SHELL_PROGRESS_RESET;
-          continue;
-        }
-        if( cli_strcmp(z,"once")==0 ){
-          p->flgProgress |= SHELL_PROGRESS_ONCE;
-          continue;
-        }
-        if( cli_strcmp(z,"timeout")==0 ){
-          if( i==nArg-1 ){
-            dotCmdError(p, i, "missing argument", 0);
-            return 1;
-          }
-          i++;
-          p->tmProgress = atof(azArg[i]);
-          if( p->tmProgress>0.0 ){
-            p->flgProgress = SHELL_PROGRESS_QUIET|SHELL_PROGRESS_TMOUT;
-            if( nn==0 ) nn = 100;
-          }
-          continue;
-        }
-        if( cli_strcmp(z,"limit")==0 ){
-          if( i+1>=nArg ){
-            eputz("Error: missing argument on --limit\n");
-            rc = 1;
-            goto meta_command_exit;
-          }else{
-            p->mxProgress = (int)integerValue(azArg[++i]);
-          }
-          continue;
-        }
-        cli_printf(stderr,"Error: unknown option: \"%s\"\n", azArg[i]);
-        rc = 1;
-        goto meta_command_exit;
-      }else{
-        nn = (int)integerValue(z);
-      }
-    }
-    open_db(p, 0);
-    sqlite3_progress_handler(p->db, nn, progress_handler, p);
-  }else
-#endif /* SQLITE_OMIT_PROGRESS_CALLBACK */
-
-  if( c=='p' && cli_strncmp(azArg[0], "prompt", n)==0 ){
-    if( nArg >= 2) {
-      shell_strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
-    }
-    if( nArg >= 3) {
-      shell_strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
-    }
-  }else
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( c=='q' && cli_strncmp(azArg[0], "quit", n)==0 ){
-    rc = 2;
-  }else
-#endif
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( c=='r' && n>=3 && cli_strncmp(azArg[0], "read", n)==0 ){
-    FILE *inSaved = p->in;
-    i64 savedLineno = p->lineno;
-    failIfSafeMode(p, "cannot run .read in safe mode");
-    if( nArg!=2 ){
-      eputz("Usage: .read FILE\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    if( azArg[1][0]=='|' ){
-#ifdef SQLITE_OMIT_POPEN
-      eputz("Error: pipes are not supported in this OS\n");
-      rc = 1;
-#else
-      p->in = sqlite3_popen(azArg[1]+1, "r");
-      if( p->in==0 ){
-        cli_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
-        rc = 1;
-      }else{
-        rc = process_input(p, "<pipe>");
-        pclose(p->in);
-      }
-#endif
-    }else if( (p->in = openChrSource(azArg[1]))==0 ){
-      cli_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
-      rc = 1;
-    }else{
-      char *zFilename = strdup(azArg[1]);
-      rc = process_input(p, zFilename);
-      free(zFilename);
-      fclose(p->in);
-    }
-    p->in = inSaved;
-    p->lineno = savedLineno;
-  }else
-#endif /* !defined(SQLITE_SHELL_FIDDLE) */
-
-#ifndef SQLITE_SHELL_FIDDLE
-  if( c=='r' && n>=3 && cli_strncmp(azArg[0], "restore", n)==0 ){
-    const char *zSrcFile;
-    const char *zDb;
-    sqlite3 *pSrc;
-    sqlite3_backup *pBackup;
-    int nTimeout = 0;
-
-    failIfSafeMode(p, "cannot run .restore in safe mode");
-    if( nArg==2 ){
-      zSrcFile = azArg[1];
-      zDb = "main";
-    }else if( nArg==3 ){
-      zSrcFile = azArg[2];
-      zDb = azArg[1];
-    }else{
-      eputz("Usage: .restore ?DB? FILE\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    rc = sqlite3_open(zSrcFile, &pSrc);
-    if( rc!=SQLITE_OK ){
-      cli_printf(stderr,"Error: cannot open \"%s\"\n", zSrcFile);
-      close_db(pSrc);
-      return 1;
-    }
-    open_db(p, 0);
-    pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
-    if( pBackup==0 ){
-      shellDatabaseError(p->db);
-      close_db(pSrc);
-      return 1;
-    }
-    while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
-          || rc==SQLITE_BUSY  ){
-      if( rc==SQLITE_BUSY ){
-        if( nTimeout++ >= 3 ) break;
-        sqlite3_sleep(100);
-      }
-    }
-    sqlite3_backup_finish(pBackup);
-    if( rc==SQLITE_DONE ){
-      rc = 0;
-    }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
-      eputz("Error: source database is busy\n");
-      rc = 1;
-    }else{
-      shellDatabaseError(p->db);
-      rc = 1;
-    }
-    close_db(pSrc);
-  }else
-#endif /* !defined(SQLITE_SHELL_FIDDLE) */
-
-  if( c=='s' &&
-     (cli_strncmp(azArg[0], "scanstats",  n)==0 ||
-      cli_strncmp(azArg[0], "scanstatus", n)==0)
-  ){
-    if( nArg==2 ){
-      if( cli_strcmp(azArg[1], "vm")==0 ){
-        p->mode.scanstatsOn = 3;
-      }else
-      if( cli_strcmp(azArg[1], "est")==0 ){
-        p->mode.scanstatsOn = 2;
-      }else{
-        p->mode.scanstatsOn = (u8)booleanValue(azArg[1]);
-      }
-      open_db(p, 0);
-      sqlite3_db_config(
-          p->db, SQLITE_DBCONFIG_STMT_SCANSTATUS, p->mode.scanstatsOn, (int*)0
-      );
-#if !defined(SQLITE_ENABLE_STMT_SCANSTATUS)
-      eputz("Warning: .scanstats not available in this build.\n");
-#elif !defined(SQLITE_ENABLE_BYTECODE_VTAB)
-      if( p->mode.scanstatsOn==3 ){
-        eputz("Warning: \".scanstats vm\" not available in this build.\n");
-      }
-#endif
-    }else{
-      eputz("Usage: .scanstats on|off|est\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='s' && cli_strncmp(azArg[0], "schema", n)==0 ){
-    ShellState data;
-    char *zErrMsg = 0;
-    const char *zDiv = "(";
-    const char *zName = 0;
-    int iSchema = 0;
-    int bDebug = 0;
-    int bNoSystemTabs = 0;
-    int bIndent = 0;
-    int ii;
-    sqlite3_str *pSql;
-    sqlite3_stmt *pStmt = 0;
- 
-    open_db(p, 0);
-    memcpy(&data, p, sizeof(data));
-    data.mode.spec.bTitles = QRF_No;
-    data.mode.eMode = MODE_List;
-    data.mode.spec.eText = QRF_TEXT_Plain;
-    data.mode.spec.nCharLimit = 0;
-    data.mode.spec.zRowSep = "\n";
-    for(ii=1; ii<nArg; ii++){
-      if( optionMatch(azArg[ii],"indent") ){
-        bIndent = 1;
-      }else if( optionMatch(azArg[ii],"debug") ){
-        bDebug = 1;
-      }else if( optionMatch(azArg[ii],"nosys") ){
-        bNoSystemTabs = 1;
-      }else if( azArg[ii][0]=='-' ){
-        cli_printf(stderr,"Unknown option: \"%s\"\n", azArg[ii]);
-        rc = 1;
-        goto meta_command_exit;
-      }else if( zName==0 ){
-        zName = azArg[ii];
-      }else{
-        eputz("Usage: .schema ?--indent? ?--nosys? ?LIKE-PATTERN?\n");
-        rc = 1;
-        goto meta_command_exit;
-      }
-    }
-    if( zName!=0 ){
-      int isSchema = sqlite3_strlike(zName, "sqlite_master", '\\')==0
-                  || sqlite3_strlike(zName, "sqlite_schema", '\\')==0
-                  || sqlite3_strlike(zName,"sqlite_temp_master", '\\')==0
-                  || sqlite3_strlike(zName,"sqlite_temp_schema", '\\')==0;
-      if( isSchema ){
-        cli_printf(p->out,
-                      "CREATE TABLE %ssqlite_schema (\n"
-                      "  type text,\n"
-                      "  name text,\n"
-                      "  tbl_name text,\n"
-                      "  rootpage integer,\n"
-                      "  sql text\n"
-                      ");\n",
-               sqlite3_strlike("sqlite_t%",zName,0)==0 ? "temp." : ""
-        );
-      }
-    }
-    rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
-    if( rc ){
-      shellDatabaseError(p->db);
-      sqlite3_finalize(pStmt);
-      
-      rc = 1;
-      goto meta_command_exit;
-    }
-    pSql = sqlite3_str_new(p->db);
-    sqlite3_str_appendf(pSql, "SELECT sql FROM", 0);
-    iSchema = 0;
-    while( sqlite3_step(pStmt)==SQLITE_ROW ){
-      const char *zDb = (const char*)sqlite3_column_text(pStmt, 1);
-      char zScNum[30];
-      sqlite3_snprintf(sizeof(zScNum), zScNum, "%d", ++iSchema);
-      sqlite3_str_appendall(pSql, zDiv);
-      zDiv = " UNION ALL ";
-      if( sqlite3_stricmp(zDb, "main")==0 ){
-        sqlite3_str_appendf(pSql,
-            "SELECT shell_format_schema(shell_add_schema(sql,NULL,name),%d)",
-            bIndent);
-      }else{
-        sqlite3_str_appendf(pSql,
-            "SELECT shell_format_schema(shell_add_schema(sql,%Q,name),%d)",
-            zDb, bIndent);
-      }
-      sqlite3_str_appendf(pSql,
-         " AS sql, type, tbl_name, name, rowid, %d AS snum, %Q as sname",
-         ++iSchema, zDb);
-      sqlite3_str_appendf(pSql," FROM \"%w\".sqlite_schema", zDb);
-    }
-    sqlite3_finalize(pStmt);
-#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS) \
- && !defined(SQLITE_OMIT_VIRTUALTABLE)
-    if( zName ){
-      sqlite3_str_appendall(pSql,
-         " UNION ALL SELECT shell_module_schema(name),"
-         " 'table', name, name, name, 9e+99, 'main' FROM pragma_module_list");
-    }
-#endif
-    sqlite3_str_appendf(pSql, ") WHERE ", 0);
-    if( zName ){
-      int bGlob;
-      bGlob = strchr(zName, '*') != 0 || strchr(zName, '?') != 0 ||
-              strchr(zName, '[') != 0;
-      if( strchr(zName, '.') ){
-        sqlite3_str_appendall(pSql, "lower(format('%%s.%%s',sname,tbl_name))");
-      }else{
-        sqlite3_str_appendall(pSql, "lower(tbl_name)");
-      }
-      if( bGlob ){
-        sqlite3_str_appendf(pSql, " GLOB %Q AND ", zName);
-      }else{
-        sqlite3_str_appendf(pSql, " LIKE %Q ESCAPE '\\' AND ", zName);
-      }
-    }
-    if( bNoSystemTabs ){
-      sqlite3_str_appendf(pSql, " name NOT LIKE 'sqlite__%%' ESCAPE '_' AND ");
-    }
-    sqlite3_str_appendf(pSql, "sql IS NOT NULL ORDER BY snum, rowid");
-    if( bDebug ){
-      cli_printf(p->out, "SQL: %s;\n", sqlite3_str_value(pSql));
-    }else{
-      rc = shell_exec(&data, sqlite3_str_value(pSql), &zErrMsg);
-    }
-    sqlite3_str_free(pSql);
-
-    if( zErrMsg ){
-      shellEmitError(zErrMsg);
-      sqlite3_free(zErrMsg);
-      rc = 1;
-    }else if( rc != SQLITE_OK ){
-      eputz("Error: querying schema information\n");
-      rc = 1;
-    }else{
-      rc = 0;
-    }
-  }else
-
-  if( (c=='s' && n==11 && cli_strncmp(azArg[0], "selecttrace", n)==0)
-   || (c=='t' && n==9  && cli_strncmp(azArg[0], "treetrace", n)==0)
-  ){
-    unsigned int x = nArg>=2? (unsigned int)integerValue(azArg[1]) : 0xffffffff;
-    sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &x);
-  }else
-
-#if defined(SQLITE_ENABLE_SESSION)
-  if( c=='s' && cli_strncmp(azArg[0],"session",n)==0 && n>=3 ){
-    struct AuxDb *pAuxDb = p->pAuxDb;
-    OpenSession *pSession = &pAuxDb->aSession[0];
-    char **azCmd = &azArg[1];
-    int iSes = 0;
-    int nCmd = nArg - 1;
-    int i;
-    if( nArg<=1 ) goto session_syntax_error;
-    open_db(p, 0);
-    if( nArg>=3 ){
-      for(iSes=0; iSes<pAuxDb->nSession; iSes++){
-        if( cli_strcmp(pAuxDb->aSession[iSes].zName, azArg[1])==0 ) break;
-      }
-      if( iSes<pAuxDb->nSession ){
-        pSession = &pAuxDb->aSession[iSes];
-        azCmd++;
-        nCmd--;
-      }else{
-        pSession = &pAuxDb->aSession[0];
-        iSes = 0;
-      }
-    }
-
-    /* .session attach TABLE
-    ** Invoke the sqlite3session_attach() interface to attach a particular
-    ** table so that it is never filtered.
-    */
-    if( cli_strcmp(azCmd[0],"attach")==0 ){
-      if( nCmd!=2 ) goto session_syntax_error;
-      if( pSession->p==0 ){
-        session_not_open:
-        eputz("ERROR: No sessions are open\n");
-      }else{
-        rc = sqlite3session_attach(pSession->p, azCmd[1]);
-        if( rc ){
-          cli_printf(stderr,
-               "ERROR: sqlite3session_attach() returns %d\n",rc);
-          rc = 0;
-        }
-      }
-    }else
-
-    /* .session changeset FILE
-    ** .session patchset FILE
-    ** Write a changeset or patchset into a file.  The file is overwritten.
-    */
-    if( cli_strcmp(azCmd[0],"changeset")==0
-     || cli_strcmp(azCmd[0],"patchset")==0
-    ){
-      FILE *out = 0;
-      failIfSafeMode(p, "cannot run \".session %s\" in safe mode", azCmd[0]);
-      if( nCmd!=2 ) goto session_syntax_error;
-      if( pSession->p==0 ) goto session_not_open;
-      out = sqlite3_fopen(azCmd[1], "wb");
-      if( out==0 ){
-        cli_printf(stderr,"ERROR: cannot open \"%s\" for writing\n",
-              azCmd[1]);
-      }else{
-        int szChng;
-        void *pChng;
-        if( azCmd[0][0]=='c' ){
-          rc = sqlite3session_changeset(pSession->p, &szChng, &pChng);
-        }else{
-          rc = sqlite3session_patchset(pSession->p, &szChng, &pChng);
-        }
-        if( rc ){
-          cli_printf(stdout, "Error: error code %d\n", rc);
-          rc = 0;
-        }
-        if( pChng
-          && fwrite(pChng, szChng, 1, out)!=1 ){
-          cli_printf(stderr,
-              "ERROR: Failed to write entire %d-byte output\n", szChng);
-        }
-        sqlite3_free(pChng);
-        fclose(out);
-      }
-    }else
-
-    /* .session close
-    ** Close the identified session
-    */
-    if( cli_strcmp(azCmd[0], "close")==0 ){
-      if( nCmd!=1 ) goto session_syntax_error;
-      if( pAuxDb->nSession ){
-        session_close(pSession);
-        pAuxDb->aSession[iSes] = pAuxDb->aSession[--pAuxDb->nSession];
-      }
-    }else
-
-    /* .session enable ?BOOLEAN?
-    ** Query or set the enable flag
-    */
-    if( cli_strcmp(azCmd[0], "enable")==0 ){
-      int ii;
-      if( nCmd>2 ) goto session_syntax_error;
-      ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
-      if( pAuxDb->nSession ){
-        ii = sqlite3session_enable(pSession->p, ii);
-        cli_printf(p->out,
-            "session %s enable flag = %d\n", pSession->zName, ii);
-      }
-    }else
-
-    /* .session filter GLOB ....
-    ** Set a list of GLOB patterns of table names to be excluded.
-    */
-    if( cli_strcmp(azCmd[0], "filter")==0 ){
-      int ii;
-      i64 nByte;
-      if( nCmd<2 ) goto session_syntax_error;
-      if( pAuxDb->nSession ){
-        for(ii=0; ii<pSession->nFilter; ii++){
-          sqlite3_free(pSession->azFilter[ii]);
-        }
-        sqlite3_free(pSession->azFilter);
-        nByte = sizeof(pSession->azFilter[0])*(nCmd-1);
-        pSession->azFilter = sqlite3_malloc64( nByte );
-        shell_check_oom( pSession->azFilter );
-        for(ii=1; ii<nCmd; ii++){
-          char *x = pSession->azFilter[ii-1] = sqlite3_mprintf("%s", azCmd[ii]);
-          shell_check_oom(x);
-        }
-        pSession->nFilter = ii-1;
-      }
-    }else
-
-    /* .session indirect ?BOOLEAN?
-    ** Query or set the indirect flag
-    */
-    if( cli_strcmp(azCmd[0], "indirect")==0 ){
-      int ii;
-      if( nCmd>2 ) goto session_syntax_error;
-      ii = nCmd==1 ? -1 : booleanValue(azCmd[1]);
-      if( pAuxDb->nSession ){
-        ii = sqlite3session_indirect(pSession->p, ii);
-        cli_printf(p->out,
-            "session %s indirect flag = %d\n", pSession->zName, ii);
-      }
-    }else
-
-    /* .session isempty
-    ** Determine if the session is empty
-    */
-    if( cli_strcmp(azCmd[0], "isempty")==0 ){
-      int ii;
-      if( nCmd!=1 ) goto session_syntax_error;
-      if( pAuxDb->nSession ){
-        ii = sqlite3session_isempty(pSession->p);
-        cli_printf(p->out,
-             "session %s isempty flag = %d\n", pSession->zName, ii);
-      }
-    }else
-
-    /* .session list
-    ** List all currently open sessions
-    */
-    if( cli_strcmp(azCmd[0],"list")==0 ){
-      for(i=0; i<pAuxDb->nSession; i++){
-        cli_printf(p->out, "%d %s\n", i, pAuxDb->aSession[i].zName);
-      }
-    }else
-
-    /* .session open DB NAME
-    ** Open a new session called NAME on the attached database DB.
-    ** DB is normally "main".
-    */
-    if( cli_strcmp(azCmd[0],"open")==0 ){
-      char *zName;
-      if( nCmd!=3 ) goto session_syntax_error;
-      zName = azCmd[2];
-      if( zName[0]==0 ) goto session_syntax_error;
-      for(i=0; i<pAuxDb->nSession; i++){
-        if( cli_strcmp(pAuxDb->aSession[i].zName,zName)==0 ){
-          cli_printf(stderr,"Session \"%s\" already exists\n", zName);
-          goto meta_command_exit;
-        }
-      }
-      if( pAuxDb->nSession>=ArraySize(pAuxDb->aSession) ){
-        cli_printf(stderr,
-           "Maximum of %d sessions\n", ArraySize(pAuxDb->aSession));
-        goto meta_command_exit;
-      }
-      pSession = &pAuxDb->aSession[pAuxDb->nSession];
-      rc = sqlite3session_create(p->db, azCmd[1], &pSession->p);
-      if( rc ){
-        cli_printf(stderr,"Cannot open session: error code=%d\n", rc);
-        rc = 0;
-        goto meta_command_exit;
-      }
-      pSession->nFilter = 0;
-      sqlite3session_table_filter(pSession->p, session_filter, pSession);
-      pAuxDb->nSession++;
-      pSession->zName = sqlite3_mprintf("%s", zName);
-      shell_check_oom(pSession->zName);
-    }else
-    /* If no command name matches, show a syntax error */
-    session_syntax_error:
-    showHelp(p->out, "session");
-  }else
-#endif
-
-#ifdef SQLITE_DEBUG
-  /* Undocumented commands for internal testing.  Subject to change
-  ** without notice. */
-  if( c=='s' && n>=10 && cli_strncmp(azArg[0], "selftest-", 9)==0 ){
-    if( cli_strncmp(azArg[0]+9, "boolean", n-9)==0 ){
-      int i, v;
-      for(i=1; i<nArg; i++){
-        v = booleanValue(azArg[i]);
-        cli_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
-      }
-    }
-    if( cli_strncmp(azArg[0]+9, "integer", n-9)==0 ){
-      int i; sqlite3_int64 v;
-      for(i=1; i<nArg; i++){
-        char zBuf[200];
-        v = integerValue(azArg[i]);
-        sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
-        cli_puts(zBuf, p->out);
-      }
-    }
-  }else
-#endif
-
-  if( c=='s' && n>=4 && cli_strncmp(azArg[0],"selftest",n)==0 ){
-    int bIsInit = 0;         /* True to initialize the SELFTEST table */
-    int bVerbose = 0;        /* Verbose output */
-    int bSelftestExists;     /* True if SELFTEST already exists */
-    int i, k;                /* Loop counters */
-    int nTest = 0;           /* Number of tests runs */
-    int nErr = 0;            /* Number of errors seen */
-    ShellText str;           /* Answer for a query */
-    sqlite3_stmt *pStmt = 0; /* Query against the SELFTEST table */
-
-    open_db(p,0);
-    for(i=1; i<nArg; i++){
-      const char *z = azArg[i];
-      if( z[0]=='-' && z[1]=='-' ) z++;
-      if( cli_strcmp(z,"-init")==0 ){
-        bIsInit = 1;
-      }else
-      if( cli_strcmp(z,"-v")==0 ){
-        bVerbose++;
-      }else
-      {
-        cli_printf(stderr,
-              "Unknown option \"%s\" on \"%s\"\n", azArg[i], azArg[0]);
-        cli_puts("Should be one of: --init -v\n", stderr);
-        rc = 1;
-        goto meta_command_exit;
-      }
-    }
-    if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
-           != SQLITE_OK ){
-      bSelftestExists = 0;
-    }else{
-      bSelftestExists = 1;
-    }
-    if( bIsInit ){
-      createSelftestTable(p);
-      bSelftestExists = 1;
-    }
-    initText(&str);
-    appendText(&str, "x", 0);
-    for(k=bSelftestExists; k>=0; k--){
-      if( k==1 ){
-        rc = sqlite3_prepare_v2(p->db,
-            "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
-            -1, &pStmt, 0);
-      }else{
-        rc = sqlite3_prepare_v2(p->db,
-          "VALUES(0,'memo','Missing SELFTEST table - default checks only',''),"
-          "      (1,'run','PRAGMA integrity_check','ok')",
-          -1, &pStmt, 0);
-      }
-      if( rc ){
-        eputz("Error querying the selftest table\n");
-        rc = 1;
-        sqlite3_finalize(pStmt);
-        goto meta_command_exit;
-      }
-      for(i=1; sqlite3_step(pStmt)==SQLITE_ROW; i++){
-        int tno = sqlite3_column_int(pStmt, 0);
-        const char *zOp = (const char*)sqlite3_column_text(pStmt, 1);
-        const char *zSql = (const char*)sqlite3_column_text(pStmt, 2);
-        const char *zAns = (const char*)sqlite3_column_text(pStmt, 3);
-
-        if( zOp==0 ) continue;
-        if( zSql==0 ) continue;
-        if( zAns==0 ) continue;
-        k = 0;
-        if( bVerbose>0 ){
-          cli_printf(stdout, "%d: %s %s\n", tno, zOp, zSql);
-        }
-        if( cli_strcmp(zOp,"memo")==0 ){
-          cli_printf(p->out, "%s\n", zSql);
-        }else
-        if( cli_strcmp(zOp,"run")==0 ){
-          char *zErrMsg = 0;
-          str.n = 0;
-          str.zTxt[0] = 0;
-          rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
-          nTest++;
-          if( bVerbose ){
-            cli_printf(p->out, "Result: %s\n", str.zTxt);
-          }
-          if( rc || zErrMsg ){
-            nErr++;
-            rc = 1;
-            cli_printf(p->out, "%d: error-code-%d: %s\n", tno, rc,zErrMsg);
-            sqlite3_free(zErrMsg);
-          }else if( cli_strcmp(zAns,str.zTxt)!=0 ){
-            nErr++;
-            rc = 1;
-            cli_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
-            cli_printf(p->out, "%d:      Got: [%s]\n", tno, str.zTxt);
-          }
-        }
-        else{
-          cli_printf(stderr,
-                "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
-          rc = 1;
-          break;
-        }
-      } /* End loop over rows of content from SELFTEST */
-      sqlite3_finalize(pStmt);
-    } /* End loop over k */
-    freeText(&str);
-    cli_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
-  }else
-
-  if( c=='s' && cli_strncmp(azArg[0], "separator", n)==0 ){
-    if( nArg<2 || nArg>3 ){
-      eputz("Usage: .separator COL ?ROW?\n");
-      rc = 1;
-    }
-    if( nArg>=2 ){
-      modeSetStr(&p->mode.spec.zColumnSep, azArg[1]);
-    }
-    if( nArg>=3 ){
-      modeSetStr(&p->mode.spec.zRowSep,azArg[2]);
-    }
-  }else
-
-  if( c=='s' && n>=4 && cli_strncmp(azArg[0],"sha3sum",n)==0 ){
-    const char *zLike = 0;   /* Which table to checksum. 0 means everything */
-    int i;                   /* Loop counter */
-    int bSchema = 0;         /* Also hash the schema */
-    int bSeparate = 0;       /* Hash each table separately */
-    int iSize = 224;         /* Hash algorithm to use */
-    int bDebug = 0;          /* Only show the query that would have run */
-    sqlite3_stmt *pStmt;     /* For querying tables names */
-    char *zSql;              /* SQL to be run */
-    char *zSep;              /* Separator */
-    ShellText sSql;          /* Complete SQL for the query to run the hash */
-    ShellText sQuery;        /* Set of queries used to read all content */
-    open_db(p, 0);
-    for(i=1; i<nArg; i++){
-      const char *z = azArg[i];
-      if( z[0]=='-' ){
-        z++;
-        if( z[0]=='-' ) z++;
-        if( cli_strcmp(z,"schema")==0 ){
-          bSchema = 1;
-        }else
-        if( cli_strcmp(z,"sha3-224")==0 || cli_strcmp(z,"sha3-256")==0
-         || cli_strcmp(z,"sha3-384")==0 || cli_strcmp(z,"sha3-512")==0
-        ){
-          iSize = atoi(&z[5]);
-        }else
-        if( cli_strcmp(z,"debug")==0 ){
-          bDebug = 1;
-        }else
-        {
-          cli_printf(stderr,
-                  "Unknown option \"%s\" on \"%s\"\n", azArg[i], azArg[0]);
-          showHelp(p->out, azArg[0]);
-          rc = 1;
-          goto meta_command_exit;
-        }
-      }else if( zLike ){
-        eputz("Usage: .sha3sum ?OPTIONS? ?LIKE-PATTERN?\n");
-        rc = 1;
-        goto meta_command_exit;
-      }else{
-        zLike = z;
-        bSeparate = 1;
-        if( sqlite3_strlike("sqlite\\_%", zLike, '\\')==0 ) bSchema = 1;
-      }
-    }
-    if( bSchema ){
-      zSql = "SELECT lower(name) as tname FROM sqlite_schema"
-             " WHERE type='table' AND coalesce(rootpage,0)>1"
-             " UNION ALL SELECT 'sqlite_schema'"
-             " ORDER BY 1 collate nocase";
-    }else{
-      zSql = "SELECT lower(name) as tname FROM sqlite_schema"
-             " WHERE type='table' AND coalesce(rootpage,0)>1"
-             " AND name NOT LIKE 'sqlite__%' ESCAPE '_'"
-             " ORDER BY 1 collate nocase";
-    }
-    sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-    initText(&sQuery);
-    initText(&sSql);
-    appendText(&sSql, "WITH [sha3sum$query](a,b) AS(",0);
-    zSep = "VALUES(";
-    while( SQLITE_ROW==sqlite3_step(pStmt) ){
-      const char *zTab = (const char*)sqlite3_column_text(pStmt,0);
-      if( zTab==0 ) continue;
-      if( zLike && sqlite3_strlike(zLike, zTab, 0)!=0 ) continue;
-      if( cli_strncmp(zTab, "sqlite_",7)!=0 ){
-        appendText(&sQuery,"SELECT * FROM ", 0);
-        appendText(&sQuery,zTab,'"');
-        appendText(&sQuery," NOT INDEXED;", 0);
-      }else if( cli_strcmp(zTab, "sqlite_schema")==0 ){
-        appendText(&sQuery,"SELECT type,name,tbl_name,sql FROM sqlite_schema"
-                           " ORDER BY name;", 0);
-      }else if( cli_strcmp(zTab, "sqlite_sequence")==0 ){
-        appendText(&sQuery,"SELECT name,seq FROM sqlite_sequence"
-                           " ORDER BY name;", 0);
-      }else if( cli_strcmp(zTab, "sqlite_stat1")==0 ){
-        appendText(&sQuery,"SELECT tbl,idx,stat FROM sqlite_stat1"
-                           " ORDER BY tbl,idx;", 0);
-      }else if( cli_strcmp(zTab, "sqlite_stat4")==0 ){
-        appendText(&sQuery, "SELECT * FROM ", 0);
-        appendText(&sQuery, zTab, 0);
-        appendText(&sQuery, " ORDER BY tbl, idx, rowid;\n", 0);
-      }
-      appendText(&sSql, zSep, 0);
-      appendText(&sSql, sQuery.zTxt, '\'');
-      sQuery.n = 0;
-      appendText(&sSql, ",", 0);
-      appendText(&sSql, zTab, '\'');
-      zSep = "),(";
-    }
-    sqlite3_finalize(pStmt);
-    if( bSeparate ){
-      zSql = sqlite3_mprintf(
-          "%s))"
-          " SELECT lower(hex(sha3_query(a,%d))) AS hash, b AS label"
-          "   FROM [sha3sum$query]",
-          sSql.zTxt, iSize);
-    }else{
-      zSql = sqlite3_mprintf(
-          "%s))"
-          " SELECT lower(hex(sha3_query(group_concat(a,''),%d))) AS hash"
-          "   FROM [sha3sum$query]",
-          sSql.zTxt, iSize);
-    }
-    shell_check_oom(zSql);
-    freeText(&sQuery);
-    freeText(&sSql);
-    if( bDebug ){
-      cli_printf(p->out, "%s\n", zSql);
-    }else{
-      shell_exec(p, zSql, 0);
-    }
-#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && !defined(SQLITE_OMIT_VIRTUALTABLE)
-    {
-      int lrc;
-      char *zRevText = /* Query for reversible to-blob-to-text check */
-        "SELECT lower(name) as tname FROM sqlite_schema\n"
-        "WHERE type='table' AND coalesce(rootpage,0)>1\n"
-        "AND name NOT LIKE 'sqlite__%%' ESCAPE '_'%s\n"
-        "ORDER BY 1 collate nocase";
-      zRevText = sqlite3_mprintf(zRevText, zLike? " AND name LIKE $tspec" : "");
-      zRevText = sqlite3_mprintf(
-          /* lower-case query is first run, producing upper-case query. */
-          "with tabcols as materialized(\n"
-          "select tname, cname\n"
-          "from ("
-          " select printf('\"%%w\"',ss.tname) as tname,"
-          " printf('\"%%w\"',ti.name) as cname\n"
-          " from (%z) ss\n inner join pragma_table_info(tname) ti))\n"
-          "select 'SELECT total(bad_text_count) AS bad_text_count\n"
-          "FROM ('||group_concat(query, ' UNION ALL ')||')' as btc_query\n"
-          " from (select 'SELECT COUNT(*) AS bad_text_count\n"
-          "FROM '||tname||' WHERE '\n"
-          "||group_concat('CAST(CAST('||cname||' AS BLOB) AS TEXT)<>'||cname\n"
-          "|| ' AND typeof('||cname||')=''text'' ',\n"
-          "' OR ') as query, tname from tabcols group by tname)"
-          , zRevText);
-      shell_check_oom(zRevText);
-      if( bDebug ) cli_printf(p->out, "%s\n", zRevText);
-      lrc = sqlite3_prepare_v2(p->db, zRevText, -1, &pStmt, 0);
-      if( lrc!=SQLITE_OK ){
-        /* assert(lrc==SQLITE_NOMEM); // might also be SQLITE_ERROR if the
-        ** user does cruel and unnatural things like ".limit expr_depth 0". */
-        rc = 1;
-      }else{
-        if( zLike ) sqlite3_bind_text(pStmt,1,zLike,-1,SQLITE_STATIC);
-        lrc = SQLITE_ROW==sqlite3_step(pStmt);
-        if( lrc ){
-          const char *zGenQuery = (char*)sqlite3_column_text(pStmt,0);
-          sqlite3_stmt *pCheckStmt;
-          lrc = sqlite3_prepare_v2(p->db, zGenQuery, -1, &pCheckStmt, 0);
-          if( bDebug ) cli_printf(p->out, "%s\n", zGenQuery);
-          if( lrc!=SQLITE_OK ){
-            rc = 1;
-          }else{
-            if( SQLITE_ROW==sqlite3_step(pCheckStmt) ){
-              double countIrreversible = sqlite3_column_double(pCheckStmt, 0);
-              if( countIrreversible>0 ){
-                int sz = (int)(countIrreversible + 0.5);
-                cli_printf(stderr,
-                      "Digest includes %d invalidly encoded text field%s.\n",
-                      sz, (sz>1)? "s": "");
-              }
-            }
-            sqlite3_finalize(pCheckStmt);
-          }
-          sqlite3_finalize(pStmt);
-        }
-      }
-      if( rc ) eputz(".sha3sum failed.\n");
-      sqlite3_free(zRevText);
-    }
-#endif /* !defined(*_OMIT_SCHEMA_PRAGMAS) && !defined(*_OMIT_VIRTUALTABLE) */
-    sqlite3_free(zSql);
-  }else
-
-#if !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE)
-  if( c=='s'
-   && (cli_strncmp(azArg[0], "shell", n)==0
-       || cli_strncmp(azArg[0],"system",n)==0)
-  ){
-    char *zCmd;
-    int i, x;
-    failIfSafeMode(p, "cannot run .%s in safe mode", azArg[0]);
-    if( nArg<2 ){
-      eputz("Usage: .system COMMAND\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
-    for(i=2; i<nArg && zCmd!=0; i++){
-      zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
-                             zCmd, azArg[i]);
-    }
-    /*consoleRestore();*/
-    x = zCmd!=0 ? system(zCmd) : 1;
-    /*consoleRenewSetup();*/
-    sqlite3_free(zCmd);
-    if( x ) cli_printf(stderr,"System command returns %d\n", x);
-  }else
-#endif /* !defined(SQLITE_NOHAVE_SYSTEM) && !defined(SQLITE_SHELL_FIDDLE) */
-
-  if( c=='s' && cli_strncmp(azArg[0], "show", n)==0 ){
-    static const char *azBool[] = { "off", "on", "trigger", "full"};
-    const char *zOut;
-    int i;
-    if( nArg!=1 ){
-      eputz("Usage: .show\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    cli_printf(p->out, "%12.12s: %s\n","echo", 
-            azBool[(p->mode.mFlags & MFLG_ECHO)!=0]);
-    cli_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->mode.autoEQP&3]);
-    cli_printf(p->out, "%12.12s: %s\n","explain",
-                             p->mode.autoExplain ? "auto" : "off");
-    cli_printf(p->out, "%12.12s: %s\n","headers",
-          azBool[p->mode.spec.bTitles==QRF_Yes]);
-    if( p->mode.spec.eStyle==QRF_STYLE_Column
-     || p->mode.spec.eStyle==QRF_STYLE_Box
-     || p->mode.spec.eStyle==QRF_STYLE_Table
-     || p->mode.spec.eStyle==QRF_STYLE_Markdown
-    ){
-      cli_printf(p->out,
-            "%12.12s: %s --wrap %d --wordwrap %s --%squote\n", "mode",
-            aModeInfo[p->mode.eMode].zName, p->mode.spec.nWrap,
-            p->mode.spec.bWordWrap==QRF_Yes ? "on" : "off",
-            p->mode.spec.eText==QRF_TEXT_Sql ? "" : "no");
-    }else{
-      cli_printf(p->out, "%12.12s: %s\n","mode", 
-                 aModeInfo[p->mode.eMode].zName);
-    }
-    cli_printf(p->out, "%12.12s: ", "nullvalue");
-    output_c_string(p->out, p->mode.spec.zNull);
-    cli_puts("\n", p->out);
-    cli_printf(p->out, "%12.12s: %s\n","output",
-          strlen30(p->outfile) ? p->outfile : "stdout");
-    cli_printf(p->out, "%12.12s: ", "colseparator");
-    output_c_string(p->out, p->mode.spec.zColumnSep);
-    cli_puts("\n", p->out);
-    cli_printf(p->out, "%12.12s: ", "rowseparator");
-    output_c_string(p->out, p->mode.spec.zRowSep);
-    cli_puts("\n", p->out);
-    switch( p->statsOn ){
-      case 0:  zOut = "off";     break;
-      default: zOut = "on";      break;
-      case 2:  zOut = "stmt";    break;
-      case 3:  zOut = "vmstep";  break;
-    }
-    cli_printf(p->out, "%12.12s: %s\n","stats", zOut);
-    cli_printf(p->out, "%12.12s: ", "width");
-    for(i=0; i<p->mode.spec.nWidth; i++){
-      cli_printf(p->out, "%d ", (int)p->mode.spec.aWidth[i]);
-    }
-    cli_puts("\n", p->out);
-    cli_printf(p->out, "%12.12s: %s\n", "filename",
-          p->pAuxDb->zDbFilename ? p->pAuxDb->zDbFilename : "");
-  }else
-
-  if( c=='s' && cli_strncmp(azArg[0], "stats", n)==0 ){
-    if( nArg==2 ){
-      if( cli_strcmp(azArg[1],"stmt")==0 ){
-        p->statsOn = 2;
-      }else if( cli_strcmp(azArg[1],"vmstep")==0 ){
-        p->statsOn = 3;
-      }else{
-        p->statsOn = (u8)booleanValue(azArg[1]);
-      }
-    }else if( nArg==1 ){
-      display_stats(p->db, p, 0);
-    }else{
-      eputz("Usage: .stats ?on|off|stmt|vmstep?\n");
-      rc = 1;
-    }
-  }else
-
-  if( (c=='t' && n>1 && cli_strncmp(azArg[0], "tables", n)==0) ){
-    sqlite3_stmt *pStmt;
-    sqlite3_str *pSql;
-    const char *zPattern = nArg>1 ? azArg[1] : 0;
-
-    open_db(p, 0);
-    rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
-    if( rc ){
-      sqlite3_finalize(pStmt);
-      return shellDatabaseError(p->db);
-    }
-
-    pSql = sqlite3_str_new(p->db);
-    while( sqlite3_step(pStmt)==SQLITE_ROW ){
-      const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
-      if( zDbName==0 ) continue;
-      if( sqlite3_str_length(pSql) ){
-        sqlite3_str_appendall(pSql, " UNION ALL ");
-      }
-      if( sqlite3_stricmp(zDbName, "main")==0 ){
-        sqlite3_str_appendall(pSql, "SELECT name FROM ");
-      }else{
-        sqlite3_str_appendf(pSql, "SELECT %Q||'.'||name FROM ", zDbName);
-      }
-      sqlite3_str_appendf(pSql, "\"%w\".sqlite_schema", zDbName);
-      sqlite3_str_appendf(pSql,
-          " WHERE type IN ('table','view')"
-          "   AND name NOT LIKE 'sqlite__%%' ESCAPE '_'"
-      );
-      if( zPattern ){
-        sqlite3_str_appendf(pSql," AND name LIKE %Q", zPattern);
-      }
-    }
-    rc = sqlite3_finalize(pStmt);
-    if( rc==SQLITE_OK ){
-      sqlite3_str_appendall(pSql, " ORDER BY 1");
-    }
-
-    /* Run the SQL statement in "split" mode. */
-    modePush(p);
-    modeChange(p, MODE_Split);
-    shell_exec(p, sqlite3_str_value(pSql), 0);
-    sqlite3_str_free(pSql);
-    modePop(p);
-    if( rc ) return shellDatabaseError(p->db);
-  }else
-
-  /* Set the p->zTestcase name and begin redirecting output into
-  ** the cli_output_capture sqlite3_str */
-  if( c=='t' && cli_strcmp(azArg[0],"testcase")==0 ){
-    rc = dotCmdTestcase(p);
-  }else
-
-#ifndef SQLITE_UNTESTABLE
-  if( c=='t' && n>=8 && cli_strncmp(azArg[0], "testctrl", n)==0 ){
-    static const struct {
-       const char *zCtrlName;   /* Name of a test-control option */
-       int ctrlCode;            /* Integer code for that option */
-       int unSafe;              /* Not valid unless --unsafe-testing */
-       const char *zUsage;      /* Usage notes */
-    } aCtrl[] = {
-    {"always",             SQLITE_TESTCTRL_ALWAYS, 1,     "BOOLEAN"         },
-    {"assert",             SQLITE_TESTCTRL_ASSERT, 1,     "BOOLEAN"         },
-  /*{"benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS,1, ""        },*/
-    {"bitvec_test",        SQLITE_TESTCTRL_BITVEC_TEST, 1, "SIZE INT-ARRAY"},
-    {"byteorder",          SQLITE_TESTCTRL_BYTEORDER, 0,  ""                },
-    {"extra_schema_checks",SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS,0,"BOOLEAN"  },
-    {"fault_install",      SQLITE_TESTCTRL_FAULT_INSTALL, 1,"args..."       },
-    {"fk_no_action",       SQLITE_TESTCTRL_FK_NO_ACTION, 0, "BOOLEAN"       },
-    {"imposter",         SQLITE_TESTCTRL_IMPOSTER,1,"SCHEMA ON/OFF ROOTPAGE"},
-    {"internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS,0,""          },
-    {"json_selfcheck",     SQLITE_TESTCTRL_JSON_SELFCHECK ,0,"BOOLEAN"      },
-    {"localtime_fault",    SQLITE_TESTCTRL_LOCALTIME_FAULT,0,"BOOLEAN"      },
-    {"never_corrupt",      SQLITE_TESTCTRL_NEVER_CORRUPT,1, "BOOLEAN"       },
-    {"optimizations",      SQLITE_TESTCTRL_OPTIMIZATIONS,0,"DISABLE-MASK ..."},
-#ifdef YYCOVERAGE
-    {"parser_coverage",    SQLITE_TESTCTRL_PARSER_COVERAGE,0,""             },
-#endif
-    {"pending_byte",       SQLITE_TESTCTRL_PENDING_BYTE,1, "OFFSET  "       },
-    {"prng_restore",       SQLITE_TESTCTRL_PRNG_RESTORE,0, ""               },
-    {"prng_save",          SQLITE_TESTCTRL_PRNG_SAVE,   0, ""               },
-    {"prng_seed",          SQLITE_TESTCTRL_PRNG_SEED,   0, "SEED ?db?"      },
-    {"seek_count",         SQLITE_TESTCTRL_SEEK_COUNT,  0, ""               },
-    {"sorter_mmap",        SQLITE_TESTCTRL_SORTER_MMAP, 0, "NMAX"           },
-    {"tune",               SQLITE_TESTCTRL_TUNE,        1, "ID VALUE"       },
-    };
-    int testctrl = -1;
-    int iCtrl = -1;
-    int rc2 = 0;    /* 0: usage.  1: %d  2: %x  3: no-output */
-    int isOk = 0;
-    int i, n2;
-    const char *zCmd = 0;
-
-    open_db(p, 0);
-    zCmd = nArg>=2 ? azArg[1] : "help";
-
-    /* The argument can optionally begin with "-" or "--" */
-    if( zCmd[0]=='-' && zCmd[1] ){
-      zCmd++;
-      if( zCmd[0]=='-' && zCmd[1] ) zCmd++;
-    }
-
-    /* --help lists all test-controls */
-    if( cli_strcmp(zCmd,"help")==0 ){
-      cli_puts("Available test-controls:\n", p->out);
-      for(i=0; i<ArraySize(aCtrl); i++){
-        if( aCtrl[i].unSafe && !ShellHasFlag(p,SHFLG_TestingMode) ) continue;
-        cli_printf(p->out, "  .testctrl %s %s\n",
-              aCtrl[i].zCtrlName, aCtrl[i].zUsage);
-      }
-      rc = 1;
-      goto meta_command_exit;
-    }
-
-    /* convert testctrl text option to value. allow any unique prefix
-    ** of the option name, or a numerical value. */
-    n2 = strlen30(zCmd);
-    for(i=0; i<ArraySize(aCtrl); i++){
-      if( aCtrl[i].unSafe && !ShellHasFlag(p,SHFLG_TestingMode) ) continue;
-      if( cli_strncmp(zCmd, aCtrl[i].zCtrlName, n2)==0 ){
-        if( testctrl<0 ){
-          testctrl = aCtrl[i].ctrlCode;
-          iCtrl = i;
-        }else{
-          cli_printf(stderr,"Error: ambiguous test-control: \"%s\"\n"
-                "Use \".testctrl --help\" for help\n", zCmd);
-          rc = 1;
-          goto meta_command_exit;
-        }
-      }
-    }
-    if( testctrl<0 ){
-      cli_printf(stderr,"Error: unknown test-control: %s\n"
-            "Use \".testctrl --help\" for help\n", zCmd);
-    }else{
-      switch(testctrl){
-
-        /* Special processing for .testctrl opt MASK ...
-        ** Each MASK argument can be one of:
-        **
-        **      +LABEL       Enable the named optimization 
-        **
-        **      -LABEL       Disable the named optimization
-        **
-        **      INTEGER      Mask of optimizations to disable
-        */
-        case SQLITE_TESTCTRL_OPTIMIZATIONS: {
-          static const struct {
-             unsigned int mask;    /* Mask for this optimization */
-             unsigned int bDsply;  /* Display this on output */
-             const char *zLabel;   /* Name of optimization */
-          } aLabel[] = {
-            { 0x00000001, 1, "QueryFlattener" },
-            { 0x00000001, 0, "Flatten" },
-            { 0x00000002, 1, "WindowFunc" },
-            { 0x00000004, 1, "GroupByOrder" },
-            { 0x00000008, 1, "FactorOutConst" },
-            { 0x00000010, 1, "DistinctOpt" },
-            { 0x00000020, 1, "CoverIdxScan" },
-            { 0x00000040, 1, "OrderByIdxJoin" },
-            { 0x00000080, 1, "Transitive" },
-            { 0x00000100, 1, "OmitNoopJoin" },
-            { 0x00000200, 1, "CountOfView" },
-            { 0x00000400, 1, "CursorHints" },
-            { 0x00000800, 1, "Stat4" },
-            { 0x00001000, 1, "PushDown" },
-            { 0x00002000, 1, "SimplifyJoin" },
-            { 0x00004000, 1, "SkipScan" },
-            { 0x00008000, 1, "PropagateConst" },
-            { 0x00010000, 1, "MinMaxOpt" },
-            { 0x00020000, 1, "SeekScan" },
-            { 0x00040000, 1, "OmitOrderBy" },
-            { 0x00080000, 1, "BloomFilter" },
-            { 0x00100000, 1, "BloomPulldown" },
-            { 0x00200000, 1, "BalancedMerge" },
-            { 0x00400000, 1, "ReleaseReg" },
-            { 0x00800000, 1, "FlttnUnionAll" },
-            { 0x01000000, 1, "IndexedEXpr" },
-            { 0x02000000, 1, "Coroutines" },
-            { 0x04000000, 1, "NullUnusedCols" },
-            { 0x08000000, 1, "OnePass" },
-            { 0x10000000, 1, "OrderBySubq" },
-            { 0x20000000, 1, "StarQuery" },
-            { 0x40000000, 1, "ExistsToJoin" },
-            { 0xffffffff, 0, "All" },
-          };
-          unsigned int curOpt;
-          unsigned int newOpt;
-          unsigned int m;
-          int ii;
-          int nOff;
-          sqlite3_test_control(SQLITE_TESTCTRL_GETOPT, p->db, &curOpt);
-          newOpt = curOpt;
-          for(ii=2; ii<nArg; ii++){
-            const char *z = azArg[ii];
-            int useLabel = 0;
-            const char *zLabel = 0;
-            if( (z[0]=='+'|| z[0]=='-') && !IsDigit(z[1]) ){
-              useLabel = z[0];
-              zLabel = &z[1];
-            }else if( !IsDigit(z[0]) && z[0]!=0 && !IsDigit(z[1]) ){
-              useLabel = '+';
-              zLabel = z;
-            }else{
-              newOpt = (unsigned int)strtol(z,0,0);
-            }
-            if( useLabel ){
-              int jj;
-              for(jj=0; jj<ArraySize(aLabel); jj++){
-                if( sqlite3_stricmp(zLabel, aLabel[jj].zLabel)==0 ) break;
-              }
-              if( jj>=ArraySize(aLabel) ){
-                cli_printf(stderr,
-                    "Error: no such optimization: \"%s\"\n", zLabel);
-                cli_puts("Should be one of:", stderr);
-                for(jj=0; jj<ArraySize(aLabel); jj++){
-                  cli_printf(stderr," %s", aLabel[jj].zLabel);
-                }
-                cli_puts("\n", stderr);
-                rc = 1;
-                goto meta_command_exit;
-              }
-              if( useLabel=='+' ){
-                newOpt &= ~aLabel[jj].mask;
-              }else{
-                newOpt |= aLabel[jj].mask;
-              }
-            }
-          }
-          if( curOpt!=newOpt ){
-            sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,p->db,newOpt);
-          }
-          for(ii=nOff=0, m=1; ii<32; ii++, m <<= 1){
-            if( m & newOpt ) nOff++;
-          }
-          if( nOff<12 ){
-            cli_puts("+All", p->out);
-            for(ii=0; ii<ArraySize(aLabel); ii++){
-              if( !aLabel[ii].bDsply  ) continue;
-              if( (newOpt & aLabel[ii].mask)!=0 ){
-                cli_printf(p->out, " -%s", aLabel[ii].zLabel);
-              }
-            }
-          }else{
-            cli_puts("-All", p->out);
-            for(ii=0; ii<ArraySize(aLabel); ii++){
-              if( !aLabel[ii].bDsply  ) continue;
-              if( (newOpt & aLabel[ii].mask)==0 ){
-                cli_printf(p->out, " +%s", aLabel[ii].zLabel);
-              }
-            }
-          }
-          cli_puts("\n", p->out);
-          rc2 = isOk = 3;
-          break;
-        }
-
-        /* sqlite3_test_control(int, db, int) */
-        case SQLITE_TESTCTRL_FK_NO_ACTION:
-          if( nArg==3 ){
-            unsigned int opt = (unsigned int)strtol(azArg[2], 0, 0);
-            rc2 = sqlite3_test_control(testctrl, p->db, opt);
-            isOk = 3;
-          }
-          break;
-
-        /* sqlite3_test_control(int) */
-        case SQLITE_TESTCTRL_PRNG_SAVE:
-        case SQLITE_TESTCTRL_PRNG_RESTORE:
-        case SQLITE_TESTCTRL_BYTEORDER:
-          if( nArg==2 ){
-            rc2 = sqlite3_test_control(testctrl);
-            isOk = testctrl==SQLITE_TESTCTRL_BYTEORDER ? 1 : 3;
-          }
-          break;
-
-        /* sqlite3_test_control(int, uint) */
-        case SQLITE_TESTCTRL_PENDING_BYTE:
-          if( nArg==3 ){
-            unsigned int opt = (unsigned int)integerValue(azArg[2]);
-            rc2 = sqlite3_test_control(testctrl, opt);
-            isOk = 3;
-          }
-          break;
-
-        /* sqlite3_test_control(int, int, sqlite3*) */
-        case SQLITE_TESTCTRL_PRNG_SEED:
-          if( nArg==3 || nArg==4 ){
-            int ii = (int)integerValue(azArg[2]);
-            sqlite3 *db;
-            if( ii==0 && cli_strcmp(azArg[2],"random")==0 ){
-              sqlite3_randomness(sizeof(ii),&ii);
-              cli_printf(stdout, "-- random seed: %d\n", ii);
-            }
-            if( nArg==3 ){
-              db = 0;
-            }else{
-              db = p->db;
-              /* Make sure the schema has been loaded */
-              sqlite3_table_column_metadata(db, 0, "x", 0, 0, 0, 0, 0, 0);
-            }
-            rc2 = sqlite3_test_control(testctrl, ii, db);
-            isOk = 3;
-          }
-          break;
-
-        /* sqlite3_test_control(int, int) */
-        case SQLITE_TESTCTRL_ASSERT:
-        case SQLITE_TESTCTRL_ALWAYS:
-          if( nArg==3 ){
-            int opt = booleanValue(azArg[2]);
-            rc2 = sqlite3_test_control(testctrl, opt);
-            isOk = 1;
-          }
-          break;
-
-        /* sqlite3_test_control(int, int) */
-        case SQLITE_TESTCTRL_LOCALTIME_FAULT:
-        case SQLITE_TESTCTRL_NEVER_CORRUPT:
-          if( nArg==3 ){
-            int opt = booleanValue(azArg[2]);
-            rc2 = sqlite3_test_control(testctrl, opt);
-            isOk = 3;
-          }
-          break;
-
-        /* sqlite3_test_control(sqlite3*) */
-        case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS:
-          rc2 = sqlite3_test_control(testctrl, p->db);
-          isOk = 3;
-          break;
-
-        case SQLITE_TESTCTRL_IMPOSTER:
-          if( nArg==5 ){
-            rc2 = sqlite3_test_control(testctrl, p->db,
-                          azArg[2],
-                          integerValue(azArg[3]),
-                          integerValue(azArg[4]));
-            isOk = 3;
-          }
-          break;
-
-        case SQLITE_TESTCTRL_SEEK_COUNT: {
-          u64 x = 0;
-          rc2 = sqlite3_test_control(testctrl, p->db, &x);
-          cli_printf(p->out, "%llu\n", x);
-          isOk = 3;
-          break;
-        }
-
-#ifdef YYCOVERAGE
-        case SQLITE_TESTCTRL_PARSER_COVERAGE: {
-          if( nArg==2 ){
-            sqlite3_test_control(testctrl, p->out);
-            isOk = 3;
-          }
-          break;
-        }
-#endif
-#ifdef SQLITE_DEBUG
-        case SQLITE_TESTCTRL_TUNE: {
-          if( nArg==4 ){
-            int id = (int)integerValue(azArg[2]);
-            int val = (int)integerValue(azArg[3]);
-            sqlite3_test_control(testctrl, id, &val);
-            isOk = 3;
-          }else if( nArg==3 ){
-            int id = (int)integerValue(azArg[2]);
-            sqlite3_test_control(testctrl, -id, &rc2);
-            isOk = 1;
-          }else if( nArg==2 ){
-            int id = 1;
-            while(1){
-              int val = 0;
-              rc2 = sqlite3_test_control(testctrl, -id, &val);
-              if( rc2!=SQLITE_OK ) break;
-              if( id>1 ) cli_puts("  ", p->out);
-              cli_printf(p->out, "%d: %d", id, val);
-              id++;
-            }
-            if( id>1 ) cli_puts("\n", p->out);
-            isOk = 3;
-          }
-          break;
-        }
-#endif
-        case SQLITE_TESTCTRL_SORTER_MMAP:
-          if( nArg==3 ){
-            int opt = (unsigned int)integerValue(azArg[2]);
-            rc2 = sqlite3_test_control(testctrl, p->db, opt);
-            isOk = 3;
-          }
-          break;
-        case SQLITE_TESTCTRL_JSON_SELFCHECK:
-          if( nArg==2 ){
-            rc2 = -1;
-            isOk = 1;
-          }else{
-            rc2 = booleanValue(azArg[2]);
-            isOk = 3;
-          }
-          sqlite3_test_control(testctrl, &rc2);
-          break;
-        case SQLITE_TESTCTRL_BITVEC_TEST: {
-          /* Examples:
-          **   .testctrl bitvec_test 100   6,1       -- Show BITVEC constants
-          **   .testctrl bitvec_test 1000  1,12,7,3  -- Simple test
-          **                         ----  --------
-          **      size of Bitvec -----^        ^---  aOp array. 0 added at end.
-          **
-          ** See comments on sqlite3BitvecBuiltinTest() for more information
-          ** about the aOp[] array.
-          */
-          int iSize;
-          const char *zTestArg;
-          int nOp;
-          int ii, jj, x;
-          int *aOp;
-          if( nArg!=4 ){
-            cli_printf(stderr,
-              "ERROR - should be:  \".testctrl bitvec_test SIZE  INT-ARRAY\"\n"
-            );
-            rc = 1;
-            goto meta_command_exit;
-          }
-          isOk = 3;
-          iSize = (int)integerValue(azArg[2]);
-          zTestArg = azArg[3];
-          nOp = (int)strlen(zTestArg)+1;
-          aOp = malloc( sizeof(int)*(nOp+1) );
-          shell_check_oom(aOp);
-          memset(aOp, 0, sizeof(int)*(nOp+1) );
-          for(ii = jj = x = 0; zTestArg[ii]!=0; ii++){
-            if( IsDigit(zTestArg[ii]) ){
-              x = x*10 + zTestArg[ii] - '0';
-            }else{
-              aOp[jj++] = x;
-              x = 0;
-            }
-          }
-          aOp[jj] = x;
-          x = sqlite3_test_control(testctrl, iSize, aOp);
-          cli_printf(p->out, "result: %d\n", x);
-          free(aOp);
-          break;
-        }
-        case SQLITE_TESTCTRL_FAULT_INSTALL: {
-          int kk;
-          int bShowHelp = nArg<=2;
-          isOk = 3;
-          for(kk=2; kk<nArg; kk++){
-            const char *z = azArg[kk];
-            if( z[0]=='-' && z[1]=='-' ) z++;
-            if( cli_strcmp(z,"off")==0 ){
-              sqlite3_test_control(testctrl, 0);
-            }else if( cli_strcmp(z,"on")==0 ){
-              faultsim_state.iCnt = faultsim_state.nSkip;
-              if( faultsim_state.iErr==0 ) faultsim_state.iErr = 1;
-              faultsim_state.nHit = 0;
-              sqlite3_test_control(testctrl, faultsim_callback);
-            }else if( cli_strcmp(z,"reset")==0 ){
-              faultsim_state.iCnt = faultsim_state.nSkip;
-              faultsim_state.nHit = 0;
-              sqlite3_test_control(testctrl, faultsim_callback);
-            }else if( cli_strcmp(z,"status")==0 ){
-              cli_printf(p->out, "faultsim.iId:       %d\n",
-                              faultsim_state.iId);
-              cli_printf(p->out, "faultsim.iErr:      %d\n",
-                              faultsim_state.iErr);
-              cli_printf(p->out, "faultsim.iCnt:      %d\n",
-                              faultsim_state.iCnt);
-              cli_printf(p->out, "faultsim.nHit:      %d\n",
-                              faultsim_state.nHit);
-              cli_printf(p->out, "faultsim.iInterval: %d\n",
-                              faultsim_state.iInterval);
-              cli_printf(p->out, "faultsim.eVerbose:  %d\n",
-                              faultsim_state.eVerbose);
-              cli_printf(p->out, "faultsim.nRepeat:   %d\n",
-                              faultsim_state.nRepeat);
-              cli_printf(p->out, "faultsim.nSkip:     %d\n",
-                              faultsim_state.nSkip);
-            }else if( cli_strcmp(z,"-v")==0 ){
-              if( faultsim_state.eVerbose<2 ) faultsim_state.eVerbose++;
-            }else if( cli_strcmp(z,"-q")==0 ){
-              if( faultsim_state.eVerbose>0 ) faultsim_state.eVerbose--;
-            }else if( cli_strcmp(z,"-id")==0 && kk+1<nArg ){
-              faultsim_state.iId = atoi(azArg[++kk]);
-            }else if( cli_strcmp(z,"-errcode")==0 && kk+1<nArg ){
-              faultsim_state.iErr = atoi(azArg[++kk]);
-            }else if( cli_strcmp(z,"-interval")==0 && kk+1<nArg ){
-              faultsim_state.iInterval = atoi(azArg[++kk]);
-            }else if( cli_strcmp(z,"-repeat")==0 && kk+1<nArg ){
-              faultsim_state.nRepeat = atoi(azArg[++kk]);
-           }else if( cli_strcmp(z,"-skip")==0 && kk+1<nArg ){
-              faultsim_state.nSkip = atoi(azArg[++kk]);
-            }else if( cli_strcmp(z,"-?")==0 || sqlite3_strglob("*help*",z)==0){
-              bShowHelp = 1;
-            }else{
-              cli_printf(stderr,
-                  "Unrecognized fault_install argument: \"%s\"\n",
-                  azArg[kk]);
-              rc = 1;
-              bShowHelp = 1;
-              break;
-            }
-          }
-          if( bShowHelp ){
-            cli_puts(
-               "Usage: .testctrl fault_install ARGS\n"
-               "Possible arguments:\n"
-               "   off               Disable faultsim\n"
-               "   on                Activate faultsim\n"
-               "   reset             Reset the trigger counter\n"
-               "   status            Show current status\n"
-               "   -v                Increase verbosity\n"
-               "   -q                Decrease verbosity\n"
-               "   --errcode N       When triggered, return N as error code\n"
-               "   --id ID           Trigger only for the ID specified\n"
-               "   --interval N      Trigger only after every N-th call\n"
-               "   --repeat N        Turn off after N hits.  0 means never\n"
-               "   --skip N          Skip the first N encounters\n"
-               ,p->out
-            );
-          }
-          break;
-        }
-      }
-    }
-    if( isOk==0 && iCtrl>=0 ){
-      cli_printf(p->out,
-          "Usage: .testctrl %s %s\n", zCmd,aCtrl[iCtrl].zUsage);
-      rc = 1;
-    }else if( isOk==1 ){
-      cli_printf(p->out, "%d\n", rc2);
-    }else if( isOk==2 ){
-      cli_printf(p->out, "0x%08x\n", rc2);
-    }
-  }else
-#endif /* !defined(SQLITE_UNTESTABLE) */
-
-  if( c=='t' && n>4 && cli_strncmp(azArg[0], "timeout", n)==0 ){
-    open_db(p, 0);
-    sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
-  }else
-
-  if( c=='t' && n>=5 && cli_strncmp(azArg[0], "timer", n)==0 ){
-    if( nArg==2 ){
-      if( cli_strcmp(azArg[1],"once")==0 ){
-        p->enableTimer = 1;
-      }else{
-        p->enableTimer = 2*booleanValue(azArg[1]);
-      }
-      if( p->enableTimer && !HAS_TIMER ){
-        eputz("Error: timer not available on this system.\n");
-        p->enableTimer = 0;
-      }
-    }else{
-      eputz("Usage: .timer on|off|once\n");
-      rc = 1;
-    }
-  }else
-
-#ifndef SQLITE_OMIT_TRACE
-  if( c=='t' && cli_strncmp(azArg[0], "trace", n)==0 ){
-    int mType = 0;
-    int jj;
-    open_db(p, 0);
-    for(jj=1; jj<nArg; jj++){
-      const char *z = azArg[jj];
-      if( z[0]=='-' ){
-        if( optionMatch(z, "expanded") ){
-          p->eTraceType = SHELL_TRACE_EXPANDED;
-        }
-#ifdef SQLITE_ENABLE_NORMALIZE
-        else if( optionMatch(z, "normalized") ){
-          p->eTraceType = SHELL_TRACE_NORMALIZED;
-        }
-#endif
-        else if( optionMatch(z, "plain") ){
-          p->eTraceType = SHELL_TRACE_PLAIN;
-        }
-        else if( optionMatch(z, "profile") ){
-          mType |= SQLITE_TRACE_PROFILE;
-        }
-        else if( optionMatch(z, "row") ){
-          mType |= SQLITE_TRACE_ROW;
-        }
-        else if( optionMatch(z, "stmt") ){
-          mType |= SQLITE_TRACE_STMT;
-        }
-        else if( optionMatch(z, "close") ){
-          mType |= SQLITE_TRACE_CLOSE;
-        }
-        else {
-          cli_printf(stderr,"Unknown option \"%s\" on \".trace\"\n", z);
-          rc = 1;
-          goto meta_command_exit;
-        }
-      }else{
-        output_file_close(p->traceOut);
-        p->traceOut = output_file_open(p, z);
-      }
-    }
-    if( p->traceOut==0 ){
-      sqlite3_trace_v2(p->db, 0, 0, 0);
-    }else{
-      if( mType==0 ) mType = SQLITE_TRACE_STMT;
-      sqlite3_trace_v2(p->db, mType, sql_trace_callback, p);
-    }
-  }else
-#endif /* !defined(SQLITE_OMIT_TRACE) */
-
-#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_VIRTUALTABLE)
-  if( c=='u' && cli_strncmp(azArg[0], "unmodule", n)==0 ){
-    int ii;
-    int lenOpt;
-    char *zOpt;
-    if( nArg<2 ){
-      eputz("Usage: .unmodule [--allexcept] NAME ...\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    open_db(p, 0);
-    zOpt = azArg[1];
-    if( zOpt[0]=='-' && zOpt[1]=='-' && zOpt[2]!=0 ) zOpt++;
-    lenOpt = (int)strlen(zOpt);
-    if( lenOpt>=3 && cli_strncmp(zOpt, "-allexcept",lenOpt)==0 ){
-      assert( azArg[nArg]==0 );
-      sqlite3_drop_modules(p->db, nArg>2 ? (const char**)(azArg+2) : 0);
-    }else{
-      for(ii=1; ii<nArg; ii++){
-        sqlite3_create_module(p->db, azArg[ii], 0, 0);
-      }
-    }
-  }else
-#endif
-
-  if( c=='v' && cli_strncmp(azArg[0], "version", n)==0 ){
-    char *zPtrSz = sizeof(void*)==8 ? "64-bit" : "32-bit";
-    cli_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
-          sqlite3_libversion(), sqlite3_sourceid());
-#if SQLITE_HAVE_ZLIB
-    cli_printf(p->out, "zlib version %s\n", zlibVersion());
-#endif
-#define CTIMEOPT_VAL_(opt) #opt
-#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
-#if defined(__clang__) && defined(__clang_major__)
-    cli_printf(p->out, "clang-" CTIMEOPT_VAL(__clang_major__) "."
-          CTIMEOPT_VAL(__clang_minor__) "."
-          CTIMEOPT_VAL(__clang_patchlevel__) " (%s)\n", zPtrSz);
-#elif defined(_MSC_VER)
-    cli_printf(p->out, "msvc-" CTIMEOPT_VAL(_MSC_VER) " (%s)\n", zPtrSz);
-#elif defined(__GNUC__) && defined(__VERSION__)
-    cli_printf(p->out, "gcc-" __VERSION__ " (%s)\n", zPtrSz);
-#endif
-  }else
-
-  if( c=='v' && cli_strncmp(azArg[0], "vfsinfo", n)==0 ){
-    const char *zDbName = nArg==2 ? azArg[1] : "main";
-    sqlite3_vfs *pVfs = 0;
-    if( p->db ){
-      sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
-      if( pVfs ){
-        cli_printf(p->out, "vfs.zName      = \"%s\"\n", pVfs->zName);
-        cli_printf(p->out, "vfs.iVersion   = %d\n", pVfs->iVersion);
-        cli_printf(p->out, "vfs.szOsFile   = %d\n", pVfs->szOsFile);
-        cli_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
-      }
-    }
-  }else
-
-  if( c=='v' && cli_strncmp(azArg[0], "vfslist", n)==0 ){
-    sqlite3_vfs *pVfs;
-    sqlite3_vfs *pCurrent = 0;
-    if( p->db ){
-      sqlite3_file_control(p->db, "main", SQLITE_FCNTL_VFS_POINTER, &pCurrent);
-    }
-    for(pVfs=sqlite3_vfs_find(0); pVfs; pVfs=pVfs->pNext){
-      cli_printf(p->out, "vfs.zName      = \"%s\"%s\n", pVfs->zName,
-            pVfs==pCurrent ? "  <--- CURRENT" : "");
-      cli_printf(p->out, "vfs.iVersion   = %d\n", pVfs->iVersion);
-      cli_printf(p->out, "vfs.szOsFile   = %d\n", pVfs->szOsFile);
-      cli_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
-      if( pVfs->pNext ){
-        cli_puts("-----------------------------------\n", p->out);
-      }
-    }
-  }else
-
-  if( c=='v' && cli_strncmp(azArg[0], "vfsname", n)==0 ){
-    const char *zDbName = nArg==2 ? azArg[1] : "main";
-    char *zVfsName = 0;
-    if( p->db ){
-      sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
-      if( zVfsName ){
-        cli_printf(p->out, "%s\n", zVfsName);
-        sqlite3_free(zVfsName);
-      }
-    }
-  }else
-
-  if( c=='w' && cli_strncmp(azArg[0], "wheretrace", n)==0 ){
-    unsigned int x = nArg>=2? (unsigned int)integerValue(azArg[1]) : 0xffffffff;
-    sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 3, &x);
-  }else
-
-  if( c=='w' && cli_strncmp(azArg[0], "width", n)==0 ){
-    int j;
-    p->mode.spec.nWidth = nArg-1;
-    p->mode.spec.aWidth = realloc(p->mode.spec.aWidth,
-                                  (p->mode.spec.nWidth+1)*sizeof(short int));
-    shell_check_oom(p->mode.spec.aWidth);
-    for(j=1; j<nArg; j++){
-      i64 w = integerValue(azArg[j]);
-      if( w < -QRF_MAX_WIDTH ) w = -QRF_MAX_WIDTH;
-      if( w > QRF_MAX_WIDTH ) w = QRF_MAX_WIDTH;
-      p->mode.spec.aWidth[j-1] = (short int)w;
-    }
-  }else
-
-  {
-    cli_printf(stderr,"Error: unknown command or invalid arguments: "
-          " \"%s\". Enter \".help\" for help\n", azArg[0]);
-    rc = 1;
-  }
-
-meta_command_exit:
-  if( p->nPopOutput ){
-    p->nPopOutput--;
-    if( p->nPopOutput==0 ) output_reset(p);
-  }
-  p->bSafeMode = p->bSafeModePersist;
-  p->dot.nArg = 0;
-  return rc;
-}
-
-/* Line scan result and intermediate states (supporting scan resumption)
-*/
-#ifndef CHAR_BIT
-# define CHAR_BIT 8
-#endif
-typedef enum {
-  QSS_HasDark = 1<<CHAR_BIT, QSS_EndingSemi = 2<<CHAR_BIT,
-  QSS_CharMask = (1<<CHAR_BIT)-1, QSS_ScanMask = 3<<CHAR_BIT,
-  QSS_Start = 0
-} QuickScanState;
-#define QSS_SETV(qss, newst) ((newst) | ((qss) & QSS_ScanMask))
-#define QSS_INPLAIN(qss) (((qss)&QSS_CharMask)==QSS_Start)
-#define QSS_PLAINWHITE(qss) (((qss)&~QSS_EndingSemi)==QSS_Start)
-#define QSS_PLAINDARK(qss) (((qss)&~QSS_EndingSemi)==QSS_HasDark)
-#define QSS_SEMITERM(qss) (((qss)&~QSS_HasDark)==QSS_EndingSemi)
-
-/*
-** Scan line for classification to guide shell's handling.
-** The scan is resumable for subsequent lines when prior
-** return values are passed as the 2nd argument.
-*/
-static QuickScanState quickscan(char *zLine, QuickScanState qss,
-                                SCAN_TRACKER_REFTYPE pst){
-  char cin;
-  char cWait = (char)qss; /* intentional narrowing loss */
-  if( cWait==0 ){
-  PlainScan:
-    while( (cin = *zLine++)!=0 ){
-      if( IsSpace(cin) )
-        continue;
-      switch (cin){
-      case '-':
-        if( *zLine!='-' )
-          break;
-        while((cin = *++zLine)!=0 )
-          if( cin=='\n')
-            goto PlainScan;
-        return qss;
-      case ';':
-        qss |= QSS_EndingSemi;
-        continue;
-      case '/':
-        if( *zLine=='*' ){
-          ++zLine;
-          cWait = '*';
-          CONTINUE_PROMPT_AWAITS(pst, "/*");
-          qss = QSS_SETV(qss, cWait);
-          goto TermScan;
-        }
-        break;
-      case '[':
-        cin = ']';
-        deliberate_fall_through; /* FALLTHRU */
-      case '`': case '\'': case '"':
-        cWait = cin;
-        qss = QSS_HasDark | cWait;
-        CONTINUE_PROMPT_AWAITC(pst, cin);
-        goto TermScan;
-      case '(':
-        CONTINUE_PAREN_INCR(pst, 1);
-        break;
-      case ')':
-        CONTINUE_PAREN_INCR(pst, -1);
-        break;
-      default:
-        break;
-      }
-      qss = (qss & ~QSS_EndingSemi) | QSS_HasDark;
-    }
-  }else{
-  TermScan:
-    while( (cin = *zLine++)!=0 ){
-      if( cin==cWait ){
-        switch( cWait ){
-        case '*':
-          if( *zLine != '/' )
-            continue;
-          ++zLine;
-          CONTINUE_PROMPT_AWAITC(pst, 0);
-          qss = QSS_SETV(qss, 0);
-          goto PlainScan;
-        case '`': case '\'': case '"':
-          if(*zLine==cWait){
-            /* Swallow doubled end-delimiter.*/
-            ++zLine;
-            continue;
-          }
-          deliberate_fall_through; /* FALLTHRU */
-        case ']':
-          CONTINUE_PROMPT_AWAITC(pst, 0);
-          qss = QSS_SETV(qss, 0);
-          goto PlainScan;
-        default: assert(0);
-        }
-      }
-    }
-  }
-  return qss;
-}
-
-/*
-** Return TRUE if the line typed in is an SQL command terminator other
-** than a semi-colon.  The SQL Server style "go" command is understood
-** as is the Oracle "/".
-*/
-static int line_is_command_terminator(char *zLine){
-  while( IsSpace(zLine[0]) ){ zLine++; };
-  if( zLine[0]=='/' )
-    zLine += 1; /* Oracle */
-  else if ( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o' )
-    zLine += 2; /* SQL Server */
-  else
-    return 0;
-  return quickscan(zLine, QSS_Start, 0)==QSS_Start;
-}
-
-/*
-** The CLI needs a working sqlite3_complete() to work properly.  So error
-** out of the build if compiling with SQLITE_OMIT_COMPLETE.
-*/
-#ifdef SQLITE_OMIT_COMPLETE
-# error the CLI application is incompatible with SQLITE_OMIT_COMPLETE.
-#endif
-
-/*
-** Return true if zSql is a complete SQL statement.  Return false if it
-** ends in the middle of a string literal or C-style comment.
-*/
-static int line_is_complete(char *zSql, int nSql){
-  int rc;
-  if( zSql==0 ) return 1;
-  zSql[nSql] = ';';
-  zSql[nSql+1] = 0;
-  rc = sqlite3_complete(zSql);
-  zSql[nSql] = 0;
-  return rc;
-}
-
-/*
-** This function is called after processing each line of SQL in the
-** runOneSqlLine() function. Its purpose is to detect scenarios where
-** defensive mode should be automatically turned off. Specifically, when
-**
-**   1. The first line of input is "PRAGMA foreign_keys=OFF;",
-**   2. The second line of input is "BEGIN TRANSACTION;",
-**   3. The database is empty, and
-**   4. The shell is not running in --safe mode.
-** 
-** The implementation uses the ShellState.eRestoreState to maintain state:
-**
-**    0: Have not seen any SQL.
-**    1: Have seen "PRAGMA foreign_keys=OFF;".
-**    2-6: Currently running .dump transaction. If the "2" bit is set,
-**         disable DEFENSIVE when done. If "4" is set, disable DQS_DDL.
-**    7: Nothing left to do. This function becomes a no-op.
-*/
-static int doAutoDetectRestore(ShellState *p, const char *zSql){
-  int rc = SQLITE_OK;
-
-  if( p->eRestoreState<7 ){
-    switch( p->eRestoreState ){
-      case 0: {
-        const char *zExpect = "PRAGMA foreign_keys=OFF;";
-        assert( strlen(zExpect)==24 );
-        if( p->bSafeMode==0
-         && strlen(zSql)>=24
-         && memcmp(zSql, zExpect, 25)==0
-        ){
-          p->eRestoreState = 1;
-        }else{
-          p->eRestoreState = 7;
-        }
-        break;
-      };
-  
-      case 1: {
-        int bIsDump = 0;
-        const char *zExpect = "BEGIN TRANSACTION;";
-        assert( strlen(zExpect)==18 );
-        if( memcmp(zSql, zExpect, 19)==0 ){
-          /* Now check if the database is empty. */
-          const char *zQuery = "SELECT 1 FROM sqlite_schema LIMIT 1";
-          sqlite3_stmt *pStmt = 0;
-  
-          bIsDump = 1;
-          shellPrepare(p->db, &rc, zQuery, &pStmt);
-          if( rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
-            bIsDump = 0;
-          }
-          shellFinalize(&rc, pStmt);
-        }
-        if( bIsDump && rc==SQLITE_OK ){
-          int bDefense = 0;
-          int bDqsDdl = 0;
-          sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, -1, &bDefense);
-          sqlite3_db_config(p->db, SQLITE_DBCONFIG_DQS_DDL, -1, &bDqsDdl);
-          sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, 0, 0);
-          sqlite3_db_config(p->db, SQLITE_DBCONFIG_DQS_DDL, 1, 0);
-          p->eRestoreState = (bDefense ? 2 : 0) + (bDqsDdl ? 4 : 0);
-        }else{
-          p->eRestoreState = 7;
-        }
-        break;
-      }
-  
-      default: {
-        if( sqlite3_get_autocommit(p->db) ){
-          if( (p->eRestoreState & 2) ){
-            sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, 1, 0);
-          }
-          if( (p->eRestoreState & 4) ){
-            sqlite3_db_config(p->db, SQLITE_DBCONFIG_DQS_DDL, 0, 0);
-          }
-          p->eRestoreState = 7;
-        }
-        break;
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Run a single line of SQL.  Return the number of errors.
-*/
-static int runOneSqlLine(
-  ShellState *p,            /* Execution context */
-  char *zSql,               /* SQL to be run */
-  const char *zFilename,    /* Source file of the sql */
-  int startline             /* linenumber */
-){
-  int rc;
-  char *zErrMsg = 0;
-
-  open_db(p, 0);
-  if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
-  if( p->flgProgress & SHELL_PROGRESS_RESET ) p->nProgress = 0;
-  BEGIN_TIMER(p);
-  rc = shell_exec(p, zSql, &zErrMsg);
-  END_TIMER(p);
-  if( rc || zErrMsg ){
-    char zPrefix[2048
-                 /* must be relatively large:
-                 ** https://sqlite.org/forum/forumpost/205f73db1b2806f5 */];
-    const char *zErrorTail;
-    const char *zErrorType;
-    if( zErrMsg==0 ){
-      zErrorType = "Error";
-      zErrorTail = sqlite3_errmsg(p->db);
-    }else if( cli_strncmp(zErrMsg, "in prepare, ",12)==0 ){
-      zErrorType = "Parse error";
-      zErrorTail = &zErrMsg[12];
-    }else if( cli_strncmp(zErrMsg, "stepping, ", 10)==0 ){
-      zErrorType = "Runtime error";
-      zErrorTail = &zErrMsg[10];
-    }else{
-      zErrorType = "Error";
-      zErrorTail = zErrMsg;
-    }
-    if( zFilename || !stdin_is_interactive ){
-      if( cli_strcmp(zFilename,"cmdline")==0 ){
-        sqlite3_snprintf(sizeof(zPrefix), zPrefix,
-                  "%s in %r command line argument:", zErrorType, startline);
-      }else if( cli_strcmp(zFilename,"<stdin>")==0 ){
-        sqlite3_snprintf(sizeof(zPrefix), zPrefix,
-                  "%s near line %d:", zErrorType, startline);
-      }else{
-        sqlite3_snprintf(sizeof(zPrefix), zPrefix,
-                  "%s near line %d of %s:", zErrorType, startline, zFilename);
-      }
-    }else{
-      sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:", zErrorType);
-    }
-    cli_printf(stderr,"%s %s\n", zPrefix, zErrorTail);
-    sqlite3_free(zErrMsg);
-    zErrMsg = 0;
-    return 1;
-  }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
-    char zLineBuf[2000];
-    sqlite3_snprintf(sizeof(zLineBuf), zLineBuf,
-            "changes: %lld   total_changes: %lld",
-            sqlite3_changes64(p->db), sqlite3_total_changes64(p->db));
-    cli_printf(p->out, "%s\n", zLineBuf);
-  }
-
-  if( doAutoDetectRestore(p, zSql) ) return 1;
-  return 0;
-}
-
-static void echo_group_input(ShellState *p, const char *zDo){
-  if( p->mode.mFlags & MFLG_ECHO ){
-    cli_printf(p->out, "%s\n", zDo);
-    fflush(p->out);
-  }
-}
-
-#ifdef SQLITE_SHELL_FIDDLE
-/*
-** Alternate one_input_line() impl for wasm mode. This is not in the primary
-** impl because we need the global shellState and cannot access it from that
-** function without moving lots of code around (creating a larger/messier diff).
-*/
-static char *one_input_line(ShellState *p, char *zPrior, int isContinuation){
-  /* Parse the next line from shellState.wasm.zInput. */
-  const char *zBegin = shellState.wasm.zPos;
-  const char *z = zBegin;
-  char *zLine = 0;
-  i64 nZ = 0;
-  FILE *in = p->in;
-
-  UNUSED_PARAMETER(in);
-  UNUSED_PARAMETER(isContinuation);
-  if(!z || !*z){
-    return 0;
-  }
-  while(*z && IsSpace(*z)) ++z;
-  zBegin = z;
-  for(; *z && '\n'!=*z; ++nZ, ++z){}
-  if(nZ>0 && '\r'==zBegin[nZ-1]){
-    --nZ;
-  }
-  shellState.wasm.zPos = z;
-  zLine = realloc(zPrior, nZ+1);
-  shell_check_oom(zLine);
-  memcpy(zLine, zBegin, nZ);
-  zLine[nZ] = 0;
-  return zLine;
-}
-#endif /* SQLITE_SHELL_FIDDLE */
-
-/*
-** Read input from *in and process it.  If *in==0 then input
-** is interactive - the user is typing it it.  Otherwise, input
-** is coming from a file or device.  A prompt is issued and history
-** is saved only if input is interactive.  An interrupt signal will
-** cause this routine to exit immediately, unless input is interactive.
-**
-** Return the number of errors.
-*/
-static int process_input(ShellState *p, const char *zSrc){
-  char *zLine = 0;          /* A single input line */
-  char *zSql = 0;           /* Accumulated SQL text */
-  i64 nLine;                /* Length of current line */
-  i64 nSql = 0;             /* Bytes of zSql[] used */
-  i64 nAlloc = 0;           /* Allocated zSql[] space */
-  int rc;                   /* Error code */
-  int errCnt = 0;           /* Number of errors seen */
-  i64 startline = 0;        /* Line number for start of current input */
-  QuickScanState qss = QSS_Start; /* Accumulated line status (so far) */
-  const char *saved_zInFile;      /* Prior value of p->zInFile */
-  i64 saved_lineno;               /* Prior value of p->lineno */
-
-  if( p->inputNesting==MAX_INPUT_NESTING ){
-    /* This will be more informative in a later version. */
-    cli_printf(stderr,"%s: Input nesting limit (%d) reached at line %lld."
-          " Check recursion.\n", zSrc, MAX_INPUT_NESTING, p->lineno);
-    return 1;
-  }
-  ++p->inputNesting;
-  saved_zInFile = p->zInFile;
-  p->zInFile = zSrc;
-  saved_lineno = p->lineno;
-  p->lineno = 0;
-  CONTINUE_PROMPT_RESET;
-  while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){
-    fflush(p->out);
-    zLine = one_input_line(p, zLine, nSql>0);
-    if( zLine==0 ){
-      /* End of input */
-      if( p->in==0 && stdin_is_interactive ) cli_puts("\n", p->out);
-      break;
-    }
-    if( seenInterrupt ){
-      if( p->in!=0 ) break;
-      seenInterrupt = 0;
-    }
-    p->lineno++;
-    if( QSS_INPLAIN(qss)
-        && line_is_command_terminator(zLine)
-        && line_is_complete(zSql, nSql) ){
-      memcpy(zLine,";",2);
-    }
-    qss = quickscan(zLine, qss, CONTINUE_PROMPT_PSTATE);
-    if( QSS_PLAINWHITE(qss) && nSql==0 ){
-      /* Just swallow single-line whitespace */
-      echo_group_input(p, zLine);
-      qss = QSS_Start;
-      continue;
-    }
-    if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){
-      CONTINUE_PROMPT_RESET;
-      echo_group_input(p, zLine);
-      if( zLine[0]=='.' ){
-        rc = do_meta_command(zLine, p);
-        if( rc==2 ){ /* exit requested */
-          break;
-        }else if( rc ){
-          errCnt++;
-        }
-      }
-      qss = QSS_Start;
-      continue;
-    }
-    /* No single-line dispositions remain; accumulate line(s). */
-    nLine = strlen(zLine);
-    if( nSql+nLine+2>=nAlloc ){
-      /* Grow buffer by half-again increments when big. */
-      nAlloc = nSql+(nSql>>1)+nLine+100;
-      zSql = realloc(zSql, nAlloc);
-      shell_check_oom(zSql);
-    }
-    if( nSql==0 ){
-      i64 i;
-      for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
-      assert( nAlloc>0 && zSql!=0 );
-      memcpy(zSql, zLine+i, nLine+1-i);
-      startline = p->lineno;
-      nSql = nLine-i;
-    }else{
-      zSql[nSql++] = '\n';
-      memcpy(zSql+nSql, zLine, nLine+1);
-      nSql += nLine;
-    }
-    if( nSql>0x7fff0000 ){
-      char zSize[100];
-      sqlite3_snprintf(sizeof(zSize),zSize,"%,lld",nSql);
-      cli_printf(stderr, "%s:%lld: Input SQL is too big: %s bytes\n",
-                      zSrc, startline, zSize);
-      nSql = 0;
-      errCnt++;
-      break;
-    }else if( nSql && QSS_SEMITERM(qss) && sqlite3_complete(zSql) ){
-      echo_group_input(p, zSql);
-      errCnt += runOneSqlLine(p, zSql, p->zInFile, startline);
-      CONTINUE_PROMPT_RESET;
-      nSql = 0;
-      if( p->nPopOutput ){
-        output_reset(p);
-        p->nPopOutput = 0;
-      }else{
-        clearTempFile(p);
-      }
-      if( p->nPopMode ){
-        modePop(p);
-        p->nPopMode = 0;
-      }
-      p->bSafeMode = p->bSafeModePersist;
-      qss = QSS_Start;
-    }else if( nSql && QSS_PLAINWHITE(qss) ){
-      echo_group_input(p, zSql);
-      nSql = 0;
-      qss = QSS_Start;
-    }
-  }
-  if( nSql ){
-    /* This may be incomplete. Let the SQL parser deal with that. */
-    echo_group_input(p, zSql);
-    errCnt += runOneSqlLine(p, zSql, p->zInFile, startline);
-    CONTINUE_PROMPT_RESET;
-  }
-  free(zSql);
-  free(zLine);
-  --p->inputNesting;
-  p->zInFile = saved_zInFile;
-  p->lineno = saved_lineno;
-  return errCnt>0;
-}
-
-/*
-** Return a pathname which is the user's home directory.  A
-** 0 return indicates an error of some kind.
-*/
-static char *find_home_dir(int clearFlag){
-  static char *home_dir = NULL;
-  if( clearFlag ){
-    free(home_dir);
-    home_dir = 0;
-    return 0;
-  }
-  if( home_dir ) return home_dir;
-
-#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
-     && !defined(__RTP__) && !defined(_WRS_KERNEL) && !defined(SQLITE_WASI)
-  {
-    struct passwd *pwent;
-    uid_t uid = getuid();
-    if( (pwent=getpwuid(uid)) != NULL) {
-      home_dir = pwent->pw_dir;
-    }
-  }
-#endif
-
-#if defined(_WIN32_WCE)
-  /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
-   */
-  home_dir = "/";
-#else
-
-#if defined(_WIN32) || defined(WIN32)
-  if (!home_dir) {
-    home_dir = getenv("USERPROFILE");
-  }
-#endif
-
-  if (!home_dir) {
-    home_dir = getenv("HOME");
-  }
-
-#if defined(_WIN32) || defined(WIN32)
-  if (!home_dir) {
-    char *zDrive, *zPath;
-    int n;
-    zDrive = getenv("HOMEDRIVE");
-    zPath = getenv("HOMEPATH");
-    if( zDrive && zPath ){
-      n = strlen30(zDrive) + strlen30(zPath) + 1;
-      home_dir = malloc( n );
-      if( home_dir==0 ) return 0;
-      sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
-      return home_dir;
-    }
-    home_dir = "c:\\";
-  }
-#endif
-
-#endif /* !_WIN32_WCE */
-
-  if( home_dir ){
-    i64 n = strlen(home_dir) + 1;
-    char *z = malloc( n );
-    if( z ) memcpy(z, home_dir, n);
-    home_dir = z;
-  }
-
-  return home_dir;
-}
-
-/*
-** On non-Windows platforms, look for:
-**
-** - ${zEnvVar}/${zBaseName}
-** - ${HOME}/${zSubdir}/${zBaseName}
-**
-** $zEnvVar is intended to be the name of an XDG_... environment
-** variable, e.g. XDG_CONFIG_HOME or XDG_STATE_HOME.  If zEnvVar is
-** NULL or getenv(zEnvVar) is NULL then fall back to the second
-** option. If the selected option is not found in the filesystem,
-** return 0.
-**
-** zSubdir may be NULL or empty, in which case ${HOME}/${zBaseName}
-** becomes the fallback.
-**
-** Both zSubdir and zBaseName may contain subdirectory parts. zSubdir
-** will conventionally be ".config" or ".local/state", which, not
-** coincidentally, is the typical subdir of the corresponding XDG_...
-** var with the XDG var's $HOME prefix.
-**
-** The returned string is obtained from sqlite3_malloc() and should be
-** sqlite3_free()'d by the caller.
-*/
-static char *find_xdg_file(const char *zEnvVar, const char *zSubdir,
-                           const char *zBaseName){
-#if defined(_WIN32) || defined(WIN32) || defined(_WIN32_WCE) \
-     || defined(__RTP__) || defined(_WRS_KERNEL)
-  return 0;
-#else
-  char *zConfigFile = 0;
-  const char *zXdgDir;
-
-  zXdgDir = zEnvVar ? getenv(zEnvVar) : 0;
-  if( zXdgDir ){
-    zConfigFile = sqlite3_mprintf("%s/%s", zXdgDir, zBaseName);
-  }else{
-    const char * zHome = find_home_dir(0);
-    if( zHome==0 ) return 0;
-    zConfigFile = (zSubdir && *zSubdir)
-      ? sqlite3_mprintf("%s/%s/%s", zHome, zSubdir, zBaseName)
-      : sqlite3_mprintf("%s/%s", zHome, zBaseName);
-  }
-  shell_check_oom(zConfigFile);
-  if( access(zConfigFile,0)!=0 ){
-    sqlite3_free(zConfigFile);
-    zConfigFile = 0;
-  }
-  return zConfigFile;
-#endif
-}
-
-/*
-** Read input from the file sqliterc_override.  If that parameter is
-** NULL, take it from find_xdg_file(), if found, or fall back to
-** ~/.sqliterc.
-**
-** Failure to read the config is only considered a failure if
-** sqliterc_override is not NULL, in which case this function may emit
-** a warning or, if ::bail_on_error is true, fail fatally if the file
-** named by sqliterc_override is not found.
-*/
-static void process_sqliterc(
-  ShellState *p,                  /* Configuration data */
-  const char *sqliterc_override   /* Name of config file. NULL to use default */
-){
-  char *home_dir = NULL;
-  char *sqliterc = (char*)sqliterc_override;
-  FILE *inSaved = p->in;
-  i64 savedLineno = p->lineno;
-
-  if( sqliterc == NULL ){
-    sqliterc = find_xdg_file("XDG_CONFIG_HOME",
-                             ".config",
-                             "sqlite3/sqliterc");
-  }
-  if( sqliterc == NULL ){
-    home_dir = find_home_dir(0);
-    if( home_dir==0 ){
-      eputz("-- warning: cannot find home directory;"
-            " cannot read ~/.sqliterc\n");
-      return;
-    }
-    sqliterc = sqlite3_mprintf("%s/.sqliterc",home_dir);
-    shell_check_oom(sqliterc);
-  }
-  p->in = sqliterc ? sqlite3_fopen(sqliterc,"rb") : 0;
-  if( p->in ){
-    if( stdin_is_interactive ){
-      cli_printf(stderr,"-- Loading resources from %s\n", sqliterc);
-    }
-    if( process_input(p, sqliterc) && bail_on_error ) cli_exit(1);
-    fclose(p->in);
-  }else if( sqliterc_override!=0 ){
-    cli_printf(stderr,"cannot open: \"%s\"\n", sqliterc);
-    if( bail_on_error ) cli_exit(1);
-  }
-  p->in = inSaved;
-  p->lineno = savedLineno;
-  if( sqliterc != sqliterc_override ){
-    sqlite3_free(sqliterc);
-  }
-}
-
-/*
-** Show available command line options
-*/
-static const char zOptions[] =
-  "   --                   treat no subsequent arguments as options\n"
-#if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE)
-  "   -A ARGS...           run \".archive ARGS\" and exit\n"
-#endif
-  "   -append              append the database to the end of the file\n"
-  "   -ascii               set output mode to 'ascii'\n"
-  "   -bail                stop after hitting an error\n"
-  "   -batch               force batch I/O\n"
-  "   -box                 set output mode to 'box'\n"
-  "   -cmd COMMAND         run \"COMMAND\" before reading stdin\n"
-  "   -column              set output mode to 'column'\n"
-  "   -csv                 set output mode to 'csv'\n"
-#if !defined(SQLITE_OMIT_DESERIALIZE)
-  "   -deserialize         open the database using sqlite3_deserialize()\n"
-#endif
-  "   -echo                print inputs before execution\n"
-  "   -escape T            ctrl-char escape; T is one of: symbol, ascii, off\n"
-  "   -init FILENAME       read/process named file\n"
-  "   -[no]header          turn headers on or off\n"
-#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
-  "   -heap SIZE           Size of heap for memsys3 or memsys5\n"
-#endif
-  "   -help                show this message\n"
-  "   -html                set output mode to HTML\n"
-  "   -ifexists            only open if database already exists\n"
-  "   -interactive         force interactive I/O\n"
-  "   -json                set output mode to 'json'\n"
-  "   -line                set output mode to 'line'\n"
-  "   -list                set output mode to 'list'\n"
-  "   -lookaside SIZE N    use N entries of SZ bytes for lookaside memory\n"
-  "   -markdown            set output mode to 'markdown'\n"
-#if !defined(SQLITE_OMIT_DESERIALIZE)
-  "   -maxsize N           maximum size for a --deserialize database\n"
-#endif
-  "   -memtrace            trace all memory allocations and deallocations\n"
-  "   -mmap N              default mmap size set to N\n"
-#ifdef SQLITE_ENABLE_MULTIPLEX
-  "   -multiplex           enable the multiplexor VFS\n"
-#endif
-  "   -newline SEP         set output row separator. Default: '\\n'\n"
-  "   -nofollow            refuse to open symbolic links to database files\n"
-  "   -noinit              Do not read the ~/.sqliterc file at startup\n"
-  "   -nonce STRING        set the safe-mode escape nonce\n"
-  "   -no-rowid-in-view    Disable rowid-in-view using sqlite3_config()\n"
-  "   -nullvalue TEXT      set text string for NULL values. Default ''\n"
-  "   -pagecache SIZE N    use N slots of SZ bytes each for page cache memory\n"
-  "   -pcachetrace         trace all page cache operations\n"
-  "   -quote               set output mode to 'quote'\n"
-  "   -readonly            open the database read-only\n"
-  "   -safe                enable safe-mode\n"
-  "   -screenwidth N       use N as the default screenwidth \n"
-  "   -separator SEP       set output column separator. Default: '|'\n"
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-  "   -sorterref SIZE      sorter references threshold size\n"
-#endif
-  "   -stats               print memory stats before each finalize\n"
-  "   -table               set output mode to 'table'\n"
-  "   -tabs                set output mode to 'tabs'\n"
-  "   -unsafe-testing      allow unsafe commands and modes for testing\n"
-  "   -version             show SQLite version\n"
-  "   -vfs NAME            use NAME as the default VFS\n"
-  "   -vfstrace            enable tracing of all VFS calls\n"
-#ifdef SQLITE_HAVE_ZLIB
-  "   -zip                 open the file as a ZIP Archive\n"
-#endif
-;
-static void usage(int showDetail){
-  cli_printf(stderr,"Usage: %s [OPTIONS] [FILENAME [SQL...]]\n"
-       "FILENAME is the name of an SQLite database. A new database is created\n"
-       "if the file does not previously exist. Defaults to :memory:.\n", Argv0);
-  if( showDetail ){
-    cli_printf(stderr,"OPTIONS include:\n%s", zOptions);
-  }else{
-    eputz("Use the -help option for additional information\n");
-  }
-  exit(0);
-}
-
-/*
-** Internal check:  Verify that the SQLite is uninitialized.  Print a
-** error message if it is initialized.
-*/
-static void verify_uninitialized(void){
-  if( sqlite3_config(-1)==SQLITE_MISUSE ){
-    sputz(stdout, "WARNING: attempt to configure SQLite after"
-          " initialization.\n");
-  }
-}
-
-/*
-** Initialize the state information in data
-*/
-static void main_init(ShellState *p) {
-  memset(p, 0, sizeof(*p));
-  p->pAuxDb = &p->aAuxDb[0];
-  p->shellFlgs = SHFLG_Lookaside;
-  sqlite3_config(SQLITE_CONFIG_LOG, shellLog, p);
-#if !defined(SQLITE_SHELL_FIDDLE)
-  verify_uninitialized();
-#endif
-  sqlite3_config(SQLITE_CONFIG_URI, 1);
-  sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
-  sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
-  sqlite3_snprintf(sizeof(continuePrompt), continuePrompt,"   ...> ");
-}
-
-/*
-** Output text to the console in a font that attracts extra attention.
-*/
-#if defined(_WIN32) || defined(WIN32)
-static void printBold(const char *zText){
-  HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
-  CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
-  GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
-  SetConsoleTextAttribute(out,
-         FOREGROUND_RED|FOREGROUND_INTENSITY
-  );
-  sputz(stdout, zText);
-  SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
-}
-#else
-static void printBold(const char *zText){
-  cli_printf(stdout, "\033[1m%s\033[0m", zText);
-}
-#endif
-
-/*
-** Get the argument to an --option.  Throw an error and die if no argument
-** is available.
-*/
-static char *cmdline_option_value(int argc, char **argv, int i){
-  if( i==argc ){
-    cli_printf(stderr,
-            "%s: Error: missing argument to %s\n", argv[0], argv[argc-1]);
-    cli_exit(1);
-  }
-  return argv[i];
-}
-
-static void sayAbnormalExit(void){
-  if( seenInterrupt ) eputz("Program interrupted.\n");
-}
-
-/* Routine to output from vfstrace
-*/
-static int vfstraceOut(const char *z, void *pArg){
-  ShellState *p = (ShellState*)pArg;
-  cli_puts(z, p->out);
-  fflush(p->out);
-  return 1;
-}
-
-#if defined(SQLITE_DEBUG) && !defined(SQLITE_SHELL_FIDDLE)
-/* Ensure that sqlite3_reset_auto_extension() clears auto-extension
-** memory. https://sqlite.org/forum/forumpost/310cb231b07c80d1.
-** Testing this: if we (inadvertently) remove the
-** sqlite3_reset_auto_extension() call from main(), most shell tests
-** will fail because of a leak message in their output. */
-static int auto_ext_leak_tester(
-  sqlite3 *db,
-  char **pzErrMsg,
-  const struct sqlite3_api_routines *pThunk
-){
-  (void)db; (void)pzErrMsg; (void)pThunk;
-  return SQLITE_OK;
-}
-#endif
-
-/* Alternative name to the entry point for Fiddle */
-#ifdef SQLITE_SHELL_FIDDLE
-#  define main fiddle_main
-#endif
-
-/* Use the wmain() entry point on Windows.  Translate arguments to
-** UTF8, then invoke the traditional main() entry point which is
-** renamed using a #define to utf8_main() .
-*/
-#if defined(_WIN32) && !defined(__MINGW32__) && !defined(main)
-#  define main utf8_main                 /* Rename entry point to utf_main() */
-int SQLITE_CDECL utf8_main(int,char**);  /* Forward declaration */  
-int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
-  int rc, i;
-  char **argv = malloc( sizeof(char*) * (argc+1) );
-  char **orig = argv;
-  if( argv==0 ){
-    fprintf(stderr, "malloc failed\n");
-    exit(1);
-  }
-  for(i=0; i<argc; i++){
-    int nByte = WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1, 0, 0, 0, 0);
-    if( nByte==0 ){
-      argv[i] = 0;
-    }else{
-      argv[i] = malloc( nByte );
-      if( argv[i]==0 ){
-        fprintf(stderr, "malloc failed\n");
-        exit(1);
-      }
-      nByte = WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1, argv[i],nByte,0,0);
-      if( nByte==0 ){
-        free(argv[i]);
-        argv[i] = 0;
-      }
-    }
-  }
-  argv[argc] = 0;
-  rc = utf8_main(argc, argv);
-  for(i=0; i<argc; i++) free(orig[i]);
-  free(argv);
-  return rc;
-}
-#endif /* WIN32 */
-
-/*
-** This is the main entry point for the process.  Everything starts here.
-**
-** The "main" identifier may have been #defined to something else:
-**
-**     utf8_main            On Windows
-**     fiddle_main          In Fiddle
-**     sqlite3_shell        Other projects that use shell.c as a subroutine
-*/
-int SQLITE_CDECL main(int argc, char **argv){
-#ifdef SQLITE_DEBUG
-  sqlite3_int64 mem_main_enter = 0;
-#endif
-#ifdef SQLITE_SHELL_FIDDLE
-#  define data shellState
-#else
-  ShellState data;
-#endif
-  const char *zInitFile = 0;
-  int i;
-  int rc = 0;
-  int warnInmemoryDb = 0;
-  int readStdin = 1;
-  int noInit = 0;                 /* Do not read ~/.sqliterc if true */
-  int nCmd = 0;
-  int nOptsEnd = argc;
-  int bEnableVfstrace = 0;
-  char **azCmd = 0;
-  int *aiCmd = 0;
-  const char *zVfs = 0;           /* Value of -vfs command-line option */
-  setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
-
-#ifdef SQLITE_SHELL_FIDDLE
-  stdin_is_interactive = 0;
-  stdout_is_console = 1;
-  data.wasm.zDefaultDbName = "/fiddle.sqlite3";
-#else
-  stdin_is_interactive = isatty(0);
-  stdout_is_console = isatty(1);
-#endif
-  atexit(sayAbnormalExit);
-#ifdef SQLITE_DEBUG
-  mem_main_enter = sqlite3_memory_used();
-#endif
-#if !defined(_WIN32_WCE)
-  if( getenv("SQLITE_DEBUG_BREAK") ){
-    if( isatty(0) && isatty(2) ){
-      char zLine[100];
-      cli_printf(stderr,
-            "attach debugger to process %d and press ENTER to continue...",
-            GETPID());
-      if( sqlite3_fgets(zLine, sizeof(zLine), stdin)!=0
-       && cli_strcmp(zLine,"stop")==0
-      ){
-        exit(1);
-      }
-    }else{
-#if defined(_WIN32) || defined(WIN32)
-      DebugBreak();
-#elif defined(SIGTRAP)
-      raise(SIGTRAP);
-#endif
-    }
-  }
-#endif
-  /* Register a valid signal handler early, before much else is done. */
-#ifdef SIGINT
-  signal(SIGINT, interrupt_handler);
-#elif (defined(_WIN32) || defined(WIN32)) && !defined(_WIN32_WCE)
-  if( !SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE) ){
-    eputz("No ^C handler.\n");
-  }
-#endif
-
-#if USE_SYSTEM_SQLITE+0!=1
-  if( cli_strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,60)!=0 ){
-    cli_printf(stderr,
-          "SQLite header and source version mismatch\n%s\n%s\n",
-          sqlite3_sourceid(), SQLITE_SOURCE_ID);
-    exit(1);
-  }
-#endif
-  main_init(&data);
-
-  assert( argc>=1 && argv && argv[0] );
-  Argv0 = argv[0];
-
-#ifdef SQLITE_SHELL_DBNAME_PROC
-  {
-    /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
-    ** of a C-function that will provide the name of the database file.  Use
-    ** this compile-time option to embed this shell program in larger
-    ** applications. */
-    extern void SQLITE_SHELL_DBNAME_PROC(const char**);
-    SQLITE_SHELL_DBNAME_PROC(&data.pAuxDb->zDbFilename);
-    warnInmemoryDb = 0;
-  }
-#endif
-
-  /* Do an initial pass through the command-line arguments to locate
-  ** the name of the database file, the name of the initialization file,
-  ** the size of the alternative malloc heap, options affecting commands
-  ** or SQL run from the command line, and the first command to execute.
-  */
-#ifndef SQLITE_SHELL_FIDDLE
-  verify_uninitialized();
-#endif
-  for(i=1; i<argc; i++){
-    char *z;
-    z = argv[i];
-    if( z[0]!='-' || i>nOptsEnd ){
-      if( data.aAuxDb->zDbFilename==0 && !isScriptFile(z,1) ){
-        data.aAuxDb->zDbFilename = z;
-      }else{
-        /* Excess arguments are interpreted as SQL (or dot-commands) and
-        ** mean that nothing is read from stdin */
-        readStdin = 0;
-        stdin_is_interactive = 0;
-        nCmd++;
-        azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
-        shell_check_oom(azCmd);
-        aiCmd = realloc(aiCmd, sizeof(aiCmd[0])*nCmd);
-        shell_check_oom(azCmd);
-        azCmd[nCmd-1] = z;
-        aiCmd[nCmd-1] = i;
-      }
-      continue;
-    }
-    if( z[1]=='-' ) z++;
-    if( cli_strcmp(z, "-")==0 ){
-      nOptsEnd = i;
-      continue;
-    }else if( cli_strcmp(z,"-separator")==0
-     || cli_strcmp(z,"-nullvalue")==0
-     || cli_strcmp(z,"-newline")==0
-     || cli_strcmp(z,"-cmd")==0
-    ){
-      (void)cmdline_option_value(argc, argv, ++i);
-    }else if( cli_strcmp(z,"-init")==0 ){
-      zInitFile = cmdline_option_value(argc, argv, ++i);
-    }else if( cli_strcmp(z,"-interactive")==0 ){
-    }else if( cli_strcmp(z,"-batch")==0 ){
-      /* Need to check for batch mode here to so we can avoid printing
-      ** informational messages (like from process_sqliterc) before
-      ** we do the actual processing of arguments later in a second pass.
-      */
-      stdin_is_interactive = 0;
-      stdout_is_console = 0;
-      modeChange(&data, MODE_BATCH);
-    }else if( cli_strcmp(z,"-screenwidth")==0 ){
-      int n = atoi(cmdline_option_value(argc, argv, ++i));
-      if( n<2 ){
-        sqlite3_fprintf(stderr,"minimum --screenwidth is 2\n");
-        exit(1);
-      }
-      stdout_tty_width = n;
-    }else if( cli_strcmp(z,"-utf8")==0 ){
-    }else if( cli_strcmp(z,"-no-utf8")==0 ){
-    }else if( cli_strcmp(z,"-no-rowid-in-view")==0 ){
-      int val = 0;
-      sqlite3_config(SQLITE_CONFIG_ROWID_IN_VIEW, &val);
-      assert( val==0 );
-    }else if( cli_strcmp(z,"-heap")==0 ){
-#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
-      const char *zSize;
-      sqlite3_int64 szHeap;
-
-      zSize = cmdline_option_value(argc, argv, ++i);
-      szHeap = integerValue(zSize);
-      if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
-      verify_uninitialized();
-      sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
-#else
-      (void)cmdline_option_value(argc, argv, ++i);
-#endif
-    }else if( cli_strcmp(z,"-pagecache")==0 ){
-      sqlite3_int64 n, sz;
-      sz = integerValue(cmdline_option_value(argc,argv,++i));
-      if( sz>65536 ) sz = 65536;
-      if( sz<0 ) sz = 0;
-      n = integerValue(cmdline_option_value(argc,argv,++i));
-      if( sz>0 && n>0 && 0xffffffffffffLL/sz<n ){
-        n = 0xffffffffffffLL/sz;
-      }
-      if( sz>0 && (sz & (sz-1))==0 ){
-        /* If SIZE is a power of two, round it up by the PCACHE_HDRSZ */
-        int szHdr = 0;
-        sqlite3_config(SQLITE_CONFIG_PCACHE_HDRSZ, &szHdr);
-        sz += szHdr;
-        cli_printf(stdout, "Page cache size increased to %d to accommodate"
-                        " the %d-byte headers\n", (int)sz, szHdr);
-      }
-      verify_uninitialized();
-      sqlite3_config(SQLITE_CONFIG_PAGECACHE,
-                    (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n);
-      data.shellFlgs |= SHFLG_Pagecache;
-    }else if( cli_strcmp(z,"-lookaside")==0 ){
-      int n, sz;
-      sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
-      if( sz<0 ) sz = 0;
-      n = (int)integerValue(cmdline_option_value(argc,argv,++i));
-      if( n<0 ) n = 0;
-      verify_uninitialized();
-      sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
-      if( (i64)sz*(i64)n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
-    }else if( cli_strcmp(z,"-threadsafe")==0 ){
-      int n;
-      n = (int)integerValue(cmdline_option_value(argc,argv,++i));
-      verify_uninitialized();
-      switch( n ){
-         case 0:  sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);  break;
-         case 2:  sqlite3_config(SQLITE_CONFIG_MULTITHREAD);   break;
-         default: sqlite3_config(SQLITE_CONFIG_SERIALIZED);    break;
-      }
-    }else if( cli_strcmp(z,"-vfstrace")==0 ){
-      bEnableVfstrace = 1;
-#ifdef SQLITE_ENABLE_MULTIPLEX
-    }else if( cli_strcmp(z,"-multiplex")==0 ){
-      extern int sqlite3_multiplex_initialize(const char*,int);
-      sqlite3_multiplex_initialize(0, 1);
-#endif
-    }else if( cli_strcmp(z,"-mmap")==0 ){
-      sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
-      verify_uninitialized();
-      sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
-#if defined(SQLITE_ENABLE_SORTER_REFERENCES)
-    }else if( cli_strcmp(z,"-sorterref")==0 ){
-      sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
-      verify_uninitialized();
-      sqlite3_config(SQLITE_CONFIG_SORTERREF_SIZE, (int)sz);
-#endif
-    }else if( cli_strcmp(z,"-vfs")==0 ){
-      zVfs = cmdline_option_value(argc, argv, ++i);
-#ifdef SQLITE_HAVE_ZLIB
-    }else if( cli_strcmp(z,"-zip")==0 ){
-      data.openMode = SHELL_OPEN_ZIPFILE;
-#endif
-    }else if( cli_strcmp(z,"-append")==0 ){
-      data.openMode = SHELL_OPEN_APPENDVFS;
-#ifndef SQLITE_OMIT_DESERIALIZE
-    }else if( cli_strcmp(z,"-deserialize")==0 ){
-      data.openMode = SHELL_OPEN_DESERIALIZE;
-    }else if( cli_strcmp(z,"-maxsize")==0 && i+1<argc ){
-      data.szMax = integerValue(argv[++i]);
-#endif
-    }else if( cli_strcmp(z,"-readonly")==0 ){
-      data.openFlags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
-      data.openFlags |= SQLITE_OPEN_READONLY;
-    }else if( cli_strcmp(z,"-nofollow")==0 ){
-      data.openFlags |= SQLITE_OPEN_NOFOLLOW;
-    }else if( cli_strcmp(z,"-noinit")==0 ){
-      noInit = 1;
-    }else if( cli_strcmp(z,"-exclusive")==0 ){  /* UNDOCUMENTED */
-      data.openFlags |= SQLITE_OPEN_EXCLUSIVE;
-    }else if( cli_strcmp(z,"-ifexists")==0 ){
-      data.openFlags &= ~(SQLITE_OPEN_CREATE);
-      if( data.openFlags==0 ) data.openFlags = SQLITE_OPEN_READWRITE;
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
-    }else if( cli_strncmp(z, "-A",2)==0 ){
-      /* All remaining command-line arguments are passed to the ".archive"
-      ** command, so ignore them */
-      break;
-#endif
-    }else if( cli_strcmp(z, "-memtrace")==0 ){
-      sqlite3MemTraceActivate(stderr);
-    }else if( cli_strcmp(z, "-pcachetrace")==0 ){
-      sqlite3PcacheTraceActivate(stderr);
-    }else if( cli_strcmp(z,"-bail")==0 ){
-      bail_on_error = 1;
-    }else if( cli_strcmp(z,"-nonce")==0 ){
-      free(data.zNonce);
-      data.zNonce = strdup(cmdline_option_value(argc, argv, ++i));
-    }else if( cli_strcmp(z,"-unsafe-testing")==0 ){
-      ShellSetFlag(&data,SHFLG_TestingMode);
-    }else if( cli_strcmp(z,"-safe")==0 ){
-      /* no-op - catch this on the second pass */
-    }else if( cli_strcmp(z,"-escape")==0 && i+1<argc ){
-      /* skip over the argument */
-      i++;
-    }else if( cli_strcmp(z,"-test-argv")==0 ){
-      /* Undocumented test option.  Print the values in argv[] and exit.
-      ** Use this to verify that any translation of the argv[], for example
-      ** on Windows that receives wargv[] from the OS and must convert
-      ** to UTF8 prior to calling this routine. */
-      int kk;
-      for(kk=0; kk<argc; kk++){
-        sqlite3_fprintf(stdout,"argv[%d] = \"%s\"\n", kk, argv[kk]);
-      }
-      return 0;
-    }
-  }
-#ifndef SQLITE_SHELL_FIDDLE
-  if( !bEnableVfstrace ) verify_uninitialized();
-#endif
-
-
-#ifdef SQLITE_SHELL_INIT_PROC
-  {
-    /* If the SQLITE_SHELL_INIT_PROC macro is defined, then it is the name
-    ** of a C-function that will perform initialization actions on SQLite that
-    ** occur just before or after sqlite3_initialize(). Use this compile-time
-    ** option to embed this shell program in larger applications. */
-    extern void SQLITE_SHELL_INIT_PROC(void);
-    SQLITE_SHELL_INIT_PROC();
-  }
-#else
-  /* All the sqlite3_config() calls have now been made. So it is safe
-  ** to call sqlite3_initialize() and process any command line -vfs option. */
-  sqlite3_initialize();
-#endif
-
-  if( zVfs ){
-    sqlite3_vfs *pVfs = sqlite3_vfs_find(zVfs);
-    if( pVfs ){
-      sqlite3_vfs_register(pVfs, 1);
-    }
-#if !defined(SQLITE_OMIT_LOAD_EXTENSION)
-    else if( access(zVfs,0)==0 ){
-      /* If the VFS name is not the name of an existing VFS, but it is
-      ** the name of a file, then try to load that file as an extension.
-      ** Presumably the extension implements the desired VFS. */
-      sqlite3 *db = 0;
-      char *zErr = 0;
-      sqlite3_open(":memory:", &db);
-      sqlite3_enable_load_extension(db, 1);
-      rc = sqlite3_load_extension(db, zVfs, 0, &zErr);
-      sqlite3_close(db);
-      if( (rc&0xff)!=SQLITE_OK ){
-        cli_printf(stderr, "could not load extension VFS \"%s\": %s\n",
-                   zVfs, zErr);
-        exit(1);
-      }
-    }
-#endif
-    else{
-      cli_printf(stderr,"no such VFS: \"%s\"\n", zVfs);
-      exit(1);
-    }
-  }
-
-  if( data.pAuxDb->zDbFilename==0 ){
-#ifndef SQLITE_OMIT_MEMORYDB
-    data.pAuxDb->zDbFilename = ":memory:";
-    warnInmemoryDb = argc==1;
-#else
-    cli_printf(stderr,
-                    "%s: Error: no database filename specified\n", Argv0);
-    rc = 1;
-    goto shell_main_exit;
-#endif
-  }
-  data.out = stdout;
-  if( bEnableVfstrace ){
-    vfstrace_register("trace",0,vfstraceOut, &data, 1);
-  }
-#ifndef SQLITE_SHELL_FIDDLE
-  sqlite3_appendvfs_init(0,0,0);
-#ifdef SQLITE_DEBUG
-  sqlite3_auto_extension( (void (*)(void))auto_ext_leak_tester );
-#endif
-#endif
-  modeDefault(&data);
-
-  /* Go ahead and open the database file if it already exists.  If the
-  ** file does not exist, delay opening it.  This prevents empty database
-  ** files from being created if a user mistypes the database name argument
-  ** to the sqlite command-line tool.
-  */
-  if( access(data.pAuxDb->zDbFilename, 0)==0 ){
-    open_db(&data, 0);
-  }
-
-  /* Process the initialization file if there is one.  If no -init option
-  ** is given on the command line, look for a file named ~/.sqliterc and
-  ** try to process it.
-  */
-  if( !noInit ) process_sqliterc(&data,zInitFile);
-
-  /* Make a second pass through the command-line arguments and set
-  ** options.  This second pass is delayed until after the initialization
-  ** file is processed so that the command-line arguments will override
-  ** settings in the initialization file.
-  */
-  for(i=1; i<argc; i++){
-    char *z = argv[i];
-    if( z[0]!='-' || i>=nOptsEnd ) continue;
-    if( z[1]=='-' ){ z++; }
-    if( cli_strcmp(z,"-init")==0 ){
-      i++;
-    }else if( cli_strcmp(z,"-html")==0 ){
-      modeChange(&data, MODE_Html);
-    }else if( cli_strcmp(z,"-list")==0 ){
-      modeChange(&data, MODE_List);
-    }else if( cli_strcmp(z,"-quote")==0 ){
-      modeChange(&data, MODE_Quote);
-    }else if( cli_strcmp(z,"-line")==0 ){
-      modeChange(&data, MODE_Line);
-    }else if( cli_strcmp(z,"-column")==0 ){
-      modeChange(&data, MODE_Column);
-    }else if( cli_strcmp(z,"-json")==0 ){
-      modeChange(&data, MODE_Json);
-    }else if( cli_strcmp(z,"-markdown")==0 ){
-      modeChange(&data, MODE_Markdown);
-    }else if( cli_strcmp(z,"-table")==0 ){
-      modeChange(&data, MODE_Table);
-    }else if( cli_strcmp(z,"-psql")==0 ){
-      modeChange(&data, MODE_Psql);
-    }else if( cli_strcmp(z,"-box")==0 ){
-      modeChange(&data, MODE_Box);
-    }else if( cli_strcmp(z,"-csv")==0 ){
-      modeChange(&data, MODE_Csv);
-    }else if( cli_strcmp(z,"-escape")==0 && i+1<argc ){
-      /* See similar code at tag-20250224-1 */
-      const char *zEsc = argv[++i];
-      int k;
-      for(k=0; k<ArraySize(qrfEscNames); k++){
-        if( sqlite3_stricmp(zEsc,qrfEscNames[k])==0 ){
-          data.mode.spec.eEsc = k;
-          break;
-        }
-      }
-      if( k>=ArraySize(qrfEscNames) ){
-        cli_printf(stderr, "unknown control character escape mode \"%s\""
-                                " - choices:", zEsc);
-        for(k=0; k<ArraySize(qrfEscNames); k++){
-          cli_printf(stderr, " %s", qrfEscNames[k]);
-        }
-        cli_printf(stderr, "\n");
-        exit(1);
-      }
-#ifdef SQLITE_HAVE_ZLIB
-    }else if( cli_strcmp(z,"-zip")==0 ){
-      data.openMode = SHELL_OPEN_ZIPFILE;
-#endif
-    }else if( cli_strcmp(z,"-append")==0 ){
-      data.openMode = SHELL_OPEN_APPENDVFS;
-#ifndef SQLITE_OMIT_DESERIALIZE
-    }else if( cli_strcmp(z,"-deserialize")==0 ){
-      data.openMode = SHELL_OPEN_DESERIALIZE;
-    }else if( cli_strcmp(z,"-maxsize")==0 && i+1<argc ){
-      data.szMax = integerValue(argv[++i]);
-#endif
-    }else if( cli_strcmp(z,"-readonly")==0 ){
-      data.openFlags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
-      data.openFlags |= SQLITE_OPEN_READONLY;
-    }else if( cli_strcmp(z,"-nofollow")==0 ){
-      data.openFlags |= SQLITE_OPEN_NOFOLLOW;
-    }else if( cli_strcmp(z,"-noinit")==0 ){
-      /* No-op */
-    }else if( cli_strcmp(z,"-exclusive")==0 ){  /* UNDOCUMENTED */
-      data.openFlags |= SQLITE_OPEN_EXCLUSIVE;
-    }else if( cli_strcmp(z,"-ifexists")==0 ){
-      data.openFlags &= ~(SQLITE_OPEN_CREATE);
-      if( data.openFlags==0 ) data.openFlags = SQLITE_OPEN_READWRITE;
-    }else if( cli_strcmp(z,"-ascii")==0 ){
-      modeChange(&data, MODE_Ascii);
-    }else if( cli_strcmp(z,"-tabs")==0 ){
-      modeChange(&data, MODE_Tabs);
-    }else if( cli_strcmp(z,"-separator")==0 ){
-      modeSetStr(&data.mode.spec.zColumnSep, 
-                       cmdline_option_value(argc,argv,++i));
-    }else if( cli_strcmp(z,"-newline")==0 ){
-      modeSetStr(&data.mode.spec.zRowSep, 
-                       cmdline_option_value(argc,argv,++i));
-    }else if( cli_strcmp(z,"-nullvalue")==0 ){
-     modeSetStr(&data.mode.spec.zNull, 
-                       cmdline_option_value(argc,argv,++i));
-    }else if( cli_strcmp(z,"-header")==0 ){
-      data.mode.spec.bTitles = QRF_Yes;
-     }else if( cli_strcmp(z,"-noheader")==0 ){
-      data.mode.spec.bTitles = QRF_No;
-    }else if( cli_strcmp(z,"-echo")==0 ){
-      data.mode.mFlags |= MFLG_ECHO;
-    }else if( cli_strcmp(z,"-eqp")==0 ){
-      data.mode.autoEQP = AUTOEQP_on;
-    }else if( cli_strcmp(z,"-eqpfull")==0 ){
-      data.mode.autoEQP = AUTOEQP_full;
-    }else if( cli_strcmp(z,"-stats")==0 ){
-      data.statsOn = 1;
-    }else if( cli_strcmp(z,"-scanstats")==0 ){
-      data.mode.scanstatsOn = 1;
-    }else if( cli_strcmp(z,"-backslash")==0 ){
-      /* Undocumented command-line option: -backslash
-      ** Causes C-style backslash escapes to be evaluated in SQL statements
-      ** prior to sending the SQL into SQLite.  Useful for injecting
-      ** crazy bytes in the middle of SQL statements for testing and debugging.
-      */
-      ShellSetFlag(&data, SHFLG_Backslash);
-    }else if( cli_strcmp(z,"-bail")==0 ){
-      /* No-op.  The bail_on_error flag should already be set. */
-    }else if( cli_strcmp(z,"-version")==0 ){
-      cli_printf(stdout, "%s %s (%d-bit)\n",
-            sqlite3_libversion(), sqlite3_sourceid(), 8*(int)sizeof(char*));
-      rc = 0;
-      goto shell_main_exit;
-    }else if( cli_strcmp(z,"-interactive")==0 ){
-      /* Need to check for interactive override here to so that it can
-      ** affect console setup (for Windows only) and testing thereof.
-      */
-      stdin_is_interactive = 1;
-    }else if( cli_strcmp(z,"-batch")==0 ){
-      /* already handled */
-    }else if( cli_strcmp(z,"-screenwidth")==0 ){
-      i++;      
-    }else if( cli_strcmp(z,"-utf8")==0 ){
-      /* already handled */
-    }else if( cli_strcmp(z,"-no-utf8")==0 ){
-      /* already handled */
-    }else if( cli_strcmp(z,"-no-rowid-in-view")==0 ){
-      /* already handled */
-    }else if( cli_strcmp(z,"-heap")==0 ){
-      i++;
-    }else if( cli_strcmp(z,"-pagecache")==0 ){
-      i+=2;
-    }else if( cli_strcmp(z,"-lookaside")==0 ){
-      i+=2;
-    }else if( cli_strcmp(z,"-threadsafe")==0 ){
-      i+=2;
-    }else if( cli_strcmp(z,"-nonce")==0 ){
-      i += 2;
-    }else if( cli_strcmp(z,"-mmap")==0 ){
-      i++;
-    }else if( cli_strcmp(z,"-memtrace")==0 ){
-      i++;
-    }else if( cli_strcmp(z,"-pcachetrace")==0 ){
-      i++;
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    }else if( cli_strcmp(z,"-sorterref")==0 ){
-      i++;
-#endif
-    }else if( cli_strcmp(z,"-vfs")==0 ){
-      i++;
-    }else if( cli_strcmp(z,"-vfstrace")==0 ){
-      i++;
-#ifdef SQLITE_ENABLE_MULTIPLEX
-    }else if( cli_strcmp(z,"-multiplex")==0 ){
-      i++;
-#endif
-    }else if( cli_strcmp(z,"-help")==0 ){
-      usage(1);
-    }else if( cli_strcmp(z,"-cmd")==0 ){
-      /* Run commands that follow -cmd first and separately from commands
-      ** that simply appear on the command-line.  This seems goofy.  It would
-      ** be better if all commands ran in the order that they appear.  But
-      ** we retain the goofy behavior for historical compatibility. */
-      if( i==argc-1 ) break;
-      z = cmdline_option_value(argc,argv,++i);
-      if( z[0]=='.' ){
-        rc = do_meta_command(z, &data);
-        if( rc && (bail_on_error || rc==2) ){
-          if( rc==2 ) rc = 0;
-          goto shell_main_exit;
-        }
-      }else{
-        rc = runOneSqlLine(&data, z, "cmdline", i);
-        if( bail_on_error ) goto shell_main_exit;
-      }
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
-    }else if( cli_strncmp(z, "-A", 2)==0 ){
-      if( nCmd>0 ){
-        cli_printf(stderr,"Error: cannot mix regular SQL or dot-commands"
-              " with \"%s\"\n", z);
-        rc = 1;
-        goto shell_main_exit;
-      }
-      open_db(&data, OPEN_DB_ZIPFILE);
-      if( z[2] ){
-        argv[i] = &z[2];
-        arDotCommand(&data, 1, argv+(i-1), argc-(i-1));
-      }else{
-        arDotCommand(&data, 1, argv+i, argc-i);
-      }
-      readStdin = 0;
-      stdin_is_interactive = 0;
-      break;
-#endif
-    }else if( cli_strcmp(z,"-safe")==0 ){
-      data.bSafeMode = data.bSafeModePersist = 1;
-    }else if( cli_strcmp(z,"-unsafe-testing")==0 ){
-      /* Acted upon in first pass. */
-    }else{
-      cli_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
-      eputz("Use -help for a list of options.\n");
-      rc = 1;
-      goto shell_main_exit;
-    }
-  }
-
-  if( !readStdin ){
-    /* Run all arguments that do not begin with '-' as if they were separate
-    ** command-line inputs, except for the argToSkip argument which contains
-    ** the database filename.
-    */
-    for(i=0; i<nCmd; i++){
-      echo_group_input(&data, azCmd[i]);
-      if( isScriptFile(azCmd[i],0) ){
-        FILE *inSaved = data.in;
-        i64 savedLineno = data.lineno;
-        int res = 1;
-        if( (data.in = openChrSource(azCmd[i]))!=0 ){
-          res = process_input(&data, azCmd[i]);
-          fclose(data.in);
-        }
-        data.in = inSaved;
-        data.lineno = savedLineno;
-        if( res ) i = nCmd;
-      }else if( azCmd[i][0]=='.' ){
-        char *zErrCtx = malloc( 64 );
-        shell_check_oom(zErrCtx);
-        sqlite3_snprintf(64,zErrCtx,"argv[%i]:",aiCmd[i]);
-        data.zInFile = "<cmdline>";
-        data.zErrPrefix = zErrCtx;
-        rc = do_meta_command(azCmd[i], &data);
-        free(data.zErrPrefix);
-        data.zErrPrefix = 0;
-        if( rc ){
-          if( rc==2 ) rc = 0;
-          goto shell_main_exit;
-        }
-      }else{
-        rc = runOneSqlLine(&data, azCmd[i], "cmdline", aiCmd[i]);
-        if( data.nPopMode ){
-          modePop(&data);
-          data.nPopMode = 0;
-        }
-        if( rc ){
-          goto shell_main_exit;
-        }
-
-      }
-      if( data.nPopOutput && azCmd[i][0]!='.' ){
-        output_reset(&data);
-        data.nPopOutput = 0;
-      }else{
-        clearTempFile(&data);
-      }
-    }
-  }else{
-    /* Run commands received from standard input
-    */
-    if( stdin_is_interactive ){
-      char *zHome;
-      char *zHistory;
-      cli_printf(stdout,
-            "SQLite version %s %.19s\n" /*extra-version-info*/
-            "Enter \".help\" for usage hints.\n",
-            sqlite3_libversion(), sqlite3_sourceid());
-      if( warnInmemoryDb ){
-        sputz(stdout, "Connected to a ");
-        printBold("transient in-memory database");
-        sputz(stdout, ".\nUse \".open FILENAME\" to reopen on a"
-              " persistent database.\n");
-      }
-      zHistory = getenv("SQLITE_HISTORY");
-      if( zHistory ){
-        zHistory = sqlite3_mprintf("%s", zHistory);
-        shell_check_oom(zHistory);
-      }else{
-        zHistory = find_xdg_file("XDG_STATE_HOME",
-                                 ".local/state",
-                                 "sqlite_history");
-        if( 0==zHistory && (zHome = find_home_dir(0))!=0 ){
-          zHistory = sqlite3_mprintf("%s/.sqlite_history", zHome);
-          shell_check_oom(zHistory);
-        }
-      }
-      if( zHistory ){ shell_read_history(zHistory); }
-#if (HAVE_READLINE || HAVE_EDITLINE) && !defined(SQLITE_OMIT_READLINE_COMPLETION)
-      rl_attempted_completion_function = readline_completion;
-#elif HAVE_LINENOISE==1
-      linenoiseSetCompletionCallback(linenoise_completion);
-#elif HAVE_LINENOISE==2
-      linenoiseSetCompletionCallback(linenoise_completion, NULL);
-#endif
-      data.in = 0;
-      rc = process_input(&data, "<stdin>");
-      if( zHistory ){
-        shell_stifle_history(2000);
-        shell_write_history(zHistory);
-        sqlite3_free(zHistory);
-      }
-    }else{
-      data.in = stdin;
-      rc = process_input(&data, "<stdin>");
-    }
-  }
-#ifndef SQLITE_SHELL_FIDDLE
-  /* In WASM mode we have to leave the db state in place so that
-  ** client code can "push" SQL into it after this call returns. */
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_AUTHORIZATION)
-  if( data.expert.pExpert ){
-    expertFinish(&data, 1, 0);
-  }
-#endif
- shell_main_exit:
-  free(azCmd);
-  free(aiCmd);
-  set_table_name(&data, 0);
-  if( data.db ){
-    session_close_all(&data, -1);
-    close_db(data.db);
-  }
-  for(i=0; i<ArraySize(data.aAuxDb); i++){
-    sqlite3_free(data.aAuxDb[i].zFreeOnClose);
-    if( data.aAuxDb[i].db ){
-      session_close_all(&data, i);
-      close_db(data.aAuxDb[i].db);
-    }
-  }
-  find_home_dir(1);
-  output_reset(&data);
-  data.doXdgOpen = 0;
-  clearTempFile(&data);
-  modeFree(&data.mode);
-  if( data.nSavedModes ){
-    int ii;
-    for(ii=0; ii<data.nSavedModes; ii++){
-      modeFree(&data.aSavedModes[ii].mode);
-      free(data.aSavedModes[ii].zTag);
-    }
-    free(data.aSavedModes);
-  }
-  free(data.zErrPrefix);
-  free(data.zNonce);
-  free(data.dot.zCopy);
-  free(data.dot.azArg);
-  free(data.dot.aiOfst);
-  free(data.dot.abQuot);
-  if( data.nTestRun ){
-    sqlite3_fprintf(stdout, "%d test%s run with %d error%s\n",
-       data.nTestRun, data.nTestRun==1 ? "" : "s",
-       data.nTestErr, data.nTestErr==1 ? "" : "s");
-    fflush(stdout);
-    rc = data.nTestErr>0;
-  }
-  /* Clear the global data structure so that valgrind will detect memory
-  ** leaks */
-  memset(&data, 0, sizeof(data));
-  if( bEnableVfstrace ){
-    vfstrace_unregister("trace");
-  }
-  sqlite3_reset_auto_extension();
-#ifdef SQLITE_DEBUG
-  if( sqlite3_memory_used()>mem_main_enter ){
-    cli_printf(stderr,"Memory leaked: %u bytes\n",
-          (unsigned int)(sqlite3_memory_used()-mem_main_enter));
-  }
-#endif
-#else /* SQLITE_SHELL_FIDDLE... */
-  shell_main_exit:
-#endif
-  return rc;
-}
-
-
-#ifdef SQLITE_SHELL_FIDDLE
-/* Only for emcc experimentation purposes. */
-int fiddle_experiment(int a,int b){
-  return a + b;
-}
-
-/*
-** Returns a pointer to the current DB handle.
-*/
-sqlite3 * fiddle_db_handle(){
-  return globalDb;
-}
-
-/*
-** Returns a pointer to the given DB name's VFS. If zDbName is 0 then
-** "main" is assumed. Returns 0 if no db with the given name is
-** open.
-*/
-sqlite3_vfs * fiddle_db_vfs(const char *zDbName){
-  sqlite3_vfs * pVfs = 0;
-  if(globalDb){
-    sqlite3_file_control(globalDb, zDbName ? zDbName : "main",
-                         SQLITE_FCNTL_VFS_POINTER, &pVfs);
-  }
-  return pVfs;
-}
-
-/* Only for emcc experimentation purposes. */
-sqlite3 * fiddle_db_arg(sqlite3 *arg){
-    cli_printf(stdout, "fiddle_db_arg(%p)\n", (const void*)arg);
-    return arg;
-}
-
-/*
-** Intended to be called via a SharedWorker() while a separate
-** SharedWorker() (which manages the wasm module) is performing work
-** which should be interrupted. Unfortunately, SharedWorker is not
-** portable enough to make real use of.
-*/
-void fiddle_interrupt(void){
-  if( globalDb ) sqlite3_interrupt(globalDb);
-}
-
-/*
-** Returns the filename of the given db name, assuming "main" if
-** zDbName is NULL. Returns NULL if globalDb is not opened.
-*/
-const char * fiddle_db_filename(const char * zDbName){
-    return globalDb
-      ? sqlite3_db_filename(globalDb, zDbName ? zDbName : "main")
-      : NULL;
-}
-
-/*
-** Completely wipes out the contents of the currently-opened database
-** but leaves its storage intact for reuse. If any transactions are
-** active, they are forcibly rolled back.
-*/
-void fiddle_reset_db(void){
-  if( globalDb ){
-    int rc;
-    while( sqlite3_txn_state(globalDb,0)>0 ){
-      /*
-      ** Resolve problem reported in
-      ** https://sqlite.org/forum/forumpost/0b41a25d65
-      */
-      cli_puts("Rolling back in-progress transaction.\n", stdout);
-      sqlite3_exec(globalDb,"ROLLBACK", 0, 0, 0);
-    }
-    rc = sqlite3_db_config(globalDb, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0);
-    if( 0==rc ) sqlite3_exec(globalDb, "VACUUM", 0, 0, 0);
-    sqlite3_db_config(globalDb, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);
-  }
-}
-
-/*
-** Uses the current database's VFS xRead to stream the db file's
-** contents out to the given callback. The callback gets a single
-** chunk of size n (its 2nd argument) on each call and must return 0
-** on success, non-0 on error. This function returns 0 on success,
-** SQLITE_NOTFOUND if no db is open, or propagates any other non-0
-** code from the callback. Note that this is not thread-friendly: it
-** expects that it will be the only thread reading the db file and
-** takes no measures to ensure that is the case.
-*/
-int fiddle_export_db( int (*xCallback)(unsigned const char *zOut, int n) ){
-  sqlite3_int64 nSize = 0;
-  sqlite3_int64 nPos = 0;
-  sqlite3_file * pFile = 0;
-  unsigned char buf[1024 * 8];
-  int nBuf = (int)sizeof(buf);
-  int rc = shellState.db
-    ? sqlite3_file_control(shellState.db, "main",
-                           SQLITE_FCNTL_FILE_POINTER, &pFile)
-    : SQLITE_NOTFOUND;
-  if( rc ) return rc;
-  rc = pFile->pMethods->xFileSize(pFile, &nSize);
-  if( rc ) return rc;
-  if(nSize % nBuf){
-    /* DB size is not an even multiple of the buffer size. Reduce
-    ** buffer size so that we do not unduly inflate the db size when
-    ** exporting. */
-    if(0 == nSize % 4096) nBuf = 4096;
-    else if(0 == nSize % 2048) nBuf = 2048;
-    else if(0 == nSize % 1024) nBuf = 1024;
-    else nBuf = 512;
-  }
-  for( ; 0==rc && nPos<nSize; nPos += nBuf ){
-    rc = pFile->pMethods->xRead(pFile, buf, nBuf, nPos);
-    if(SQLITE_IOERR_SHORT_READ == rc){
-      rc = (nPos + nBuf) < nSize ? rc : 0/*assume EOF*/;
-    }
-    if( 0==rc ) rc = xCallback(buf, nBuf);
-  }
-  return rc;
-}
-
-/*
-** Trivial exportable function for emscripten. It processes zSql as if
-** it were input to the sqlite3 shell and redirects all output to the
-** wasm binding. fiddle_main() must have been called before this
-** is called, or results are undefined.
-*/
-void fiddle_exec(const char * zSql){
-  if(zSql && *zSql){
-    if('.'==*zSql) puts(zSql);
-    shellState.wasm.zInput = zSql;
-    shellState.wasm.zPos = zSql;
-    process_input(&shellState, "<stdin>");
-    shellState.wasm.zInput = shellState.wasm.zPos = 0;
-  }
-}
-#endif /* SQLITE_SHELL_FIDDLE */
-/************************* End src/shell.c.in ******************/
diff --git a/deps/sqlite-amalgamation-3530100/sqlite3.c b/deps/sqlite-amalgamation-3530100/sqlite3.c
deleted file mode 100644
index dfd557ad..00000000
--- a/deps/sqlite-amalgamation-3530100/sqlite3.c
+++ /dev/null
@@ -1,268860 +0,0 @@
-/******************************************************************************
-** This file is an amalgamation of many separate C source files from SQLite
-** version 3.53.1.  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.
-**
-** The content in this amalgamation comes from Fossil check-in
-** c88b22011a54b4f6fbd149e9f8e4de77658c with changes in files:
-**
-**    
-*/
-#ifndef SQLITE_AMALGAMATION
-#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 always be false
-**                                  and the correct answer is still obtained,
-**                                  though perhaps more slowly.
-**
-**    OPTIMIZATION-IF-FALSE       - This branch is allowed to always 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 <vxWorks.h>
-#include <pthread.h>  /* 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. */
-#ifndef OS_VXWORKS
-#  define OS_VXWORKS 0
-#endif
-#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 defined(__has_attribute)
-#  if __has_attribute(fallthrough)
-#    define deliberate_fall_through __attribute__((fallthrough));
-#  endif
-#endif
-#if !defined(deliberate_fall_through)
-#  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 <stdarg.h>     /* 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
-** <a href="http://fossil-scm.org/">Fossil configuration management
-** system</a>.  ^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.53.1"
-#define SQLITE_VERSION_NUMBER 3053001
-#define SQLITE_SOURCE_ID      "2026-05-05 10:34:17 c88b22011a54b4f6fbd149e9f8e4de77658ce58143a1af0e3785e4e6475127e9"
-#define SQLITE_SCM_BRANCH     "branch-3.53"
-#define SQLITE_SCM_TAGS       "release version-3.53.1"
-#define SQLITE_SCM_DATETIME   "2026-05-05T10:34:17.344Z"
-
-/*
-** 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.
-**
-** <blockquote><pre>
-** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
-** assert( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,80)==0 );
-** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
-** </pre></blockquote>)^
-**
-** ^The sqlite3_version[] string constant contains the text of the
-** [SQLITE_VERSION] macro.  ^The sqlite3_libversion() function returns a
-** pointer 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-separated 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 a 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:
-**
-** <ul>
-** <li> The application must ensure that the 1st parameter to sqlite3_exec()
-**      is a valid and open [database connection].
-** <li> The application must not close the [database connection] specified by
-**      the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
-** <li> The application must not modify the SQL statement text passed into
-**      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
-** <li> The application must not dereference the arrays or string pointers
-**       passed as the 3rd and 4th callback parameters after it returns.
-** </ul>
-*/
-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_ERROR_RESERVESIZE       (SQLITE_ERROR | (4<<8))
-#define SQLITE_ERROR_KEY               (SQLITE_ERROR | (5<<8))
-#define SQLITE_ERROR_UNABLE            (SQLITE_ERROR | (6<<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_IOERR_IN_PAGE           (SQLITE_IOERR | (34<<8))
-#define SQLITE_IOERR_BADKEY            (SQLITE_IOERR | (35<<8))
-#define SQLITE_IOERR_CODEC             (SQLITE_IOERR | (36<<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 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 been 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].
-**
-** The SQLITE_IOCAP_SUBPAGE_READ property means that it is ok to read
-** from the database file in amounts that are not a multiple of the
-** page size and that do not begin at a page boundary.  Without this
-** property, SQLite is careful to only do full-page reads and write
-** on aligned pages, with the one exception that it will do a sub-page
-** read of the first page to access the database header.
-*/
-#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
-#define SQLITE_IOCAP_SUBPAGE_READ           0x00008000
-
-/*
-** 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
-** least 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
-** <ul>
-** <li> [SQLITE_LOCK_NONE],
-** <li> [SQLITE_LOCK_SHARED],
-** <li> [SQLITE_LOCK_RESERVED],
-** <li> [SQLITE_LOCK_PENDING], or
-** <li> [SQLITE_LOCK_EXCLUSIVE].
-** </ul>
-** 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 one 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, via its output
-** pointer parameter, 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:
-**
-** <ul>
-** <li> [SQLITE_IOCAP_ATOMIC]
-** <li> [SQLITE_IOCAP_ATOMIC512]
-** <li> [SQLITE_IOCAP_ATOMIC1K]
-** <li> [SQLITE_IOCAP_ATOMIC2K]
-** <li> [SQLITE_IOCAP_ATOMIC4K]
-** <li> [SQLITE_IOCAP_ATOMIC8K]
-** <li> [SQLITE_IOCAP_ATOMIC16K]
-** <li> [SQLITE_IOCAP_ATOMIC32K]
-** <li> [SQLITE_IOCAP_ATOMIC64K]
-** <li> [SQLITE_IOCAP_SAFE_APPEND]
-** <li> [SQLITE_IOCAP_SEQUENTIAL]
-** <li> [SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN]
-** <li> [SQLITE_IOCAP_POWERSAFE_OVERWRITE]
-** <li> [SQLITE_IOCAP_IMMUTABLE]
-** <li> [SQLITE_IOCAP_BATCH_ATOMIC]
-** <li> [SQLITE_IOCAP_SUBPAGE_READ]
-** </ul>
-**
-** 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.
-**
-** <ul>
-** <li>[[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].
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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].
-**
-** <li>[[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].
-**
-** <li>[[SQLITE_FCNTL_SYNC_OMITTED]]
-** The SQLITE_FCNTL_SYNC_OMITTED file-control is no longer used.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_VFSNAME]]
-** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of
-** all [VFSes] in the VFS stack.  The names 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.
-**
-** <li>[[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 opcode 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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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].
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_NULL_IO]]
-** The [SQLITE_FCNTL_NULL_IO] opcode sets the low-level file descriptor
-** or file handle for the [sqlite3_file] object such that it will no longer
-** read or write to the database file.
-**
-** <li>[[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 <em>not</em> use this file-control.
-**
-** <li>[[SQLITE_FCNTL_ZIPVFS]]
-** The [SQLITE_FCNTL_ZIPVFS] opcode is implemented by zipvfs only. All other
-** VFS should return SQLITE_NOTFOUND for this opcode.
-**
-** <li>[[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.
-**
-** <li>[[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].
-**
-** <li>[[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].
-**
-** <li>[[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].
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_BLOCK_ON_CONNECT]]
-** The [SQLITE_FCNTL_BLOCK_ON_CONNECT] opcode is used to configure the
-** VFS to block when taking a SHARED lock to connect to a wal mode database.
-** This is used to implement the functionality associated with
-** SQLITE_SETLK_BLOCK_ON_CONNECT.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_CKSM_FILE]]
-** The [SQLITE_FCNTL_CKSM_FILE] opcode is for use internally by the
-** [checksum VFS shim] only.
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_FILESTAT]]
-** The [SQLITE_FCNTL_FILESTAT] opcode returns low-level diagnostic information
-** about the [sqlite3_file] objects used access the database and journal files
-** for the given schema.  The fourth parameter to [sqlite3_file_control()]
-** should be an initialized [sqlite3_str] pointer.  JSON text describing
-** various aspects of the sqlite3_file object is appended to the sqlite3_str.
-** The SQLITE_FCNTL_FILESTAT opcode is usually a no-op, unless compile-time
-** options are used to enable it.
-** </ul>
-*/
-#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
-#define SQLITE_FCNTL_NULL_IO                43
-#define SQLITE_FCNTL_BLOCK_ON_CONNECT       44
-#define SQLITE_FCNTL_FILESTAT               45
-
-/* 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
-
-/* reserved file-control numbers:
-**                                         101
-**                                         102
-**                                         103
-*/
-
-
-/*
-** 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:
-**
-** <ul>
-** <li>  sqlite3_filename_database()
-** <li>  sqlite3_filename_journal()
-** <li>  sqlite3_filename_wal()
-** <li>  sqlite3_uri_parameter()
-** <li>  sqlite3_uri_boolean()
-** <li>  sqlite3_uri_int64()
-** <li>  sqlite3_uri_key()
-** </ul>
-*/
-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:
-**
-** <ul>
-** <li>  [SQLITE_OPEN_MAIN_DB]
-** <li>  [SQLITE_OPEN_MAIN_JOURNAL]
-** <li>  [SQLITE_OPEN_TEMP_DB]
-** <li>  [SQLITE_OPEN_TEMP_JOURNAL]
-** <li>  [SQLITE_OPEN_TRANSIENT_DB]
-** <li>  [SQLITE_OPEN_SUBJOURNAL]
-** <li>  [SQLITE_OPEN_SUPER_JOURNAL]
-** <li>  [SQLITE_OPEN_WAL]
-** </ul>)^
-**
-** 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:
-**
-** <ul>
-** <li> [SQLITE_OPEN_DELETEONCLOSE]
-** <li> [SQLITE_OPEN_EXCLUSIVE]
-** </ul>
-**
-** 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 <i>not</i> 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 xNextSystemCall() 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:
-**
-** <ul>
-** <li>  SQLITE_SHM_LOCK | SQLITE_SHM_SHARED
-** <li>  SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE
-** <li>  SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED
-** <li>  SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE
-** </ul>
-**
-** 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 been 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.
-**
-** <b>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.</b>
-**
-** 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:
-** <ul>
-** <li> SQLITE_CONFIG_LOG
-** <li> SQLITE_CONFIG_PCACHE_HDRSZ
-** </ul>
-**
-** 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.
-**
-** <dl>
-** [[SQLITE_CONFIG_SINGLETHREAD]] <dt>SQLITE_CONFIG_SINGLETHREAD</dt>
-** <dd>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.</dd>
-**
-** [[SQLITE_CONFIG_MULTITHREAD]] <dt>SQLITE_CONFIG_MULTITHREAD</dt>
-** <dd>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.</dd>
-**
-** [[SQLITE_CONFIG_SERIALIZED]] <dt>SQLITE_CONFIG_SERIALIZED</dt>
-** <dd>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.</dd>
-**
-** [[SQLITE_CONFIG_MALLOC]] <dt>SQLITE_CONFIG_MALLOC</dt>
-** <dd> ^(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.</dd>
-**
-** [[SQLITE_CONFIG_GETMALLOC]] <dt>SQLITE_CONFIG_GETMALLOC</dt>
-** <dd> ^(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 simulates memory allocation failure or
-** tracks memory usage, for example. </dd>
-**
-** [[SQLITE_CONFIG_SMALL_MALLOC]] <dt>SQLITE_CONFIG_SMALL_MALLOC</dt>
-** <dd> ^The SQLITE_CONFIG_SMALL_MALLOC option takes a 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 applications 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.
-** </dd>
-**
-** [[SQLITE_CONFIG_MEMSTATUS]] <dt>SQLITE_CONFIG_MEMSTATUS</dt>
-** <dd> ^The SQLITE_CONFIG_MEMSTATUS option takes a 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:
-**   <ul>
-**   <li> [sqlite3_hard_heap_limit64()]
-**   <li> [sqlite3_memory_used()]
-**   <li> [sqlite3_memory_highwater()]
-**   <li> [sqlite3_soft_heap_limit64()]
-**   <li> [sqlite3_status64()]
-**   </ul>)^
-** ^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.
-** </dd>
-**
-** [[SQLITE_CONFIG_SCRATCH]] <dt>SQLITE_CONFIG_SCRATCH</dt>
-** <dd> The SQLITE_CONFIG_SCRATCH option is no longer used.
-** </dd>
-**
-** [[SQLITE_CONFIG_PAGECACHE]] <dt>SQLITE_CONFIG_PAGECACHE</dt>
-** <dd> ^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. </dd>
-**
-** [[SQLITE_CONFIG_HEAP]] <dt>SQLITE_CONFIG_HEAP</dt>
-** <dd> ^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.</dd>
-**
-** [[SQLITE_CONFIG_MUTEX]] <dt>SQLITE_CONFIG_MUTEX</dt>
-** <dd> ^(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 of 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].</dd>
-**
-** [[SQLITE_CONFIG_GETMUTEX]] <dt>SQLITE_CONFIG_GETMUTEX</dt>
-** <dd> ^(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].</dd>
-**
-** [[SQLITE_CONFIG_LOOKASIDE]] <dt>SQLITE_CONFIG_LOOKASIDE</dt>
-** <dd> ^(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 ("sz") and the second is the number of
-** slots allocated to each database connection ("cnt").)^
-** ^(SQLITE_CONFIG_LOOKASIDE sets the <i>default</i> lookaside size.
-** The [SQLITE_DBCONFIG_LOOKASIDE] option to [sqlite3_db_config()] can
-** be used to change the lookaside configuration on individual connections.)^
-** The [-DSQLITE_DEFAULT_LOOKASIDE] option can be used to change the
-** default lookaside configuration at compile-time.
-** </dd>
-**
-** [[SQLITE_CONFIG_PCACHE2]] <dt>SQLITE_CONFIG_PCACHE2</dt>
-** <dd> ^(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.</dd>
-**
-** [[SQLITE_CONFIG_GETPCACHE2]] <dt>SQLITE_CONFIG_GETPCACHE2</dt>
-** <dd> ^(The SQLITE_CONFIG_GETPCACHE2 option takes a single argument which
-** is a pointer to an [sqlite3_pcache_methods2] object.  SQLite copies off
-** the current page cache implementation into that object.)^ </dd>
-**
-** [[SQLITE_CONFIG_LOG]] <dt>SQLITE_CONFIG_LOG</dt>
-** <dd> 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
-** a 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. </dd>
-**
-** [[SQLITE_CONFIG_URI]] <dt>SQLITE_CONFIG_URI
-** <dd>^(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]] <dt>SQLITE_CONFIG_COVERING_INDEX_SCAN
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE
-** <dd> These options are obsolete and should not be used by new code.
-** They are retained for backwards compatibility but are now no-ops.
-** </dd>
-**
-** [[SQLITE_CONFIG_SQLLOG]]
-** <dt>SQLITE_CONFIG_SQLLOG
-** <dd>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.</dd>
-**
-** [[SQLITE_CONFIG_MMAP_SIZE]]
-** <dt>SQLITE_CONFIG_MMAP_SIZE
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_WIN32_HEAPSIZE
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_PCACHE_HDRSZ
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_PMASZ
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_STMTJRNL_SPILL
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_SORTERREF_SIZE
-** <dd>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 behavior.
-** This option is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option.
-**
-** [[SQLITE_CONFIG_MEMDB_MAXSIZE]]
-** <dt>SQLITE_CONFIG_MEMDB_MAXSIZE
-** <dd>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.
-**
-** [[SQLITE_CONFIG_ROWID_IN_VIEW]]
-** <dt>SQLITE_CONFIG_ROWID_IN_VIEW
-** <dd>The SQLITE_CONFIG_ROWID_IN_VIEW option enables or disables the ability
-** for VIEWs to have a ROWID.  The capability can only be enabled if SQLite is
-** compiled with -DSQLITE_ALLOW_ROWID_IN_VIEW, in which case the capability
-** defaults to on.  This configuration option queries the current setting or
-** changes the setting to off or on.  The argument is a pointer to an integer.
-** If that integer initially holds a value of 1, then the ability for VIEWs to
-** have ROWIDs is activated.  If the integer initially holds zero, then the
-** ability is deactivated.  Any other initial value for the integer leaves the
-** setting unchanged.  After changes, if any, the integer is written with
-** a 1 or 0, if the ability for VIEWs to have ROWIDs is on or off.  If SQLite
-** is compiled without -DSQLITE_ALLOW_ROWID_IN_VIEW (which is the usual and
-** recommended case) then the integer is always filled with zero, regardless
-** if its initial value.
-** </dl>
-*/
-#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 */
-#define SQLITE_CONFIG_ROWID_IN_VIEW       30  /* int* */
-
-/*
-** CAPI3REF: Database Connection Configuration Options
-**
-** These constants are the available integer configuration options that
-** can be passed as the second parameter to the [sqlite3_db_config()] interface.
-**
-** The [sqlite3_db_config()] interface is a var-args function.  It takes a
-** variable number of parameters, though always at least two.  The number of
-** parameters passed into sqlite3_db_config() depends on which of these
-** constants is given as the second parameter.  This documentation page
-** refers to parameters beyond the second as "arguments".  Thus, when this
-** page says "the N-th argument" it means "the N-th parameter past the
-** configuration option" or "the (N+2)-th parameter to sqlite3_db_config()".
-**
-** 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.
-**
-** <dl>
-** [[SQLITE_DBCONFIG_LOOKASIDE]]
-** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>
-** <dd> The SQLITE_DBCONFIG_LOOKASIDE option is used to adjust the
-** configuration of the [lookaside memory allocator] within a database
-** connection.
-** The arguments to the SQLITE_DBCONFIG_LOOKASIDE option are <i>not</i>
-** in the [DBCONFIG arguments|usual format].
-** The SQLITE_DBCONFIG_LOOKASIDE option takes three arguments, not two,
-** so that a call to [sqlite3_db_config()] that uses SQLITE_DBCONFIG_LOOKASIDE
-** should have a total of five parameters.
-** <ol>
-** <li><p>The first argument ("buf") is a
-** pointer to a memory buffer to use for lookaside memory.
-** The first argument may be NULL in which case SQLite will allocate the
-** lookaside buffer itself using [sqlite3_malloc()].
-** <li><P>The second argument ("sz") is the
-** size of each lookaside buffer slot.  Lookaside is disabled if "sz"
-** is less than 8.  The "sz" argument should be a multiple of 8 less than
-** 65536.  If "sz" does not meet this constraint, it is reduced in size until
-** it does.
-** <li><p>The third argument ("cnt") is the number of slots.
-** Lookaside is disabled if "cnt"is less than 1.
-*  The "cnt" value will be reduced, if necessary, so
-** that the product of "sz" and "cnt" does not exceed 2,147,418,112. The "cnt"
-** parameter is usually chosen so that the product of "sz" and "cnt" is less
-** than 1,000,000.
-** </ol>
-** <p>If the "buf" argument is not NULL, then it must
-** point to a memory buffer with a size that is greater than
-** or equal to the product of "sz" and "cnt".
-** The buffer must be aligned to an 8-byte boundary.
-** 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 value returned by [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].
-** If the "buf" argument is NULL and an attempt
-** to allocate memory based on "sz" and "cnt" fails, then
-** lookaside is silently disabled.
-** <p>
-** The [SQLITE_CONFIG_LOOKASIDE] configuration option can be used to set the
-** default lookaside configuration at initialization.  The
-** [-DSQLITE_DEFAULT_LOOKASIDE] option can be used to set the default lookaside
-** configuration at compile-time.  Typical values for lookaside are 1200 for
-** "sz" and 40 to 100 for "cnt".
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_FKEY]]
-** <dt>SQLITE_DBCONFIG_ENABLE_FKEY</dt>
-** <dd> ^This option is used to enable or disable the enforcement of
-** [foreign key constraints].  This is the same setting that is
-** enabled or disabled by the [PRAGMA foreign_keys] statement.
-** 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. </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]]
-** <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt>
-** <dd> ^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.
-**
-** <p>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.)^ </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_VIEW]]
-** <dt>SQLITE_DBCONFIG_ENABLE_VIEW</dt>
-** <dd> ^This option is used to enable or disable [CREATE VIEW | views].
-** There must 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.
-**
-** <p>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.)^ </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]]
-** <dt>SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER</dt>
-** <dd> ^This option is used to enable or disable using the
-** [fts3_tokenizer()] function - part of the [FTS3] full-text search engine
-** extension - without using bound parameters as the parameters. Doing so
-** is disabled by default. There must be two additional arguments. The first
-** argument is an integer. If it is passed 0, then using fts3_tokenizer()
-** without bound parameters is disabled. If it is passed a positive value,
-** then calling fts3_tokenizer without bound parameters is enabled. If it
-** is passed a negative value, this setting is not modified - this can be
-** used to query for the current setting. The second parameter is a pointer
-** to an integer into which is written 0 or 1 to indicate the current value
-** of this setting (after it is modified, if applicable).  The second
-** parameter may be a NULL pointer, in which case the value of the setting
-** is not reported back. Refer to [FTS3] documentation for further details.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]]
-** <dt>SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION</dt>
-** <dd> ^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 must 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 the 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_MAINDBNAME]] <dt>SQLITE_DBCONFIG_MAINDBNAME</dt>
-** <dd> ^This option is used to change the name of the "main" database
-** schema.  This option does not follow the
-** [DBCONFIG arguments|usual SQLITE_DBCONFIG argument format].
-** This option takes exactly one additional argument so that the
-** [sqlite3_db_config()] call has a total of three parameters.  The
-** extra argument must be 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 SQLITE_DBCONFIG MAINDBNAME
-** is unchanged until after the database connection closes.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE]]
-** <dt>SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE</dt>
-** <dd> Usually, when a database in [WAL mode] is closed or detached from a
-** database handle, SQLite checks if if there are other connections to the
-** same database, and if there are no other database connection (if the
-** connection being closed is the last open connection to the database),
-** then SQLite performs a [checkpoint] before closing the connection and
-** deletes the WAL file.  The SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE option can
-** be used to override that behavior. The first argument passed to this
-** operation (the third parameter to [sqlite3_db_config()]) is an integer
-** which is positive to disable checkpoints-on-close, or zero (the default)
-** to enable them, and negative to leave the setting unchanged.
-** The second argument (the fourth 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_QPSG]] <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt>
-** <dd>^(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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_TRIGGER_EQP]] <dt>SQLITE_DBCONFIG_TRIGGER_EQP</dt>
-** <dd> 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_RESET_DATABASE]] <dt>SQLITE_DBCONFIG_RESET_DATABASE</dt>
-** <dd> 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:
-** <ol>
-** <li> 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.
-** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0);
-** <li> [sqlite3_exec](db, "[VACUUM]", 0, 0, 0);
-** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);
-** </ol>
-** 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]] <dt>SQLITE_DBCONFIG_DEFENSIVE</dt>
-** <dd>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:
-** <ul>
-** <li> The [PRAGMA writable_schema=ON] statement.
-** <li> The [PRAGMA journal_mode=OFF] statement.
-** <li> The [PRAGMA schema_version=N] statement.
-** <li> Writes to the [sqlite_dbpage] virtual table.
-** <li> Direct writes to [shadow tables].
-** </ul>
-** </dd>
-**
-** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]] <dt>SQLITE_DBCONFIG_WRITABLE_SCHEMA</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_LEGACY_ALTER_TABLE]]
-** <dt>SQLITE_DBCONFIG_LEGACY_ALTER_TABLE</dt>
-** <dd>The SQLITE_DBCONFIG_LEGACY_ALTER_TABLE option activates or deactivates
-** the legacy behavior of the [ALTER TABLE RENAME] command such that 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_DQS_DML]]
-** <dt>SQLITE_DBCONFIG_DQS_DML</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_DQS_DDL]]
-** <dt>SQLITE_DBCONFIG_DQS_DDL</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_TRUSTED_SCHEMA]]
-** <dt>SQLITE_DBCONFIG_TRUSTED_SCHEMA</dt>
-** <dd>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:
-** <ul>
-** <li> 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].
-** <li> Prohibit the use of virtual tables inside of triggers or views
-** unless those virtual tables are tagged with [SQLITE_VTAB_INNOCUOUS].
-** </ul>
-** 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_LEGACY_FILE_FORMAT]]
-** <dt>SQLITE_DBCONFIG_LEGACY_FILE_FORMAT</dt>
-** <dd>The SQLITE_DBCONFIG_LEGACY_FILE_FORMAT option activates or deactivates
-** the legacy file format flag.  When activated, this flag causes all newly
-** created database files 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.
-** <p>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 descending indexes.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_STMT_SCANSTATUS]]
-** <dt>SQLITE_DBCONFIG_STMT_SCANSTATUS</dt>
-** <dd>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 run-time performance statistics
-** used by [sqlite3_stmt_scanstatus_v2()] and the [nexec and ncycle]
-** columns of the [bytecode virtual table].
-** For statistics to be collected, the flag must be set on
-** the database handle both when the SQL statement is
-** [sqlite3_prepare|prepared] and when it is [sqlite3_step|stepped].
-** The flag is set (collection of statistics is enabled) by default.
-** <p>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_REVERSE_SCANORDER]]
-** <dt>SQLITE_DBCONFIG_REVERSE_SCANORDER</dt>
-** <dd>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]. <p>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE]]
-** <dt>SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE</dt>
-** <dd>The SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE option enables or disables
-** the ability of the [ATTACH DATABASE] SQL command to create a new database
-** file if the database filed named in the ATTACH command does not already
-** exist.  This ability of ATTACH to create a new database is enabled by
-** default.  Applications can disable or reenable the ability for ATTACH to
-** create new database files using this DBCONFIG option.<p>
-** 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 attach-create 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 attach-create flag is set
-** after processing the first argument.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE]]
-** <dt>SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE</dt>
-** <dd>The SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE option enables or disables the
-** ability of the [ATTACH DATABASE] SQL command to open a database for writing.
-** This capability is enabled by default.  Applications can disable or
-** reenable this capability using the current DBCONFIG option.  If
-** this capability is disabled, the [ATTACH] command will still work,
-** but the database will be opened read-only.  If this option is disabled,
-** then the ability to create a new database using [ATTACH] is also disabled,
-** regardless of the value of the [SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE]
-** option.<p>
-** 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 ability to ATTACH another database for writing,
-** respectively.  If the second argument is not NULL, then 0 or 1 is written
-** into the integer to which the second argument points, depending on whether
-** the ability to ATTACH a read/write database is enabled or disabled
-** after processing the first argument.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_COMMENTS]]
-** <dt>SQLITE_DBCONFIG_ENABLE_COMMENTS</dt>
-** <dd>The SQLITE_DBCONFIG_ENABLE_COMMENTS option enables or disables the
-** ability to include comments in SQL text.  Comments are enabled by default.
-** An application can disable or reenable comments in SQL text using this
-** DBCONFIG option.<p>
-** 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 ability to use comments in SQL text,
-** 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
-** comments are allowed in SQL text after processing the first argument.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_FP_DIGITS]]
-** <dt>SQLITE_DBCONFIG_FP_DIGITS</dt>
-** <dd>The SQLITE_DBCONFIG_FP_DIGITS setting is a small integer that determines
-** the number of significant digits that SQLite will attempt to preserve when
-** converting floating point numbers (IEEE 754 "doubles") into text.  The
-** default value 17, as of SQLite version 3.52.0.  The value was 15 in all
-** prior versions.<p>
-** This option takes two arguments which are an integer and a pointer
-** to an integer.  The first argument is a small integer, between 3 and 23, or
-** zero.  The FP_DIGITS setting is changed to that small integer, or left
-** unaltered if the first argument is zero or out of range. The second argument
-** is a pointer to an integer.  If the pointer is not NULL, then the value of
-** the FP_DIGITS setting, after possibly being modified by the first
-** arguments, is written into the integer to which the second argument points.
-** </dd>
-**
-** </dl>
-**
-** [[DBCONFIG arguments]] <h3>Arguments To SQLITE_DBCONFIG Options</h3>
-**
-** <p>Most of the SQLITE_DBCONFIG options take two arguments, so that the
-** overall call to [sqlite3_db_config()] has a total of four parameters.
-** The first argument (the third parameter to sqlite3_db_config()) is
-** an integer.
-** The second argument is a pointer to an integer. If the first argument is 1,
-** then the option becomes enabled.  If the first integer argument is 0,
-** then the option is disabled.
-** If the first argument is -1, then the option setting
-** is unchanged.  The second argument, the pointer to an integer, may be NULL.
-** If the second argument is not NULL, then a value of 0 or 1 is written into
-** the integer to which the second argument points, depending on whether the
-** setting is disabled or enabled after applying any changes specified by
-** the first argument.
-**
-** <p>While most SQLITE_DBCONFIG options use the argument format
-** described in the previous paragraph, the [SQLITE_DBCONFIG_MAINDBNAME],
-** [SQLITE_DBCONFIG_LOOKASIDE], and [SQLITE_DBCONFIG_FP_DIGITS] options
-** are different.  See the documentation of those exceptional options for
-** details.
-*/
-#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_ENABLE_ATTACH_CREATE  1020 /* int int* */
-#define SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE   1021 /* int int* */
-#define SQLITE_DBCONFIG_ENABLE_COMMENTS       1022 /* int int* */
-#define SQLITE_DBCONFIG_FP_DIGITS             1023 /* int int* */
-#define SQLITE_DBCONFIG_MAX                   1023 /* 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.
-** For the purposes of this interface, a CREATE TABLE AS SELECT statement
-** does not count as an INSERT, UPDATE or DELETE statement and hence the rows
-** added to the new table by the CREATE TABLE AS SELECT statement are not
-** counted.
-**
-** ^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:
-**
-** <ul>
-**   <li> ^(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.)^
-**
-**   <li> ^(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.)^
-** </ul>
-**
-** ^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:
-** <ul>
-** <li> the [sqlite3_total_changes()] interface
-** <li> the [count_changes pragma]
-** <li> the [changes() SQL function]
-** <li> the [data_version pragma]
-** </ul>
-*/
-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:
-** <ul>
-** <li> the [sqlite3_changes()] interface
-** <li> the [count_changes pragma]
-** <li> the [changes() SQL function]
-** <li> the [data_version pragma]
-** <li> the [SQLITE_FCNTL_DATA_VERSION] [file control]
-** </ul>
-*/
-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.
-** It returns 1 if an interrupt is currently in effect, or 0 otherwise.
-*/
-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 and 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: Set the Setlk Timeout
-** METHOD: sqlite3
-**
-** This routine is only useful in SQLITE_ENABLE_SETLK_TIMEOUT builds. If
-** the VFS supports blocking locks, it sets the timeout in ms used by
-** eligible locks taken on wal mode databases by the specified database
-** handle. In non-SQLITE_ENABLE_SETLK_TIMEOUT builds, or if the VFS does
-** not support blocking locks, this function is a no-op.
-**
-** Passing 0 to this function disables blocking locks altogether. Passing
-** -1 to this function requests that the VFS blocks for a long time -
-** indefinitely if possible. The results of passing any other negative value
-** are undefined.
-**
-** Internally, each SQLite database handle stores two timeout values - the
-** busy-timeout (used for rollback mode databases, or if the VFS does not
-** support blocking locks) and the setlk-timeout (used for blocking locks
-** on wal-mode databases). The sqlite3_busy_timeout() method sets both
-** values, this function sets only the setlk-timeout value. Therefore,
-** to configure separate busy-timeout and setlk-timeout values for a single
-** database handle, call sqlite3_busy_timeout() followed by this function.
-**
-** Whenever the number of connections to a wal mode database falls from
-** 1 to 0, the last connection takes an exclusive lock on the database,
-** then checkpoints and deletes the wal file. While it is doing this, any
-** new connection that tries to read from the database fails with an
-** SQLITE_BUSY error. Or, if the SQLITE_SETLK_BLOCK_ON_CONNECT flag is
-** passed to this API, the new connection blocks until the exclusive lock
-** has been released.
-*/
-SQLITE_API int sqlite3_setlk_timeout(sqlite3*, int ms, int flags);
-
-/*
-** CAPI3REF: Flags for sqlite3_setlk_timeout()
-*/
-#define SQLITE_SETLK_BLOCK_ON_CONNECT 0x01
-
-/*
-** 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 <b>result table</b> is a 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:
-**
-** <blockquote><pre>
-**        Name        | Age
-**        -----------------------
-**        Alice       | 43
-**        Bob         | 28
-**        Cindy       | 21
-** </pre></blockquote>
-**
-** 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:
-**
-** <blockquote><pre>
-**        azResult&#91;0] = "Name";
-**        azResult&#91;1] = "Age";
-**        azResult&#91;2] = "Alice";
-**        azResult&#91;3] = "43";
-**        azResult&#91;4] = "Bob";
-**        azResult&#91;5] = "28";
-**        azResult&#91;6] = "Cindy";
-**        azResult&#91;7] = "21";
-** </pre></blockquote>)^
-**
-** ^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 it 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 the 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) interface 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 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: Deprecated Tracing And Profiling Functions
-** DEPRECATED
-**
-** 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.
-**
-** <dl>
-** [[SQLITE_TRACE_STMT]] <dt>SQLITE_TRACE_STMT</dt>
-** <dd>^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]] <dt>SQLITE_TRACE_PROFILE</dt>
-** <dd>^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]] <dt>SQLITE_TRACE_ROW</dt>
-** <dd>^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]] <dt>SQLITE_TRACE_CLOSE</dt>
-** <dd>^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.
-** </dl>
-*/
-#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(D,X,P) or sqlite3_trace_v2(D,M,X,P)
-** overrides (cancels) all prior calls to sqlite3_trace(D,X,P) or
-** sqlite3_trace_v2(D,M,X,P) for the [database connection] D.  Each
-** database connection may have at most one trace callback.
-**
-** ^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:)^
-**
-** <dl>
-** ^(<dt>[SQLITE_OPEN_READONLY]</dt>
-** <dd>The database is opened in read-only mode.  If the database does
-** not already exist, an error is returned.</dd>)^
-**
-** ^(<dt>[SQLITE_OPEN_READWRITE]</dt>
-** <dd>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.</dd>)^
-**
-** ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>
-** <dd>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().</dd>)^
-** </dl>
-**
-** In addition to the required flags, the following optional flags are
-** also supported:
-**
-** <dl>
-** ^(<dt>[SQLITE_OPEN_URI]</dt>
-** <dd>The filename can be interpreted as a URI if this flag is set.</dd>)^
-**
-** ^(<dt>[SQLITE_OPEN_MEMORY]</dt>
-** <dd>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.
-** </dd>)^
-**
-** ^(<dt>[SQLITE_OPEN_NOMUTEX]</dt>
-** <dd>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].
-**
-** ^(<dt>[SQLITE_OPEN_FULLMUTEX]</dt>
-** <dd>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.)
-**
-** ^(<dt>[SQLITE_OPEN_SHAREDCACHE]</dt>
-** <dd>The database is opened with [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.
-**
-** ^(<dt>[SQLITE_OPEN_PRIVATECACHE]</dt>
-** <dd>The database is opened with [shared cache] disabled, overriding
-** the default shared cache setting provided by
-** [sqlite3_enable_shared_cache()].)^
-**
-** [[OPEN_EXRESCODE]] ^(<dt>[SQLITE_OPEN_EXRESCODE]</dt>
-** <dd>The database connection comes up in "extended result code mode".
-** In other words, the database behaves as if
-** [sqlite3_extended_result_codes(db,1)] were 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.</dd>
-**
-** [[OPEN_NOFOLLOW]] ^(<dt>[SQLITE_OPEN_NOFOLLOW]</dt>
-** <dd>The database filename is not allowed to contain a symbolic link</dd>
-** </dl>)^
-**
-** 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()]] <h3>URI Filenames</h3>
-**
-** ^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:
-**
-** <ul>
-**   <li> <b>vfs</b>: ^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().
-**
-**   <li> <b>mode</b>: ^(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().
-**
-**   <li> <b>cache</b>: ^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.
-**
-**  <li> <b>psow</b>: ^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.
-**
-**  <li> <b>nolock</b>: ^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.
-**
-**  <li> <b>immutable</b>: ^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].
-**
-** </ul>
-**
-** ^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]] <h3>URI filename examples</h3>
-**
-** <table border="1" align=center cellpadding=5>
-** <tr><th> URI filenames <th> Results
-** <tr><td> file:data.db <td>
-**          Open the file "data.db" in the current directory.
-** <tr><td> file:/home/fred/data.db<br>
-**          file:///home/fred/data.db <br>
-**          file://localhost/home/fred/data.db <br> <td>
-**          Open the database file "/home/fred/data.db".
-** <tr><td> file://darkstar/home/fred/data.db <td>
-**          An error. "darkstar" is not a recognized authority.
-** <tr><td style="white-space:nowrap">
-**          file:///C:/Documents%20and%20Settings/fred/Desktop/data.db
-**     <td> 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.
-** <tr><td> file:data.db?mode=ro&cache=private <td>
-**          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.
-** <tr><td> file:/home/fred/data.db?vfs=unix-dotfile <td>
-**          Open file "/home/fred/data.db". Use the special VFS "unix-dotfile"
-**          that uses dot-files in place of posix advisory locking.
-** <tr><td> file:data.db?mode=readonly <td>
-**          An error. "readonly" is not a valid option for the "mode" parameter.
-**          Use "ro" instead:  "file:data.db?mode=ro".
-** </table>
-**
-** ^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.
-**
-** <b>Note to Windows users:</b>  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().
-**
-** <b>Note to Windows Runtime users:</b>  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:
-** <ul>
-** <li> A database filename pointer created by the SQLite core and
-** passed into the xOpen() method of a VFS implementation, or
-** <li> A filename obtained from [sqlite3_db_filename()], or
-** <li> A new filename constructed using [sqlite3_create_filename()].
-** </ul>
-** 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 interfaces 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
-** an array P of N URI Key/Value pairs.  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:
-** <ul>
-** <li> [sqlite3_uri_parameter()],
-** <li> [sqlite3_uri_boolean()],
-** <li> [sqlite3_uri_int64()],
-** <li> [sqlite3_uri_key()],
-** <li> [sqlite3_filename_database()],
-** <li> [sqlite3_filename_journal()], or
-** <li> [sqlite3_filename_wal()].
-** </ul>
-** 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:
-**
-** <ul>
-** <li> sqlite3_errcode()
-** <li> sqlite3_extended_errcode()
-** <li> sqlite3_errmsg()
-** <li> sqlite3_errmsg16()
-** <li> sqlite3_error_offset()
-** <li> sqlite3_db_handle()
-** </ul>
-**
-** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
-** text that describes the error, as either UTF-8 or UTF-16 respectively,
-** or NULL if no error message is available.
-** (See how SQLite handles [invalid UTF] for exceptions to this rule.)
-** ^(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(E) interface returns the English-language text
-** that describes the [result code] E, as UTF-8, or NULL if E is not a
-** result code for which a text error message is available.
-** ^(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 UTF-8.
-** ^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: Set Error Code And Message
-** METHOD: sqlite3
-**
-** Set the error code of the database handle passed as the first argument
-** to errcode, and the error message to a copy of nul-terminated string
-** zErrMsg. If zErrMsg is passed NULL, then the error message is set to
-** the default message associated with the supplied error code.  Subsequent
-** calls to [sqlite3_errcode()] and [sqlite3_errmsg()] and similar will
-** return the values set by this routine in place of what was previously
-** set by SQLite itself.
-**
-** This function returns SQLITE_OK if the error code and error message are
-** successfully set, SQLITE_NOMEM if an OOM occurs, and SQLITE_MISUSE if
-** the database handle is NULL or invalid.
-**
-** The error code and message set by this routine remains in effect until
-** they are changed, either by another call to this routine or until they are
-** changed to by SQLite itself to reflect the result of some subsquent
-** API call.
-**
-** This function is intended for use by SQLite extensions or wrappers.  The
-** idea is that an extension or wrapper can use this routine to set error
-** messages and error codes and thus behave more like a core SQLite
-** feature from the point of view of an application.
-*/
-SQLITE_API int sqlite3_set_errmsg(sqlite3 *db, int errcode, const char *zErrMsg);
-
-/*
-** 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:
-**
-** <ol>
-** <li> Create the prepared statement object using [sqlite3_prepare_v2()].
-** <li> Bind values to [parameters] using the sqlite3_bind_*()
-**      interfaces.
-** <li> Run the SQL by calling [sqlite3_step()] one or more times.
-** <li> Reset the prepared statement using [sqlite3_reset()] then go back
-**      to step 2.  Do this zero or more times.
-** <li> Destroy the object using [sqlite3_finalize()].
-** </ol>
-*/
-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_<i>NAME</i> there is a
-** [limits | hard upper bound]
-** set at compile-time by a C preprocessor macro called
-** [limits | SQLITE_MAX_<i>NAME</i>].
-** (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()].
-** A concise description of these limits follows, and additional information
-** is available at [limits | Limits in SQLite].
-**
-** <dl>
-** [[SQLITE_LIMIT_LENGTH]] ^(<dt>SQLITE_LIMIT_LENGTH</dt>
-** <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
-**
-** [[SQLITE_LIMIT_SQL_LENGTH]] ^(<dt>SQLITE_LIMIT_SQL_LENGTH</dt>
-** <dd>The maximum length of an SQL statement, in bytes.</dd>)^
-**
-** [[SQLITE_LIMIT_COLUMN]] ^(<dt>SQLITE_LIMIT_COLUMN</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(<dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
-** <dd>The maximum depth of the parse tree on any expression.</dd>)^
-**
-** [[SQLITE_LIMIT_PARSER_DEPTH]] ^(<dt>SQLITE_LIMIT_PARSER_DEPTH</dt>
-** <dd>The maximum depth of the LALR(1) parser stack used to analyze
-** input SQL statements.</dd>)^
-**
-** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
-** <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
-**
-** [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
-** <dd>The maximum number of arguments on a function.</dd>)^
-**
-** [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
-** <dd>The maximum number of [ATTACH | attached databases].)^</dd>
-**
-** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]]
-** ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
-** <dd>The maximum length of the pattern argument to the [LIKE] or
-** [GLOB] operators.</dd>)^
-**
-** [[SQLITE_LIMIT_VARIABLE_NUMBER]]
-** ^(<dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
-** <dd>The maximum index number of any [parameter] in an SQL statement.)^
-**
-** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
-** <dd>The maximum depth of recursion for triggers.</dd>)^
-**
-** [[SQLITE_LIMIT_WORKER_THREADS]] ^(<dt>SQLITE_LIMIT_WORKER_THREADS</dt>
-** <dd>The maximum number of auxiliary worker threads that a single
-** [prepared statement] may start.</dd>)^
-** </dl>
-*/
-#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
-#define SQLITE_LIMIT_PARSER_DEPTH             12
-
-/*
-** CAPI3REF: Prepare Flags
-**
-** These constants define various flags that can be passed into the
-** "prepFlags" parameter of the [sqlite3_prepare_v3()] and
-** [sqlite3_prepare16_v3()] interfaces.
-**
-** New flags may be added in future releases of SQLite.
-**
-** <dl>
-** [[SQLITE_PREPARE_PERSISTENT]] ^(<dt>SQLITE_PREPARE_PERSISTENT</dt>
-** <dd>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]] <dt>SQLITE_PREPARE_NORMALIZE</dt>
-** <dd>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]] <dt>SQLITE_PREPARE_NO_VTAB</dt>
-** <dd>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.
-**
-** [[SQLITE_PREPARE_DONT_LOG]] <dt>SQLITE_PREPARE_DONT_LOG</dt>
-** <dd>The SQLITE_PREPARE_DONT_LOG flag prevents SQL compiler
-** errors from being sent to the error log defined by
-** [SQLITE_CONFIG_LOG].  This can be used, for example, to do test
-** compiles to see if some SQL syntax is well-formed, without generating
-** messages on the global error log when it is not.  If the test compile
-** fails, the sqlite3_prepare_v3() call returns the same error indications
-** with or without this flag; it just omits the call to [sqlite3_log()] that
-** logs the error.
-**
-** [[SQLITE_PREPARE_FROM_DDL]] <dt>SQLITE_PREPARE_FROM_DDL</dt>
-** <dd>The SQLITE_PREPARE_FROM_DDL flag causes the SQL compiler to enforce
-** security constraints that would otherwise only be enforced when parsing
-** the database schema.  In other words, the SQLITE_PREPARE_FROM_DDL flag
-** causes the SQL compiler to treat the SQL statement being prepared as if
-** it had come from an attacker.  When SQLITE_PREPARE_FROM_DDL is used and
-** [SQLITE_DBCONFIG_TRUSTED_SCHEMA] is off, SQL functions may only be called
-** if they are tagged with [SQLITE_INNOCUOUS] and virtual tables may only
-** be used if they are tagged with [SQLITE_VTAB_INNOCUOUS].  Best practice
-** is to use the SQLITE_PREPARE_FROM_DDL option when preparing any SQL that
-** is derived from parts of the database schema. In particular, virtual
-** table implementations that run SQL statements that are derived from
-** arguments to their CREATE VIRTUAL TABLE statement should always use
-** [sqlite3_prepare_v3()] and set the SQLITE_PREPARE_FROM_DDL flag to
-** prevent bypass of the [SQLITE_DBCONFIG_TRUSTED_SCHEMA] security checks.
-** </dl>
-*/
-#define SQLITE_PREPARE_PERSISTENT              0x01
-#define SQLITE_PREPARE_NORMALIZE               0x02
-#define SQLITE_PREPARE_NO_VTAB                 0x04
-#define SQLITE_PREPARE_DONT_LOG                0x10
-#define SQLITE_PREPARE_FROM_DDL                0x20
-
-/*
-** 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
-** [SQLITE_PREPARE_FROM_DDL|"prepFlags" option] that is sometimes
-** needed for special purpose or to pass along security restrictions.
-**
-** 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 maximum
-** number of bytes read from zSql.  When nByte is positive, zSql is read
-** up to the first zero terminator or until the nByte bytes have been read,
-** whichever comes first.  ^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 <i>including</i>
-** the nul-terminator.
-** Note that nByte measures the length of the input in bytes, not
-** characters, even for the UTF-16 interfaces.
-**
-** ^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:
-**
-** <ol>
-** <li>
-** ^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.
-** </li>
-**
-** <li>
-** ^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.
-** </li>
-**
-** <li>
-** ^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.
-** </li>
-** </ol>
-**
-** <p>^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
-** 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:
-**
-** <blockquote><pre>
-**    SELECT eval('DELETE FROM t1') FROM t2;
-** </pre></blockquote>
-**
-** 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: Change The EXPLAIN Setting For A Prepared Statement
-** METHOD: sqlite3_stmt
-**
-** The sqlite3_stmt_explain(S,E) interface changes the EXPLAIN
-** setting for [prepared statement] S.  If E is zero, then S becomes
-** a normal prepared statement.  If E is 1, then S behaves as if
-** its SQL text began with "[EXPLAIN]".  If E is 2, then S behaves as if
-** its SQL text began with "[EXPLAIN QUERY PLAN]".
-**
-** Calling sqlite3_stmt_explain(S,E) might cause S to be reprepared.
-** SQLite tries to avoid a reprepare, but a reprepare might be necessary
-** on the first transition into EXPLAIN or EXPLAIN QUERY PLAN mode.
-**
-** Because of the potential need to reprepare, a call to
-** sqlite3_stmt_explain(S,E) will fail with SQLITE_ERROR if S cannot be
-** reprepared because it was created using [sqlite3_prepare()] instead of
-** the newer [sqlite3_prepare_v2()] or [sqlite3_prepare_v3()] interfaces and
-** hence has no saved SQL text with which to reprepare.
-**
-** Changing the explain setting for a prepared statement does not change
-** the original SQL text for the statement.  Hence, if the SQL text originally
-** began with EXPLAIN or EXPLAIN QUERY PLAN, but sqlite3_stmt_explain(S,0)
-** is called to convert the statement into an ordinary statement, the EXPLAIN
-** or EXPLAIN QUERY PLAN keywords will still appear in the sqlite3_sql(S)
-** output, even though the statement now acts like a normal SQL statement.
-**
-** This routine returns SQLITE_OK if the explain mode is successfully
-** changed, or an error code if the explain mode could not be changed.
-** The explain mode cannot be changed while a statement is active.
-** Hence, it is good practice to call [sqlite3_reset(S)]
-** immediately prior to calling sqlite3_stmt_explain(S,E).
-*/
-SQLITE_API int sqlite3_stmt_explain(sqlite3_stmt *pStmt, int eMode);
-
-/*
-** 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 the 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 the following
-** templates:
-**
-** <ul>
-** <li>  ?
-** <li>  ?NNN
-** <li>  :VVV
-** <li>  @VVV
-** <li>  $VVV
-** </ul>
-**
-** 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 SQLITE_UTF8_ZT,
-** 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 the 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 <u>bytes</u> 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 occur 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 passed 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 (the E argument)
-** to sqlite3_bind_text64(S,K,Z,N,D,E) must be one of
-** [SQLITE_UTF8], [SQLITE_UTF8_ZT], [SQLITE_UTF16], [SQLITE_UTF16BE],
-** or [SQLITE_UTF16LE] to specify the encoding of the text in the
-** third parameter, Z.  The special value [SQLITE_UTF8_ZT] means that the
-** string argument is both UTF-8 encoded and is zero-terminated.  In other
-** words, SQLITE_UTF8_ZT means that the Z array is allocated to hold at
-** least N+1 bytes and that the Z&#91;N&#93; byte is zero.  If
-** the E argument to sqlite3_bind_text64(S,K,Z,N,D,E) 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, even if the call to sqlite3_bind_pointer() fails.  Due to a
-** historical design quirk, results are undefined if D is
-** SQLITE_TRANSIENT. 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 a
-** [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.
-**
-** <b>Goofy Interface Alert:</b> 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:
-**
-** <ul>
-** <li> 64-bit signed integer
-** <li> 64-bit IEEE floating point number
-** <li> string
-** <li> BLOB
-** <li> NULL
-** </ul>)^
-**
-** 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
-**
-** <b>Summary:</b>
-** <blockquote><table border=0 cellpadding=0 cellspacing=0>
-** <tr><td><b>sqlite3_column_blob</b><td>&rarr;<td>BLOB result
-** <tr><td><b>sqlite3_column_double</b><td>&rarr;<td>REAL result
-** <tr><td><b>sqlite3_column_int</b><td>&rarr;<td>32-bit INTEGER result
-** <tr><td><b>sqlite3_column_int64</b><td>&rarr;<td>64-bit INTEGER result
-** <tr><td><b>sqlite3_column_text</b><td>&rarr;<td>UTF-8 TEXT result
-** <tr><td><b>sqlite3_column_text16</b><td>&rarr;<td>UTF-16 TEXT result
-** <tr><td><b>sqlite3_column_value</b><td>&rarr;<td>The result as an
-** [sqlite3_value|unprotected sqlite3_value] object.
-** <tr><td>&nbsp;<td>&nbsp;<td>&nbsp;
-** <tr><td><b>sqlite3_column_bytes</b><td>&rarr;<td>Size of a BLOB
-** or a UTF-8 TEXT result in bytes
-** <tr><td><b>sqlite3_column_bytes16&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>Size of UTF-16
-** TEXT in bytes
-** <tr><td><b>sqlite3_column_type</b><td>&rarr;<td>Default
-** datatype of the result
-** </table></blockquote>
-**
-** <b>Details:</b>
-**
-** ^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.
-**
-** <b>Warning:</b> ^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:
-**
-** <blockquote>
-** <table border="1">
-** <tr><th> Internal<br>Type <th> Requested<br>Type <th>  Conversion
-**
-** <tr><td>  NULL    <td> INTEGER   <td> Result is 0
-** <tr><td>  NULL    <td>  FLOAT    <td> Result is 0.0
-** <tr><td>  NULL    <td>   TEXT    <td> Result is a NULL pointer
-** <tr><td>  NULL    <td>   BLOB    <td> Result is a NULL pointer
-** <tr><td> INTEGER  <td>  FLOAT    <td> Convert from integer to float
-** <tr><td> INTEGER  <td>   TEXT    <td> ASCII rendering of the integer
-** <tr><td> INTEGER  <td>   BLOB    <td> Same as INTEGER->TEXT
-** <tr><td>  FLOAT   <td> INTEGER   <td> [CAST] to INTEGER
-** <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
-** <tr><td>  FLOAT   <td>   BLOB    <td> [CAST] to BLOB
-** <tr><td>  TEXT    <td> INTEGER   <td> [CAST] to INTEGER
-** <tr><td>  TEXT    <td>  FLOAT    <td> [CAST] to REAL
-** <tr><td>  TEXT    <td>   BLOB    <td> No change
-** <tr><td>  BLOB    <td> INTEGER   <td> [CAST] to INTEGER
-** <tr><td>  BLOB    <td>  FLOAT    <td> [CAST] to REAL
-** <tr><td>  BLOB    <td>   TEXT    <td> [CAST] to TEXT, ensure zero terminator
-** </table>
-** </blockquote>)^
-**
-** 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:
-**
-** <ul>
-** <li> 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.</li>
-** <li> 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.</li>
-** <li> 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.</li>
-** </ul>
-**
-** ^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:
-**
-** <ul>
-**  <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
-**  <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
-**  <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
-** </ul>
-**
-** 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:
-**
-** <ul>
-** <li> sqlite3_column_blob()
-** <li> sqlite3_column_text()
-** <li> sqlite3_column_text16()
-** <li> sqlite3_column_bytes()
-** <li> sqlite3_column_bytes16()
-** </ul>
-**
-** 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 has 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.
-**
-** ^The return code from [sqlite3_reset(S)] indicates whether or not
-** the previous evaluation of prepared statement S completed successfully.
-** ^If [sqlite3_step(S)] has never before been called on S or if
-** [sqlite3_step(S)] has not been called since the previous call
-** to [sqlite3_reset(S)], then [sqlite3_reset(S)] will return
-** [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 might also return an [error code]
-** if there were no prior errors but the process of resetting
-** the prepared statement caused a new error. ^For example, if an
-** [INSERT] statement with a [RETURNING] clause is only stepped one time,
-** that one call to [sqlite3_step(S)] might return SQLITE_ROW but
-** the overall statement might still fail and the [sqlite3_reset(S)] call
-** might return SQLITE_BUSY if locking constraints prevent the
-** database change from committing.  Therefore, it is important that
-** applications check the return code from [sqlite3_reset(S)] even if
-** no prior call to [sqlite3_step(S)] indicated a problem.
-**
-** ^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, views, CHECK constraints, or other elements of
-** the database schema.  This flag 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 the 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 constants define integer codes that represent the various
-** text encodings supported by SQLite.
-**
-** <dl>
-** [[SQLITE_UTF8]] <dt>SQLITE_UTF8</dt><dd>Text is encoding as UTF-8</dd>
-**
-** [[SQLITE_UTF16LE]] <dt>SQLITE_UTF16LE</dt><dd>Text is encoding as UTF-16
-** with each code point being expressed "little endian" - the least significant
-** byte first.  This is the usual encoding, for example on Windows.</dd>
-**
-** [[SQLITE_UTF16BE]] <dt>SQLITE_UTF16BE</dt><dd>Text is encoding as UTF-16
-** with each code point being expressed "big endian" - the most significant
-** byte first.  This encoding is less common, but is still sometimes seen,
-** specially on older systems.
-**
-** [[SQLITE_UTF16]] <dt>SQLITE_UTF16</dt><dd>Text is encoding as UTF-16
-** with each code point being expressed either little endian or as big
-** endian, according to the native endianness of the host computer.
-**
-** [[SQLITE_ANY]] <dt>SQLITE_ANY</dt><dd>This encoding value may only be used
-** to declare the preferred text for [application-defined SQL functions]
-** created using [sqlite3_create_function()] and similar.  If the preferred
-** encoding (the 4th parameter to sqlite3_create_function() - the eTextRep
-** parameter) is SQLITE_ANY, that indicates that the function does not have
-** a preference regarding the text encoding of its parameters and can take
-** any text encoding that the SQLite core find convenient to supply.  This
-** option is deprecated.  Please do not use it in new applications.
-**
-** [[SQLITE_UTF16_ALIGNED]] <dt>SQLITE_UTF16_ALIGNED</dt><dd>This encoding
-** value may be used as the 3rd parameter (the eTextRep parameter) to
-** [sqlite3_create_collation()] and similar.  This encoding value means
-** that the application-defined collating sequence created expects its
-** input strings to be in UTF16 in native byte order, and that the start
-** of the strings must be aligned to a 2-byte boundary.
-**
-** [[SQLITE_UTF8_ZT]] <dt>SQLITE_UTF8_ZT</dt><dd>This option can only be
-** used to specify the text encoding to strings input to
-** [sqlite3_result_text64()] and [sqlite3_bind_text64()].
-** The SQLITE_UTF8_ZT encoding means that the input string (call it "z")
-** is UTF-8 encoded and that it is zero-terminated.  If the length parameter
-** (call it "n") is non-negative, this encoding option means that the caller
-** guarantees that z array contains at least n+1 bytes and that the z&#91;n&#93;
-** byte has a value of zero.
-** This option gives the same output as SQLITE_UTF8, but can be more efficient
-** by avoiding the need to make a copy of the input string, in some cases.
-** However, if z is allocated to hold fewer than n+1 bytes or if the
-** z&#91;n&#93; byte is not zero, undefined behavior may result.
-** </dl>
-*/
-#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 */
-#define SQLITE_UTF8_ZT       16    /* Zero-terminated UTF8 */
-
-/*
-** 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()].
-**
-** <dl>
-** [[SQLITE_DETERMINISTIC]] <dt>SQLITE_DETERMINISTIC</dt><dd>
-** 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.
-** </dd>
-**
-** [[SQLITE_DIRECTONLY]] <dt>SQLITE_DIRECTONLY</dt><dd>
-** 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].
-** <p>
-** 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 surreptitiously
-** modified to invoke the application-defined function in ways that are
-** harmful.
-** <p>
-** 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.
-** </dd>
-**
-** [[SQLITE_INNOCUOUS]] <dt>SQLITE_INNOCUOUS</dt><dd>
-** 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.
-** <p> 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.
-** <p>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.
-** </dd>
-**
-** [[SQLITE_SUBTYPE]] <dt>SQLITE_SUBTYPE</dt><dd>
-** The SQLITE_SUBTYPE flag indicates to SQLite that a function might call
-** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
-** This flag instructs SQLite to omit some corner-case optimizations that
-** might disrupt the operation of the [sqlite3_value_subtype()] function,
-** causing it to return zero rather than the correct subtype().
-** All SQL functions that invoke [sqlite3_value_subtype()] should have this
-** property.  If the SQLITE_SUBTYPE property is omitted, then the return
-** value from [sqlite3_value_subtype()] might sometimes be zero even though
-** a non-zero subtype was specified by the function argument expression.
-**
-** [[SQLITE_RESULT_SUBTYPE]] <dt>SQLITE_RESULT_SUBTYPE</dt><dd>
-** The SQLITE_RESULT_SUBTYPE flag indicates to SQLite that a function might call
-** [sqlite3_result_subtype()] to cause a sub-type to be associated with its
-** result.
-** Every function that invokes [sqlite3_result_subtype()] should have this
-** property.  If it does not, then the call to [sqlite3_result_subtype()]
-** might become a no-op if the function is used as a term in an
-** [expression index].  On the other hand, SQL functions that never invoke
-** [sqlite3_result_subtype()] should avoid setting this property, as the
-** purpose of this property is to disable certain optimizations that are
-** incompatible with subtypes.
-**
-** [[SQLITE_SELFORDER1]] <dt>SQLITE_SELFORDER1</dt><dd>
-** The SQLITE_SELFORDER1 flag indicates that the function is an aggregate
-** that internally orders the values provided to the first argument.  The
-** ordered-set aggregate SQL notation with a single ORDER BY term can be
-** used to invoke this function.  If the ordered-set aggregate notation is
-** used on a function that lacks this flag, then an error is raised. Note
-** that the ordered-set aggregate syntax is only available if SQLite is
-** built using the -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES compile-time option.
-** </dd>
-** </dl>
-*/
-#define SQLITE_DETERMINISTIC    0x000000800
-#define SQLITE_DIRECTONLY       0x000080000
-#define SQLITE_SUBTYPE          0x000100000
-#define SQLITE_INNOCUOUS        0x000200000
-#define SQLITE_RESULT_SUBTYPE   0x001000000
-#define SQLITE_SELFORDER1       0x002000000
-
-/*
-** 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
-**
-** <b>Summary:</b>
-** <blockquote><table border=0 cellpadding=0 cellspacing=0>
-** <tr><td><b>sqlite3_value_blob</b><td>&rarr;<td>BLOB value
-** <tr><td><b>sqlite3_value_double</b><td>&rarr;<td>REAL value
-** <tr><td><b>sqlite3_value_int</b><td>&rarr;<td>32-bit INTEGER value
-** <tr><td><b>sqlite3_value_int64</b><td>&rarr;<td>64-bit INTEGER value
-** <tr><td><b>sqlite3_value_pointer</b><td>&rarr;<td>Pointer value
-** <tr><td><b>sqlite3_value_text</b><td>&rarr;<td>UTF-8 TEXT value
-** <tr><td><b>sqlite3_value_text16</b><td>&rarr;<td>UTF-16 TEXT value in
-** the native byteorder
-** <tr><td><b>sqlite3_value_text16be</b><td>&rarr;<td>UTF-16be TEXT value
-** <tr><td><b>sqlite3_value_text16le</b><td>&rarr;<td>UTF-16le TEXT value
-** <tr><td>&nbsp;<td>&nbsp;<td>&nbsp;
-** <tr><td><b>sqlite3_value_bytes</b><td>&rarr;<td>Size of a BLOB
-** or a UTF-8 TEXT in bytes
-** <tr><td><b>sqlite3_value_bytes16&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>Size of UTF-16
-** TEXT in bytes
-** <tr><td><b>sqlite3_value_type</b><td>&rarr;<td>Default
-** datatype of the value
-** <tr><td><b>sqlite3_value_numeric_type&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>Best numeric datatype of the value
-** <tr><td><b>sqlite3_value_nochange&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>True if the column is unchanged in an UPDATE
-** against a virtual table.
-** <tr><td><b>sqlite3_value_frombind&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>True if value originated from a [bound parameter]
-** </table></blockquote>
-**
-** <b>Details:</b>
-**
-** 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
-** the prior [xColumn] method call that was invoked to extract
-** 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 while trying to do a
-** UTF8&rarr;UTF16 or UTF16&rarr;UTF8 conversion.
-** 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.
-** If the input sqlite3_value was not obtained from [sqlite3_value_dup()],
-** then valid SQL NULL returns can also be distinguished from
-** out-of-memory errors after extracting the value
-** by invoking the [sqlite3_errcode()] immediately after the suspicious
-** return value is obtained and before any
-** other SQLite interface is called on the same [database connection].
-** If the input sqlite3_value was obtained from sqlite3_value_dup() then
-** it is disconnected from the database connection and so sqlite3_errcode()
-** will not work.
-** In that case, the only way to distinguish an out-of-memory
-** condition from a true SQL NULL is to invoke sqlite3_value_type() on the
-** input to see if it is NULL prior to trying to extract the value.
-*/
-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.
-**
-** Every [application-defined SQL function] that invokes this interface
-** should include the [SQLITE_SUBTYPE] property in the text
-** encoding argument when the function is [sqlite3_create_function|registered].
-** If the [SQLITE_SUBTYPE] property is omitted, then sqlite3_value_subtype()
-** might return zero instead of the upstream subtype in some corner cases.
-*/
-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 V 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 the 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 auxiliary data with argument values. If the same argument
-** value is passed to multiple invocations of the same SQL function during
-** query execution, under some circumstances the associated auxiliary data
-** might 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 auxiliary data 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 auxiliary
-** data 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 auxiliary data
-** 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 auxiliary data 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 auxiliary data is still valid or
-** NULL if the auxiliary data 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 auxiliary data is discarded.
-** SQLite is free to discard the auxiliary data at any time, including: <ul>
-** <li> ^(when the corresponding function parameter changes)^, or
-** <li> ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
-**      SQL statement)^, or
-** <li> ^(when sqlite3_set_auxdata() is invoked again on the same
-**       parameter)^, or
-** <li> ^(during the original sqlite3_set_auxdata() call when a memory
-**      allocation error occurs.)^
-** <li> ^(during the original sqlite3_set_auxdata() call if the function
-**      is evaluated during query planning instead of during query execution,
-**      as sometimes happens with [SQLITE_ENABLE_STAT4].)^ </ul>
-**
-** Note the last two bullets 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.  Furthermore, a call to
-** sqlite3_get_auxdata() that occurs immediately after a corresponding call
-** to sqlite3_set_auxdata() might still return NULL if an out-of-memory
-** condition occurred during the sqlite3_set_auxdata() call or if the
-** function is being evaluated during query planning rather than during
-** query execution.
-**
-** ^(In practice, auxiliary data 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.
-**
-** See also: [sqlite3_get_clientdata()] and [sqlite3_set_clientdata()].
-*/
-SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
-SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
-
-/*
-** CAPI3REF: Database Connection Client Data
-** METHOD: sqlite3
-**
-** These functions are used to associate one or more named pointers
-** with a [database connection].
-** A call to sqlite3_set_clientdata(D,N,P,X) causes the pointer P
-** to be attached to [database connection] D using name N.  Subsequent
-** calls to sqlite3_get_clientdata(D,N) will return a copy of pointer P
-** or a NULL pointer if there were no prior calls to
-** sqlite3_set_clientdata() with the same values of D and N.
-** Names are compared using strcmp() and are thus case sensitive.
-** It returns 0 on success and SQLITE_NOMEM on allocation failure.
-**
-** If P and X are both non-NULL, then the destructor X is invoked with
-** argument P on the first of the following occurrences:
-** <ul>
-** <li> An out-of-memory error occurs during the call to
-**      sqlite3_set_clientdata() which attempts to register pointer P.
-** <li> A subsequent call to sqlite3_set_clientdata(D,N,P,X) is made
-**      with the same D and N parameters.
-** <li> The database connection closes.  SQLite does not make any guarantees
-**      about the order in which destructors are called, only that all
-**      destructors will be called exactly once at some point during the
-**      database connection closing process.
-** </ul>
-**
-** SQLite does not do anything with client data other than invoke
-** destructors on the client data at the appropriate time.  The intended
-** use for client data is to provide a mechanism for wrapper libraries
-** to store additional information about an SQLite database connection.
-**
-** There is no limit (other than available memory) on the number of different
-** client data pointers (with different names) that can be attached to a
-** single database connection.  However, the current implementation stores
-** the content on a linked list.  Insert and retrieval performance will
-** be proportional to the number of entries.  The design use case, and
-** the use case for which the implementation is optimized, is
-** that an application will store only small number of client data names,
-** typically just one or two.  This interface is not intended to be a
-** generalized key/value store for thousands or millions of keys.  It
-** will work for that, but performance might be disappointing.
-**
-** There is no way to enumerate the client data pointers
-** associated with a database connection.  The N parameter can be thought
-** of as a secret key such that only code that knows the secret key is able
-** to access the associated data.
-**
-** Security Warning:  These interfaces should not be exposed in scripting
-** languages or in other circumstances where it might be possible for an
-** attacker to invoke them.  Any agent that can invoke these interfaces
-** can probably also take control of the process.
-**
-** Database connection client data is only available for SQLite
-** version 3.44.0 ([dateof:3.44.0]) and later.
-**
-** See also: [sqlite3_set_auxdata()] and [sqlite3_get_auxdata()].
-*/
-SQLITE_API void *sqlite3_get_clientdata(sqlite3*,const char*);
-SQLITE_API int sqlite3_set_clientdata(sqlite3*, const char*, 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(C,Z,N,D,E) interface sets the return value of an
-** application-defined function to be a text string in an encoding
-** specified the E parameter, which must be one
-** of [SQLITE_UTF8], [SQLITE_UTF8_ZT], [SQLITE_UTF16], [SQLITE_UTF16BE],
-** or [SQLITE_UTF16LE].  ^The special value [SQLITE_UTF8_ZT] means that
-** the result text is both UTF-8 and zero-terminated.  In other words,
-** SQLITE_UTF8_ZT means that the Z array holds at least N+1 bytes and that
-** the Z&#91;N&#93; is zero.
-** ^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 were 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 a 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 *z, sqlite3_uint64 n,
-                           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.
-**
-** Every [application-defined SQL function] that invokes this interface
-** should include the [SQLITE_RESULT_SUBTYPE] property in its
-** text encoding argument when the SQL function is
-** [sqlite3_create_function|registered].  If the [SQLITE_RESULT_SUBTYPE]
-** property is omitted from the function that invokes sqlite3_result_subtype(),
-** then in some cases the sqlite3_result_subtype() might fail to set
-** the result subtype.
-**
-** If SQLite is compiled with -DSQLITE_STRICT_SUBTYPE=1, then any
-** SQL function that invokes the sqlite3_result_subtype() interface
-** and that does not have the SQLITE_RESULT_SUBTYPE property will raise
-** an error.  Future versions of SQLite might enable -DSQLITE_STRICT_SUBTYPE=1
-** by default.
-*/
-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:
-** <ul>
-** <li> [SQLITE_UTF8],
-** <li> [SQLITE_UTF16LE],
-** <li> [SQLITE_UTF16BE],
-** <li> [SQLITE_UTF16], or
-** <li> [SQLITE_UTF16_ALIGNED].
-** </ul>)^
-** ^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:
-**
-** <ol>
-** <li> If A==B then B==A.
-** <li> If A==B and B==C then A==C.
-** <li> If A&lt;B THEN B&gt;A.
-** <li> If A&lt;B and B&lt;C then A&lt;C.
-** </ol>
-**
-** 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 <u>not</u> 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*)
-);
-
-#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.
-**
-** <b>Note to Windows Runtime users:</b>  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:
-**
-** <blockquote><pre>
-** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
-** &nbsp;     TemporaryFolder->Path->Data();
-** char zPathBuf&#91;MAX_PATH + 1&#93;;
-** memset(zPathBuf, 0, sizeof(zPathBuf));
-** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
-** &nbsp;     NULL, NULL);
-** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
-** </pre></blockquote>
-*/
-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 if 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:
-** <ul>
-** <li> [sqlite3_uri_parameter()]
-** <li> [sqlite3_uri_boolean()]
-** <li> [sqlite3_uri_int64()]
-** <li> [sqlite3_filename_database()]
-** <li> [sqlite3_filename_journal()]
-** <li> [sqlite3_filename_wal()]
-** </ul>
-*/
-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):
-** <ol>
-** <li value="0"> SQLITE_TXN_NONE
-** <li value="1"> SQLITE_TXN_READ
-** <li value="2"> SQLITE_TXN_WRITE
-** </ol>
-** ^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.
-**
-** <dl>
-** [[SQLITE_TXN_NONE]] <dt>SQLITE_TXN_NONE</dt>
-** <dd>The SQLITE_TXN_NONE state means that no transaction is currently
-** pending.</dd>
-**
-** [[SQLITE_TXN_READ]] <dt>SQLITE_TXN_READ</dt>
-** <dd>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 be 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].</dd>
-**
-** [[SQLITE_TXN_WRITE]] <dt>SQLITE_TXN_WRITE</dt>
-** <dd>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
-** SQLITE_TXN_NONE at the next [ROLLBACK] or [COMMIT].</dd>
-*/
-#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.
-**
-** <p>^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.
-**
-** <p><b>The callback is not reentrant.</b> 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().
-**
-** <p>^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 canceled.  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.
-**
-** <p>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:
-**
-** <blockquote><pre>
-** &nbsp;   unsigned int demonstration_autovac_pages_callback(
-** &nbsp;     void *pClientData,
-** &nbsp;     const char *zSchema,
-** &nbsp;     unsigned int nDbPage,
-** &nbsp;     unsigned int nFreePage,
-** &nbsp;     unsigned int nBytePerPage
-** &nbsp;   ){
-** &nbsp;     return nFreePage;
-** &nbsp;   }
-** </pre></blockquote>
-*/
-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 update hook is disabled by invoking sqlite3_update_hook()
-** with a NULL pointer as the second parameter.
-** ^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.
-**
-** Whether the update hook is invoked before or after the
-** corresponding change is currently unspecified and may differ
-** depending on the type of change. Do not rely on the order of the
-** hook call with regards to the final result of the operation which
-** triggers the hook.
-**
-** 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
-** used 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:
-**
-** <ul>
-** <li> The limit value is set to zero.
-** <li> 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.
-** <li> An alternative page cache implementation is specified using
-**      [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...).
-** <li> The page cache allocates from its own memory pool supplied
-**      by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than
-**      from the heap.
-** </ul>)^
-**
-** The circumstances under which SQLite will enforce the heap limits may
-** change 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.
-**
-** ^(<blockquote>
-** <table border="1">
-** <tr><th> Parameter <th> Output<br>Type <th>  Description
-**
-** <tr><td> 5th <td> const char* <td> Data type
-** <tr><td> 6th <td> const char* <td> Name of default collation sequence
-** <tr><td> 7th <td> int         <td> True if column has a NOT NULL constraint
-** <tr><td> 8th <td> int         <td> True if column is part of the PRIMARY KEY
-** <tr><td> 9th <td> int         <td> True if column is [AUTOINCREMENT]
-** </table>
-** </blockquote>)^
-**
-** ^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:
-**
-** <pre>
-**     data type: "INTEGER"
-**     collation sequence: "BINARY"
-**     not null: 0
-**     primary key: 1
-**     auto increment: 0
-** </pre>)^
-**
-** ^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 filename 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 tries names of the form "sqlite3_X_init"
-** where X consists of the lower-case equivalent of all ASCII alphabetic
-** characters or all ASCII alphanumeric 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.
-**
-** <b>Security warning:</b> 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.)^
-**
-** <b>Security warning:</b> 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 were as follows:
-**
-** <blockquote><pre>
-** &nbsp;  int xEntryPoint(
-** &nbsp;    sqlite3 *db,
-** &nbsp;    char **pzErrMsg,
-** &nbsp;    const struct sqlite3_api_routines *pThunk
-** &nbsp;  );
-** </pre></blockquote>)^
-**
-** 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*);
-  /* The methods above are in versions 1 through 3 of the sqlite_module object.
-  ** Those below are for version 4 and greater. */
-  int (*xIntegrity)(sqlite3_vtab *pVTab, const char *zSchema,
-                    const char *zTabName, int mFlags, char **pzErr);
-};
-
-/*
-** 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:
-**
-** <blockquote>column OP expr</blockquote>
-**
-** where OP is =, &lt;, &lt;=, &gt;, or &gt;=.)^  ^(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 changed 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. One such flag is
-** [SQLITE_INDEX_SCAN_HEX], which if set causes the [EXPLAIN QUERY PLAN]
-** output to show the idxNum as hex instead of as decimal.  Another flag is
-** SQLITE_INDEX_SCAN_UNIQUE, which if set indicates that the query plan will
-** return 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 0x00000001 /* Scan visits at most 1 row */
-#define SQLITE_INDEX_SCAN_HEX    0x00000002 /* Display idxNum as hex */
-                                            /* in EXPLAIN QUERY PLAN */
-
-/*
-** 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 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:
-**
-** <pre>
-**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
-** </pre>)^
-**
-** ^(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 returns.
-**
-** This function fails with SQLITE_ERROR if any of the following are true:
-** <ul>
-**   <li> ^(Database zDb does not exist)^,
-**   <li> ^(Table zTable does not exist within database zDb)^,
-**   <li> ^(Table zTable is a WITHOUT ROWID table)^,
-**   <li> ^(Column zColumn does not exist)^,
-**   <li> ^(Row iRow is not present in the table)^,
-**   <li> ^(The specified column of row iRow contains a value that is not
-**         a TEXT or BLOB value)^,
-**   <li> ^(Column zColumn is part of an index, PRIMARY KEY or UNIQUE
-**         constraint and the blob is being opened for read/write access)^,
-**   <li> ^([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)^.
-** </ul>
-**
-** ^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 behavior. ^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 overwrite 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:
-**
-** <ul>
-** <li>   SQLITE_MUTEX_PTHREADS
-** <li>   SQLITE_MUTEX_W32
-** <li>   SQLITE_MUTEX_NOOP
-** </ul>
-**
-** 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.
-**
-**
-** ^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 be one of these
-** integer constants:
-**
-** <ul>
-** <li>  SQLITE_MUTEX_FAST
-** <li>  SQLITE_MUTEX_RECURSIVE
-** <li>  SQLITE_MUTEX_STATIC_MAIN
-** <li>  SQLITE_MUTEX_STATIC_MEM
-** <li>  SQLITE_MUTEX_STATIC_OPEN
-** <li>  SQLITE_MUTEX_STATIC_PRNG
-** <li>  SQLITE_MUTEX_STATIC_LRU
-** <li>  SQLITE_MUTEX_STATIC_PMEM
-** <li>  SQLITE_MUTEX_STATIC_APP1
-** <li>  SQLITE_MUTEX_STATIC_APP2
-** <li>  SQLITE_MUTEX_STATIC_APP3
-** <li>  SQLITE_MUTEX_STATIC_VFS1
-** <li>  SQLITE_MUTEX_STATIC_VFS2
-** <li>  SQLITE_MUTEX_STATIC_VFS3
-** </ul>
-**
-** ^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. In most cases the SQLite core only uses
-** sqlite3_mutex_try() as an optimization, so this is acceptable
-** behavior. The exceptions are unix builds that set the
-** SQLITE_ENABLE_SETLK_TIMEOUT build option. In that case a working
-** sqlite3_mutex_try() is required.)^
-**
-** ^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):
-**
-** <ul>
-**   <li>  [sqlite3_mutex_alloc()] </li>
-**   <li>  [sqlite3_mutex_free()] </li>
-**   <li>  [sqlite3_mutex_enter()] </li>
-**   <li>  [sqlite3_mutex_try()] </li>
-**   <li>  [sqlite3_mutex_leave()] </li>
-**   <li>  [sqlite3_mutex_held()] </li>
-**   <li>  [sqlite3_mutex_notheld()] </li>
-** </ul>)^
-**
-** 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 to 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_FK_NO_ACTION             7
-#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_JSON_SELFCHECK          14
-#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
-#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
-#define SQLITE_TESTCTRL_GETOPT                  16
-#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_USELONGDOUBLE           34  /* NOT USED */
-#define SQLITE_TESTCTRL_ATOF                    34
-#define SQLITE_TESTCTRL_LAST                    34  /* Largest TESTCTRL */
-
-/*
-** CAPI3REF: SQL Keyword Checking
-**
-** These routines provide access to the set of SQL language keywords
-** recognized by SQLite.  Applications can use 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 0-based 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:
-** <ul>
-** <li> Put all identifier names inside double-quotes.  This is the official
-**      SQL way to escape identifier names.
-** <li> Put identifier names inside &#91;...&#93;.  This is not standard SQL,
-**      but it is what SQL Server does and so lots of programmers use this
-**      technique.
-** <li> Begin every identifier with the letter "Z" as no SQL keywords start
-**      with "Z".
-** <li> Include a digit somewhere in every identifier name.
-** </ul>
-**
-** 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:
-** <ol>
-** <li> ^The sqlite3_str object is created using [sqlite3_str_new()].
-** <li> ^Text is appended to the sqlite3_str object using various
-** methods, such as [sqlite3_str_appendf()].
-** <li> ^The sqlite3_str object is destroyed and the string it created
-** is returned using the [sqlite3_str_finish()] interface.
-** </ol>
-*/
-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 might also return a NULL pointer if the
-** string in [sqlite3_str] object X is zero bytes long.
-**
-** ^The [sqlite3_str_free(X)] interface destroys both the sqlite3_str object
-** X and the string content it contains.  Calling sqlite3_str_free(X) is
-** the equivalent of calling [sqlite3_free](sqlite3_str_finish(X)).
-*/
-SQLITE_API char *sqlite3_str_finish(sqlite3_str*);
-SQLITE_API void sqlite3_str_free(sqlite3_str*);
-
-/*
-** CAPI3REF: Add Content To A Dynamic String
-** METHOD: sqlite3_str
-**
-** These interfaces add or remove 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.
-**
-** ^The [sqlite3_str_truncate(X,N)] method changes the length of the string
-** under construction to be N bytes or less.  This routine is a no-op if
-** N is negative or if the string is already N bytes or smaller in size.
-**
-** 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*);
-SQLITE_API void sqlite3_str_truncate(sqlite3_str*,int N);
-
-/*
-** 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 use the pointer returned by
-** [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()].
-**
-** <dl>
-** [[SQLITE_STATUS_MEMORY_USED]] ^(<dt>SQLITE_STATUS_MEMORY_USED</dt>
-** <dd>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].</dd>)^
-**
-** [[SQLITE_STATUS_MALLOC_SIZE]] ^(<dt>SQLITE_STATUS_MALLOC_SIZE</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_STATUS_MALLOC_COUNT]] ^(<dt>SQLITE_STATUS_MALLOC_COUNT</dt>
-** <dd>This parameter records the number of separate memory allocations
-** currently checked out.</dd>)^
-**
-** [[SQLITE_STATUS_PAGECACHE_USED]] ^(<dt>SQLITE_STATUS_PAGECACHE_USED</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]]
-** ^(<dt>SQLITE_STATUS_PAGECACHE_OVERFLOW</dt>
-** <dd>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
-** were 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.</dd>)^
-**
-** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(<dt>SQLITE_STATUS_PAGECACHE_SIZE</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_STATUS_SCRATCH_USED]] <dt>SQLITE_STATUS_SCRATCH_USED</dt>
-** <dd>No longer used.</dd>
-**
-** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(<dt>SQLITE_STATUS_SCRATCH_OVERFLOW</dt>
-** <dd>No longer used.</dd>
-**
-** [[SQLITE_STATUS_SCRATCH_SIZE]] <dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
-** <dd>No longer used.</dd>
-**
-** [[SQLITE_STATUS_PARSER_STACK]] ^(<dt>SQLITE_STATUS_PARSER_STACK</dt>
-** <dd>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].</dd>)^
-** </dl>
-**
-** 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.
-**
-** ^The sqlite3_db_status64(D,O,C,H,R) routine works exactly the same
-** way as sqlite3_db_status(D,O,C,H,R) routine except that the C and H
-** parameters are pointer to 64-bit integers (type: sqlite3_int64) instead
-** of pointers to 32-bit integers, which allows larger status values
-** to be returned.  If a status value exceeds 2,147,483,647 then
-** sqlite3_db_status() will truncate the value whereas sqlite3_db_status64()
-** will return the full value.
-**
-** See also: [sqlite3_status()] and [sqlite3_stmt_status()].
-*/
-SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
-SQLITE_API int sqlite3_db_status64(sqlite3*,int,sqlite3_int64*,sqlite3_int64*,int);
-
-/*
-** 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.
-**
-** <dl>
-** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt>
-** <dd>This parameter returns the number of lookaside memory slots currently
-** checked out.</dd>)^
-**
-** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_HIT</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]]
-** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>
-** <dd>This parameter returns the number of 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.</dd>)^
-**
-** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]]
-** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL</dt>
-** <dd>This parameter returns the number of 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.</dd>)^
-**
-** [[SQLITE_DBSTATUS_CACHE_USED]] ^(<dt>SQLITE_DBSTATUS_CACHE_USED</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_USED_SHARED]]
-** ^(<dt>SQLITE_DBSTATUS_CACHE_USED_SHARED</dt>
-** <dd>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 of 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.</dd>
-**
-** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(<dt>SQLITE_DBSTATUS_SCHEMA_USED</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_STMT_USED]] ^(<dt>SQLITE_DBSTATUS_STMT_USED</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(<dt>SQLITE_DBSTATUS_CACHE_HIT</dt>
-** <dd>This parameter returns the number of pager cache hits that have
-** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT
-** is always 0.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(<dt>SQLITE_DBSTATUS_CACHE_MISS</dt>
-** <dd>This parameter returns the number of pager cache misses that have
-** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS
-** is always 0.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(<dt>SQLITE_DBSTATUS_CACHE_WRITE</dt>
-** <dd>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.
-** <p>
-** ^(There is overlap between the quantities measured by this parameter
-** (SQLITE_DBSTATUS_CACHE_WRITE) and SQLITE_DBSTATUS_TEMPBUF_SPILL.
-** Resetting one will reduce the other.)^
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_SPILL]] ^(<dt>SQLITE_DBSTATUS_CACHE_SPILL</dt>
-** <dd>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 to help identify
-** inefficiencies that can be resolved by increasing the cache size.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(<dt>SQLITE_DBSTATUS_DEFERRED_FKS</dt>
-** <dd>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.
-**
-** [[SQLITE_DBSTATUS_TEMPBUF_SPILL] ^(<dt>SQLITE_DBSTATUS_TEMPBUF_SPILL</dt>
-** <dd>^(This parameter returns the number of bytes written to temporary
-** files on disk that could have been kept in memory had sufficient memory
-** been available.  This value includes writes to intermediate tables that
-** are part of complex queries, external sorts that spill to disk, and
-** writes to TEMP tables.)^
-** ^The highwater mark is always 0.
-** <p>
-** ^(There is overlap between the quantities measured by this parameter
-** (SQLITE_DBSTATUS_TEMPBUF_SPILL) and SQLITE_DBSTATUS_CACHE_WRITE.
-** Resetting one will reduce the other.)^
-** </dd>
-** </dl>
-*/
-#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_TEMPBUF_SPILL       13
-#define SQLITE_DBSTATUS_MAX                 13   /* 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:
-**
-** <dl>
-** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]] <dt>SQLITE_STMTSTATUS_FULLSCAN_STEP</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_SORT]] <dt>SQLITE_STMTSTATUS_SORT</dt>
-** <dd>^This is the number of sort operations that have occurred.
-** A non-zero value in this counter may indicate an opportunity to
-** improve performance through careful use of indices.</dd>
-**
-** [[SQLITE_STMTSTATUS_AUTOINDEX]] <dt>SQLITE_STMTSTATUS_AUTOINDEX</dt>
-** <dd>^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
-** improve performance by adding permanent indices that do not
-** need to be reinitialized each time the statement is run.</dd>
-**
-** [[SQLITE_STMTSTATUS_VM_STEP]] <dt>SQLITE_STMTSTATUS_VM_STEP</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_REPREPARE]] <dt>SQLITE_STMTSTATUS_REPREPARE</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_RUN]] <dt>SQLITE_STMTSTATUS_RUN</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_FILTER_MISS]]
-** [[SQLITE_STMTSTATUS_FILTER HIT]]
-** <dt>SQLITE_STMTSTATUS_FILTER_HIT<br>
-** SQLITE_STMTSTATUS_FILTER_MISS</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_MEMUSED]] <dt>SQLITE_STMTSTATUS_MEMUSED</dt>
-** <dd>^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.
-** </dd>
-** </dl>
-*/
-#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 be 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 be
-** 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 upon 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 set to 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) for 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 determine what action to take:
-**
-** <table border=1 width=85% align=center>
-** <tr><th> createFlag <th> Behavior when page is not already in cache
-** <tr><td> 0 <td> Do not allocate a new page.  Return NULL.
-** <tr><td> 1 <td> Allocate a new page if it is easy and convenient to do so.
-**                 Otherwise return NULL.
-** <tr><td> 2 <td> Make every effort to allocate a new page.  Only return
-**                 NULL if allocating a new page is effectively impossible.
-** </table>
-**
-** ^(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 the
-** 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 become 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:
-**   <ol>
-**     <li><b>sqlite3_backup_init()</b> is called once to initialize the
-**         backup,
-**     <li><b>sqlite3_backup_step()</b> is called one or more times to transfer
-**         the data between the two databases, and finally
-**     <li><b>sqlite3_backup_finish()</b> is called to release all resources
-**         associated with the backup operation.
-**   </ol>)^
-** There should be exactly one call to sqlite3_backup_finish() for each
-** successful call to sqlite3_backup_init().
-**
-** [[sqlite3_backup_init()]] <b>sqlite3_backup_init()</b>
-**
-** ^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()]] <b>sqlite3_backup_step()</b>
-**
-** ^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
-** <ol>
-** <li> the destination database was opened read-only, or
-** <li> the destination database is using write-ahead-log journaling
-** and the destination and source page sizes differ, or
-** <li> the destination database is an in-memory database and the
-** destination and source page sizes differ.
-** </ol>)^
-**
-** ^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 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()]] <b>sqlite3_backup_finish()</b>
-**
-** 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 of 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()]]
-** <b>sqlite3_backup_remaining() and sqlite3_backup_pagecount()</b>
-**
-** ^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().)^
-**
-** <b>Concurrent Usage of Database Handles</b>
-**
-** ^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.
-**
-** <b>Alternatives To Using The Backup API</b>
-**
-** Other techniques for safely creating a consistent backup of an SQLite
-** database include:
-**
-** <ul>
-** <li> The [VACUUM INTO] command.
-** <li> The [sqlite3_rsync] utility program.
-** </ul>
-*/
-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 connection's 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 connection's
-** 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.
-**
-** <b>Callback Invocation Details</b>
-**
-** 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.
-**
-** <b>Deadlock Detection</b>
-**
-** 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.
-**
-** <b>The "DROP TABLE" Exception</b>
-**
-** 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 the default behavior or previously registered write-ahead
-** log callback.
-**
-** ^The return value is a copy of the third parameter from the
-** previous call, if any, or 0.
-**
-** ^The [sqlite3_wal_autocheckpoint()] interface and the
-** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and
-** will overwrite any prior [sqlite3_wal_hook()] settings.
-**
-** ^If a write-ahead log callback is set using this function then
-** [sqlite3_wal_checkpoint_v2()] or [PRAGMA wal_checkpoint]
-** should be invoked periodically to keep the write-ahead log file
-** from growing without bound.
-**
-** ^Passing a NULL pointer for the callback disables automatic
-** checkpointing entirely. To re-enable the default behavior, call
-** sqlite3_wal_autocheckpoint(db,1000) or use [PRAGMA wal_checkpoint].
-*/
-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 N 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]:)^
-**
-** <dl>
-** <dt>SQLITE_CHECKPOINT_PASSIVE<dd>
-**   ^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.
-**
-** <dt>SQLITE_CHECKPOINT_FULL<dd>
-**   ^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.
-**
-** <dt>SQLITE_CHECKPOINT_RESTART<dd>
-**   ^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.
-**
-** <dt>SQLITE_CHECKPOINT_TRUNCATE<dd>
-**   ^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.
-**
-** <dt>SQLITE_CHECKPOINT_NOOP<dd>
-**   ^This mode always checkpoints zero frames. The only reason to invoke
-**   a NOOP checkpoint is to access the values returned by
-**   sqlite3_wal_checkpoint_v2() via output parameters *pnLog and *pnCkpt.
-** </dl>
-**
-** ^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_NOOP    -1  /* Do no work at all */
-#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.
-**
-** <dl>
-** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]]
-** <dt>SQLITE_VTAB_CONSTRAINT_SUPPORT</dt>
-** <dd>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 user's 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.
-** </dd>
-**
-** [[SQLITE_VTAB_DIRECTONLY]]<dt>SQLITE_VTAB_DIRECTONLY</dt>
-** <dd>Calls of the form
-** [sqlite3_vtab_config](db,SQLITE_VTAB_DIRECTONLY) from within the
-** the [xConnect] or [xCreate] methods of a [virtual table] implementation
-** prohibits that virtual table from being used from within triggers and
-** views.
-** </dd>
-**
-** [[SQLITE_VTAB_INNOCUOUS]]<dt>SQLITE_VTAB_INNOCUOUS</dt>
-** <dd>Calls of the form
-** [sqlite3_vtab_config](db,SQLITE_VTAB_INNOCUOUS) from within 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.
-** </dd>
-**
-** [[SQLITE_VTAB_USES_ALL_SCHEMAS]]<dt>SQLITE_VTAB_USES_ALL_SCHEMAS</dt>
-** <dd>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.
-** </dd>
-** </dl>
-*/
-#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:
-**
-** <ol>
-** <li><p> 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.
-** <li><p> 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.
-** <li><p> Otherwise, "BINARY" is returned.
-** </ol>
-*/
-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.
-**
-** <ol><li value="0"><p>
-** ^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().
-** <li value="1"><p>
-** ^(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.
-** <li value="2"><p>
-** ^(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 columns identified
-** by "aOrderBy" are adjacent.)^  ^(Furthermore, when two or more rows
-** contain the same values for all columns identified by "colUsed", all but
-** one such row may optionally be omitted from the result.)^
-** The virtual table is not required to omit rows that are duplicates
-** over the "colUsed" columns, but if the virtual table can do that without
-** too much extra effort, it could potentially help the query to run faster.
-** This mode is used for a DISTINCT query.
-** <li value="3"><p>
-** ^(If the sqlite3_vtab_distinct() interface returns 3, that means the
-** virtual table must return rows in the order defined by "aOrderBy" as
-** if the sqlite3_vtab_distinct() interface had returned 0.  However if
-** two or more rows in the result have the same values for all columns
-** identified by "colUsed", then all but one such row may optionally be
-** omitted.)^  Like when the return value is 2, the virtual table
-** is not required to omit rows that are duplicates over the "colUsed"
-** columns, but if the virtual table can do that without
-** too much extra effort, it could potentially help the query to run faster.
-** This mode is used for queries
-** that have both DISTINCT and ORDER BY clauses.
-** </ol>
-**
-** <p>The following table summarizes the conditions under which the
-** virtual table is allowed to set the "orderByConsumed" flag based on
-** the value returned by sqlite3_vtab_distinct().  This table is a
-** restatement of the previous four paragraphs:
-**
-** <table border=1 cellspacing=0 cellpadding=10 width="90%">
-** <tr>
-** <td valign="top">sqlite3_vtab_distinct() return value
-** <td valign="top">Rows are returned in aOrderBy order
-** <td valign="top">Rows with the same value in all aOrderBy columns are
-**                  adjacent
-** <td valign="top">Duplicates over all colUsed columns may be omitted
-** <tr><td>0<td>yes<td>yes<td>no
-** <tr><td>1<td>no<td>yes<td>no
-** <tr><td>2<td>no<td>yes<td>yes
-** <tr><td>3<td>yes<td>yes<td>yes
-** </table>
-**
-** ^For the purposes of comparing virtual table output values to see if the
-** values are the 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
-** "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 positive 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:
-**
-** <ol>
-** <li><p>
-**   ^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.
-**
-** <li><p>
-**   ^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.
-** </ol>
-**
-** ^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:
-**
-** <ol>
-** <li><p> 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.
-**
-** <li><p> The last call to sqlite3_vtab_in(P,N,F) for which F was
-** non-negative had F>=1.
-** </ol>)^
-**
-** ^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 using 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:
-**
-** <blockquote><pre>
-** &nbsp;  for(rc=sqlite3_vtab_in_first(pList, &pVal);
-** &nbsp;      rc==SQLITE_OK && pVal;
-** &nbsp;      rc=sqlite3_vtab_in_next(pList, &pVal)
-** &nbsp;  ){
-** &nbsp;    // do something with pVal
-** &nbsp;  }
-** &nbsp;  if( rc!=SQLITE_DONE ){
-** &nbsp;    // an error has occurred
-** &nbsp;  }
-** </pre></blockquote>)^
-**
-** ^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 a 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 of the [ON CONFLICT] mode
-** 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).
-**
-** <dl>
-** [[SQLITE_SCANSTAT_NLOOP]] <dt>SQLITE_SCANSTAT_NLOOP</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_NVISIT]] <dt>SQLITE_SCANSTAT_NVISIT</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_EST]] <dt>SQLITE_SCANSTAT_EST</dt>
-** <dd>^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 estimate 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.</dd>
-**
-** [[SQLITE_SCANSTAT_NAME]] <dt>SQLITE_SCANSTAT_NAME</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_EXPLAIN]] <dt>SQLITE_SCANSTAT_EXPLAIN</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECTID</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_PARENTID]] <dt>SQLITE_SCANSTAT_PARENTID</dt>
-** <dd>The "int" variable pointed to by the V parameter will be set to 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.</dd>
-**
-** [[SQLITE_SCANSTAT_NCYCLE]] <dt>SQLITE_SCANSTAT_NCYCLE</dt>
-** <dd>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.</dd>
-** </dl>
-*/
-#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
-** retrieve statistics for 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()] and the
-** [nexec and ncycle] columns of the [bytecode virtual table].
-*/
-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 is 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, because
-** the new values are not yet available. In this case, when a
-** callback made with op==SQLITE_DELETE is actually 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.
-**
-** If a read-transaction is opened by this function, then it is guaranteed
-** that the returned snapshot object may not be invalidated by a database
-** writer or checkpointer until after the read-transaction is closed. This
-** is not guaranteed if a read-transaction is already open when this
-** function is called. In that case, any subsequent write or checkpoint
-** operation on the database may invalidate the returned snapshot handle,
-** even while the read-transaction remains open.
-**
-** 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.
-**
-** <ul>
-**   <li> The database handle must not be in [autocommit mode].
-**
-**   <li> Schema S of [database connection] D must be a [WAL mode] database.
-**
-**   <li> There must not be a write transaction open on schema S of database
-**        connection D.
-**
-**   <li> 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.
-** </ul>
-**
-** 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 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 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 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 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 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 S is a NULL pointer, the main database is used.
-** 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 were 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 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.
-**
-** After the call, if the SQLITE_SERIALIZE_NOCOPY bit had been set,
-** the returned buffer content will remain accessible and unchanged
-** until either the next write operation on the connection or when
-** the connection is closed, and applications must not modify the
-** buffer. If the bit had been clear, the returned buffer will not
-** be accessed by SQLite after the call.
-**
-** 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.  If S is a NULL pointer, the main database is
-** used. 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.
-**
-** Applications must not modify the buffer P or invalidate it before
-** the database connection D is closed.
-**
-** 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 deserialize 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.
-**
-** The deserialized database should not be in [WAL mode].  If the database
-** is in WAL mode, then any attempt to use the database file will result
-** in an [SQLITE_CANTOPEN] error.  The application can set the
-** [file format version numbers] (bytes 18 and 19) of the input database P
-** to 0x01 prior to invoking sqlite3_deserialize(D,S,P,N,M,F) to force the
-** database file into rollback mode and work around this limitation.
-**
-** 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 of 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 the 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 */
-
-/*
-** CAPI3REF: Bind array values to the CARRAY table-valued function
-**
-** The sqlite3_carray_bind_v2(S,I,P,N,F,X,D) interface binds an array value to
-** parameter that is the first argument of the [carray() table-valued function].
-** The S parameter is a pointer to the [prepared statement] that uses the
-** carray() functions.  I is the parameter index to be bound.  I must be the
-** index of the parameter that is the first argument to the carray()
-** table-valued function. P is a pointer to the array to be bound, and N
-** is the number of elements in the array.  The F argument is one of
-** constants [SQLITE_CARRAY_INT32], [SQLITE_CARRAY_INT64],
-** [SQLITE_CARRAY_DOUBLE], [SQLITE_CARRAY_TEXT],
-** or [SQLITE_CARRAY_BLOB] to indicate the datatype of the array P.
-**
-** If the X argument is not a NULL pointer or one of the special
-** values [SQLITE_STATIC] or [SQLITE_TRANSIENT], then SQLite will invoke
-** the function X with argument D when it is finished using the data in P.
-** The call to X(D) is a destructor for the array P. The destructor X(D)
-** is invoked even if the call to sqlite3_carray_bind_v2() fails. If the X
-** parameter is the special-case value [SQLITE_STATIC], then SQLite assumes
-** that the data static and the destructor is never invoked.  If the X
-** parameter is the special-case value [SQLITE_TRANSIENT], then
-** sqlite3_carray_bind_v2() makes its own private copy of the data prior
-** to returning and never invokes the destructor X.
-**
-** The sqlite3_carray_bind() function works the same as sqlite3_carray_bind_v2()
-** with a D parameter set to P.  In other words,
-** sqlite3_carray_bind(S,I,P,N,F,X) is same as
-** sqlite3_carray_bind_v2(S,I,P,N,F,X,P).
-*/
-SQLITE_API int sqlite3_carray_bind_v2(
-  sqlite3_stmt *pStmt,        /* Statement to be bound */
-  int i,                      /* Parameter index */
-  void *aData,                /* Pointer to array data */
-  int nData,                  /* Number of data elements */
-  int mFlags,                 /* CARRAY flags */
-  void (*xDel)(void*),        /* Destructor for aData */
-  void *pDel                  /* Optional argument to xDel() */
-);
-SQLITE_API int sqlite3_carray_bind(
-  sqlite3_stmt *pStmt,        /* Statement to be bound */
-  int i,                      /* Parameter index */
-  void *aData,                /* Pointer to array data */
-  int nData,                  /* Number of data elements */
-  int mFlags,                 /* CARRAY flags */
-  void (*xDel)(void*)         /* Destructor for aData */
-);
-
-/*
-** CAPI3REF: Datatypes for the CARRAY table-valued function
-**
-** The fifth argument to the [sqlite3_carray_bind()] interface musts be
-** one of the following constants, to specify the datatype of the array
-** that is being bound into the [carray table-valued function].
-*/
-#define SQLITE_CARRAY_INT32     0    /* Data is 32-bit signed integers */
-#define SQLITE_CARRAY_INT64     1    /* Data is 64-bit signed integers */
-#define SQLITE_CARRAY_DOUBLE    2    /* Data is doubles */
-#define SQLITE_CARRAY_TEXT      3    /* Data is char* */
-#define SQLITE_CARRAY_BLOB      4    /* Data is struct iovec */
-
-/*
-** Versions of the above #defines that omit the initial SQLITE_, for
-** legacy compatibility.
-*/
-#define CARRAY_INT32     0    /* Data is 32-bit signed integers */
-#define CARRAY_INT64     1    /* Data is 64-bit signed integers */
-#define CARRAY_DOUBLE    2    /* Data is doubles */
-#define CARRAY_TEXT      3    /* Data is char* */
-#define CARRAY_BLOB      4    /* Data is struct iovec */
-
-/*
-** 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
-# 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 for SQLITE3_H will be added by mksqlite3.tcl */
-
-/******** 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 <rtree> WHERE <rtree col> 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 <rtree> WHERE <rtree col> 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().
-**
-** <dt>SQLITE_SESSION_OBJCONFIG_SIZE <dd>
-**   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.
-**
-** <dt>SQLITE_SESSION_OBJCONFIG_ROWID <dd>
-**   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:
-**
-** <ul>
-**   <li> The session object "indirect" flag is set when the change is
-**        made, or
-**   <li> The change is made by an SQL trigger or foreign key action
-**        instead of directly as a result of a users SQL statement.
-** </ul>
-**
-** 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.
-**
-** <h3>Special sqlite_stat1 Handling</h3>
-**
-** 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:
-**  <pre>
-**  &nbsp;     CREATE TABLE sqlite_stat1(tbl,idx,stat)
-**  </pre>
-**
-** 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()].
-**
-** <h3>Changeset Generation</h3>
-**
-** 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:
-**
-** <ul>
-**   <li> 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.
-**
-**   <li> 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.
-** </ul>
-**
-** 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 enabled, and
-** then another field of the same row is updated while the session is disabled,
-** 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:
-**
-** <ul>
-**   <li> Has the same name,
-**   <li> Has the same set of columns declared in the same order, and
-**   <li> Has the same PRIMARY KEY definition.
-** </ul>
-**
-** 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:
-**
-** <ul>
-**   <li> 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.
-**
-**   <li> 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.
-**
-**   <li> 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.
-** </ul>
-**
-** 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.
-**
-** Unless the call to this function is a no-op as described above, it is 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:
-**
-** <ul>
-**   <li> DELETE records consist of the primary key fields only. The
-**        original values of other fields are omitted.
-**   <li> The original values of any modified fields are omitted from
-**        UPDATE records.
-** </ul>
-**
-** 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:
-**
-** <ul>
-**   <li> [sqlite3changeset_next()]
-**   <li> [sqlite3changeset_op()]
-**   <li> [sqlite3changeset_new()]
-**   <li> [sqlite3changeset_old()]
-** </ul>
-**
-** 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 <b>experimental</b>
-** 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]:
-**
-** <dt>SQLITE_CHANGESETSTART_INVERT <dd>
-**   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:
-**
-** <ul>
-**   <li> The number of columns in the table, and
-**   <li> Which of those columns make up the tables PRIMARY KEY.
-** </ul>
-**
-** 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):
-**
-** <pre>
-**   sqlite3changeset_start();
-**   while( SQLITE_ROW==sqlite3changeset_next() ){
-**     // Do something with change.
-**   }
-**   rc = sqlite3changeset_finalize();
-**   if( rc!=SQLITE_OK ){
-**     // An error has occurred
-**   }
-** </pre>
-*/
-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:
-**
-** <ul>
-**   <li> Each DELETE change is changed to an INSERT, and
-**   <li> Each INSERT change is changed to a DELETE, and
-**   <li> For each UPDATE change, the old.* and new.* values are exchanged.
-** </ul>
-**
-** 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:
-**
-** <pre>
-**   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;
-**   }
-** </pre>
-**
-** 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:
-**
-** <ul>
-**   <li> It is created using a call to sqlite3changegroup_new().
-**
-**   <li> Zero or more changesets (or patchsets) are added to the object
-**        by calling sqlite3changegroup_add().
-**
-**   <li> The result of combining all input changesets together is obtained
-**        by the application via a call to sqlite3changegroup_output().
-**
-**   <li> The object is deleted using a call to sqlite3changegroup_delete().
-** </ul>
-**
-** 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 Schema to a Changegroup
-** METHOD: sqlite3_changegroup_schema
-**
-** This method may be used to optionally enforce the rule that the changesets
-** added to the changegroup handle must match the schema of database zDb
-** ("main", "temp", or the name of an attached database). If
-** sqlite3changegroup_add() is called to add a changeset that is not compatible
-** with the configured schema, SQLITE_SCHEMA is returned and the changegroup
-** object is left in an undefined state.
-**
-** A changeset schema is considered compatible with the database schema in
-** the same way as for sqlite3changeset_apply(). Specifically, for each
-** table in the changeset, there exists a database table with:
-**
-** <ul>
-**   <li> The name identified by the changeset, and
-**   <li> at least as many columns as recorded in the changeset, and
-**   <li> the primary key columns in the same position as recorded in
-**        the changeset.
-** </ul>
-**
-** The output of the changegroup object always has the same schema as the
-** database nominated using this function. In cases where changesets passed
-** to sqlite3changegroup_add() have fewer columns than the corresponding table
-** in the database schema, these are filled in using the default column
-** values from the database schema. This makes it possible to combined
-** changesets that have different numbers of columns for a single table
-** within a changegroup, provided that they are otherwise compatible.
-*/
-SQLITE_API int sqlite3changegroup_schema(sqlite3_changegroup*, sqlite3*, const char *zDb);
-
-/*
-** 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:
-**
-** <table border=1 style="margin-left:8ex;margin-right:8ex">
-**   <tr><th style="white-space:pre">Existing Change  </th>
-**       <th style="white-space:pre">New Change       </th>
-**       <th>Output Change
-**   <tr><td>INSERT <td>INSERT <td>
-**       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.
-**   <tr><td>INSERT <td>UPDATE <td>
-**       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.
-**   <tr><td>INSERT <td>DELETE <td>
-**       The existing INSERT is removed from the changegroup. The DELETE is
-**       not added.
-**   <tr><td>UPDATE <td>INSERT <td>
-**       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.
-**   <tr><td>UPDATE <td>UPDATE <td>
-**       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.
-**   <tr><td>UPDATE <td>DELETE <td>
-**       The existing UPDATE is replaced by the new DELETE within the
-**       changegroup.
-**   <tr><td>DELETE <td>INSERT <td>
-**       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.
-**   <tr><td>DELETE <td>UPDATE <td>
-**       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.
-**   <tr><td>DELETE <td>DELETE <td>
-**       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.
-** </table>
-**
-** 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. Except, if the changegroup
-** object has been configured with a database schema using the
-** sqlite3changegroup_schema() API, then it is possible to combine changesets
-** with different numbers of columns for a single table, provided that
-** they are otherwise compatible.
-**
-** 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: Add A Single Change To A Changegroup
-** METHOD: sqlite3_changegroup
-**
-** This function adds the single change currently indicated by the iterator
-** passed as the second argument to the changegroup object. The rules for
-** adding the change are just as described for [sqlite3changegroup_add()].
-**
-** If the change is successfully added to the changegroup, SQLITE_OK is
-** returned. Otherwise, an SQLite error code is returned.
-**
-** The iterator must point to a valid entry when this function is called.
-** If it does not, SQLITE_ERROR is returned and no change is added to the
-** changegroup. Additionally, the iterator must not have been opened with
-** the SQLITE_CHANGESETAPPLY_INVERT flag. In this case SQLITE_ERROR is also
-** returned.
-*/
-SQLITE_API int sqlite3changegroup_add_change(
-  sqlite3_changegroup*,
-  sqlite3_changeset_iter*
-);
-
-
-
-/*
-** 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.
-**
-** 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. Additionally, starting with version 3.51.0,
-** an error code and error message that may be accessed using the
-** [sqlite3_errcode()] and [sqlite3_errmsg()] APIs are left in the database
-** handle.
-**
-** The fourth argument (xFilter) passed to these functions is the "filter
-** callback". This may be passed NULL, in which case all changes in the
-** changeset are applied to the database. For sqlite3changeset_apply() and
-** sqlite3_changeset_apply_v2(), if it is not NULL, then it is invoked once
-** for each table affected by at least one change in the changeset. In this
-** case the table name is passed as the second argument, and a copy of
-** the context pointer passed as the sixth argument to apply() or apply_v2()
-** 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, all changes related to the table are attempted.
-**
-** For sqlite3_changeset_apply_v3(), the xFilter callback is invoked once
-** per change. The second argument in this case is an sqlite3_changeset_iter
-** that may be queried using the usual APIs for the details of the current
-** change. If the "filter callback" returns zero in this case, then no attempt
-** is made to apply the current change. If it returns non-zero, the change
-** is applied.
-**
-** 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:
-**
-** <ul>
-**   <li> The table has the same name as the name recorded in the
-**        changeset, and
-**   <li> The table has at least as many columns as recorded in the
-**        changeset, and
-**   <li> The table has primary key columns in the same position as
-**        recorded in the changeset.
-** </ul>
-**
-** 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 each UPDATE, INSERT or DELETE
-** change that is not excluded by a filter callback. 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.
-**
-** <dl>
-** <dt>DELETE Changes<dd>
-**   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].
-**
-** <dt>INSERT Changes<dd>
-**   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].
-**
-** <dt>UPDATE Changes<dd>
-**   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].
-** </dl>
-**
-** 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.
-**
-** 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 <b>experimental</b>
-** 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 */
-);
-SQLITE_API int sqlite3changeset_apply_v3(
-  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() */
-    sqlite3_changeset_iter *p     /* Handle describing change */
-  ),
-  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]:
-**
-** <dl>
-** <dt>SQLITE_CHANGESETAPPLY_NOSAVEPOINT <dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESETAPPLY_IGNORENOOP <dd>
-**   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:
-**    <ul>
-**    <li>a delete change if the row being deleted cannot be found,
-**    <li>an update change if the modified fields are already set to
-**        their new values in the conflicting row, or
-**    <li>an insert change if all fields of the conflicting row match
-**        the row being inserted.
-**    </ul>
-**
-** <dt>SQLITE_CHANGESETAPPLY_FKNOACTION <dd>
-**   If this flag it set, then all foreign key constraints in the target
-**   database behave as if they were declared with "ON UPDATE NO ACTION ON
-**   DELETE NO ACTION", even if they are actually CASCADE, RESTRICT, SET NULL
-**   or SET DEFAULT.
-*/
-#define SQLITE_CHANGESETAPPLY_NOSAVEPOINT   0x0001
-#define SQLITE_CHANGESETAPPLY_INVERT        0x0002
-#define SQLITE_CHANGESETAPPLY_IGNORENOOP    0x0004
-#define SQLITE_CHANGESETAPPLY_FKNOACTION    0x0008
-
-/*
-** CAPI3REF: Constants Passed To The Conflict Handler
-**
-** Values that may be passed as the second argument to a conflict-handler.
-**
-** <dl>
-** <dt>SQLITE_CHANGESET_DATA<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_NOTFOUND<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_CONFLICT<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_FOREIGN_KEY<dd>
-**   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().
-**
-** <dt>SQLITE_CHANGESET_CONSTRAINT<dd>
-**   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.
-**
-** </dl>
-*/
-#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.
-**
-** <dl>
-** <dt>SQLITE_CHANGESET_OMIT<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_REPLACE<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_ABORT<dd>
-**   If this value is returned, any changes applied so far are rolled back
-**   and the call to sqlite3changeset_apply() returns SQLITE_ABORT.
-** </dl>
-*/
-#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:
-**
-** <dl>
-** <dt>Local INSERT<dd>
-**   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.
-**
-** <dt>Local DELETE<dd>
-**   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.
-**
-** <dt>Local UPDATE<dd>
-**   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.
-** </dl>
-**
-** 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:
-**
-** <ul>
-**    <li> If there has been one or more REPLACE resolutions on a
-**         key, it is rebased according to a REPLACE.
-**
-**    <li> 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.
-** </ul>
-**
-** 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:
-**
-** <ol>
-**   <li> An sqlite3_rebaser object is created by calling
-**        sqlite3rebaser_create().
-**   <li> 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.
-**   <li> Each local changeset is rebased by calling sqlite3rebaser_rebase().
-**   <li> The sqlite3_rebaser object is deleted by calling
-**        sqlite3rebaser_delete().
-** </ol>
-*/
-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:
-**
-** <table border=1 style="margin-left:8ex;margin-right:8ex">
-**   <tr><th>Streaming function<th>Non-streaming equivalent</th>
-**   <tr><td>sqlite3changeset_apply_strm<td>[sqlite3changeset_apply]
-**   <tr><td>sqlite3changeset_apply_strm_v2<td>[sqlite3changeset_apply_v2]
-**   <tr><td>sqlite3changeset_concat_strm<td>[sqlite3changeset_concat]
-**   <tr><td>sqlite3changeset_invert_strm<td>[sqlite3changeset_invert]
-**   <tr><td>sqlite3changeset_start_strm<td>[sqlite3changeset_start]
-**   <tr><td>sqlite3session_changeset_strm<td>[sqlite3session_changeset]
-**   <tr><td>sqlite3session_patchset_strm<td>[sqlite3session_patchset]
-** </table>
-**
-** 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
-**
-**  <pre>
-**  &nbsp;     int nChangeset,
-**  &nbsp;     void *pChangeset,
-**  </pre>
-**
-** Is replaced by:
-**
-**  <pre>
-**  &nbsp;     int (*xInput)(void *pIn, void *pData, int *pnData),
-**  &nbsp;     void *pIn,
-**  </pre>
-**
-** 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:
-**
-**  <pre>
-**  &nbsp;     int *pnChangeset,
-**  &nbsp;     void **ppChangeset,
-**  </pre>
-**
-** Is replaced by:
-**
-**  <pre>
-**  &nbsp;     int (*xOutput)(void *pOut, const void *pData, int nData),
-**  &nbsp;     void *pOut
-**  </pre>
-**
-** 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_apply_v3_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() */
-    sqlite3_changeset_iter *p
-  ),
-  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.
-**
-** <dl>
-** <dt>SQLITE_SESSION_CONFIG_STRMSIZE<dd>
-**    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.
-** </dl>
-**
-** 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
-
-/*
-** CAPI3REF: Configure a changegroup object
-**
-** Configure the changegroup object passed as the first argument.
-** At present the only valid value for the second parameter is
-** [SQLITE_CHANGEGROUP_CONFIG_PATCHSET].
-*/
-SQLITE_API int sqlite3changegroup_config(sqlite3_changegroup*, int, void *pArg);
-
-/*
-** CAPI3REF: Options for sqlite3changegroup_config().
-**
-** The following values may be passed as the 2nd parameter to
-** sqlite3changegroup_config().
-**
-** <dt>SQLITE_CHANGEGROUP_CONFIG_PATCHSET <dd>
-**   A changegroup object generates either a changeset or patchset. Usually,
-**   this is determined by whether the first call to sqlite3changegroup_add()
-**   is passed a changeset or a patchset. Or, if the first changes are added
-**   to the changegroup object using the sqlite3changegroup_change_xxx()
-**   APIs, then this option may be used to configure whether the changegroup
-**   object generates a changeset or patchset.
-**
-**   When this option is invoked, parameter pArg must point to a value of
-**   type int. If the changegroup currently contains zero changes, and the
-**   value of the int variable is zero or greater than zero, then the
-**   changegroup is configured to generate a changeset or patchset,
-**   respectively. It is a no-op, not an error, if the changegroup is not
-**   configured because it has already started accumulating changes.
-**
-**   Before returning, the int variable is set to 0 if the changegroup is
-**   configured to generate a changeset, or 1 if it is configured to generate
-**   a patchset.
-*/
-#define SQLITE_CHANGEGROUP_CONFIG_PATCHSET 1
-
-
-/*
-** CAPI3REF: Begin adding a change to a changegroup
-**
-** This API is used, in concert with other sqlite3changegroup_change_xxx()
-** APIs, to add changes to a changegroup object one at a time. To add a
-** single change, the caller must:
-**
-**   1. Invoke sqlite3changegroup_change_begin() to indicate the type of
-**      change (INSERT, UPDATE or DELETE), the affected table and whether
-**      or not the change should be marked as indirect.
-**
-**   2. Invoke sqlite3changegroup_change_int64() or one of the other four
-**      value functions - _null(), _double(), _text() or _blob() - one or
-**      more times to specify old.* and new.* values for the change being
-**      constructed.
-**
-**   3. Invoke sqlite3changegroup_change_finish() to either finish adding
-**      the change to the group, or to discard the change altogether.
-**
-** The first argument to this function must be a pointer to the existing
-** changegroup object that the change will be added to. The second argument
-** must be SQLITE_INSERT, SQLITE_UPDATE or SQLITE_DELETE. The third is the
-** name of the table that the change affects, and the fourth is a boolean
-** flag specifying whether the change should be marked as "indirect" (if
-** bIndirect is non-zero) or not indirect (if bIndirect is zero).
-**
-** Following a successful call to this function, this function may not be
-** called again on the same changegroup object until after
-** sqlite3changegroup_change_finish() has been called. Doing so is an
-** SQLITE_MISUSE error.
-**
-** The changegroup object passed as the first argument must be already
-** configured with schema data for the specified table. It may be configured
-** either by calling sqlite3changegroup_schema() with a database that contains
-** the table, or sqlite3changegroup_add() with a changeset that contains the
-** table. If the changegroup object has not been configured with a schema for
-** the specified table when this function is called, SQLITE_ERROR is returned.
-**
-** If successful, SQLITE_OK is returned. Otherwise, if an error occurs, an
-** SQLite error code is returned. In this case, if argument pzErr is non-NULL,
-** then (*pzErr) may be set to point to a buffer containing a utf-8 formated,
-** nul-terminated, English language error message. It is the responsibility
-** of the caller to eventually free this buffer using sqlite3_free().
-*/
-SQLITE_API int sqlite3changegroup_change_begin(
-  sqlite3_changegroup*,
-  int eOp,
-  const char *zTab,
-  int bIndirect,
-  char **pzErr
-);
-
-/*
-** CAPI3REF: Add a 64-bit integer to a changegroup
-**
-** This function may only be called between a successful call to
-** sqlite3changegroup_change_begin() and its matching
-** sqlite3changegroup_change_finish() call. If it is called at any
-** other time, it is an SQLITE_MISUSE error. Calling this function
-** specifies a 64-bit integer value to be used in the change currently being
-** added to the changegroup object passed as the first argument.
-**
-** The second parameter, bNew, specifies whether the value is to be part of
-** the new.* (if bNew is non-zero) or old.* (if bNew is zero) record of
-** the change under construction. If this does not match the type of change
-** specified by the preceding call to sqlite3changegroup_change_begin() (i.e.
-** an old.* value for an SQLITE_INSERT change, or a new.* value for an
-** SQLITE_DELETE), then SQLITE_ERROR is returned.
-**
-** The third parameter specifies the column of the old.* or new.* record that
-** the value will be a part of. If the specified table has an explicit primary
-** key, then this is the index of the table column, numbered from 0 in the order
-** specified within the CREATE TABLE statement. Or, if the table uses an
-** implicit rowid key, then the column 0 is the rowid and the explicit columns
-** are numbered starting from 1. If the iCol parameter is less than 0 or greater
-** than the index of the last column in the table, SQLITE_RANGE is returned.
-**
-** The fourth parameter is the integer value to use as part of the old.* or
-** new.* record.
-**
-** If this call is successful, SQLITE_OK is returned. Otherwise, if an
-** error occurs, an SQLite error code is returned.
-*/
-SQLITE_API int sqlite3changegroup_change_int64(
-  sqlite3_changegroup*,
-  int bNew,
-  int iCol,
-  sqlite3_int64 iVal
-);
-
-/*
-** CAPI3REF: Add a NULL to a changegroup
-**
-** This function is similar to sqlite3changegroup_change_int64(). Except that
-** it configures the change currently under construction with a NULL value
-** instead of a 64-bit integer.
-*/
-SQLITE_API int sqlite3changegroup_change_null(sqlite3_changegroup*, int, int);
-
-/*
-** CAPI3REF: Add an double to a changegroup
-**
-** This function is similar to sqlite3changegroup_change_int64(). Except that
-** it configures the change currently being constructed with a real value
-** instead of a 64-bit integer.
-*/
-SQLITE_API int sqlite3changegroup_change_double(sqlite3_changegroup*, int, int, double);
-
-/*
-** CAPI3REF: Add a text value to a changegroup
-**
-** This function is similar to sqlite3changegroup_change_int64(). It configures
-** the currently accumulated change with a text value instead of a 64-bit
-** integer. Parameter pVal points to a buffer containing the text encoded using
-** utf-8. Parameter nVal may either be the size of the text value in bytes, or
-** else a negative value, in which case the buffer pVal points to is assumed to
-** be nul-terminated.
-*/
-SQLITE_API int sqlite3changegroup_change_text(
-  sqlite3_changegroup*, int, int, const char *pVal, int nVal
-);
-
-/*
-** CAPI3REF: Add a blob to a changegroup
-**
-** This function is similar to sqlite3changegroup_change_int64(). It configures
-** the currently accumulated change with a blob value instead of a 64-bit
-** integer. Parameter pVal points to a buffer containing the blob. Parameter
-** nVal is the size of the blob in bytes.
-*/
-SQLITE_API int sqlite3changegroup_change_blob(
-    sqlite3_changegroup*, int, int, const void *pVal, int nVal
-);
-
-/*
-** CAPI3REF: Finish adding one-at-at-time changes to a changegroup
-**
-** This function may only be called following a successful call to
-** sqlite3changegroup_change_begin(). Otherwise, it is an SQLITE_MISUSE error.
-**
-** If parameter bDiscard is non-zero, then the current change is simply
-** discarded. In this case this function is always successful and SQLITE_OK
-** returned.
-**
-** If parameter bDiscard is zero, then an attempt is made to add the current
-** change to the changegroup. Assuming the changegroup is configured to
-** produce a changeset (not a patchset), this requires that:
-**
-**   *  If the change is an INSERT or DELETE, then a value must be specified
-**      for all columns of the new.* or old.* record, respectively.
-**
-**   *  If the change is an UPDATE record, then values must be provided for
-**      the PRIMARY KEY columns of the old.* record, but must not be provided
-**      for PRIMARY KEY columns of the new.* record.
-**
-**   *  If the change is an UPDATE record, then for each non-PRIMARY KEY
-**      column in the old.* record for which a value has been provided, a
-**      value must also be provided for the same column in the new.* record.
-**      Similarly, for each non-PK column in the old.* record for which
-**      a value is not provided, a value must not be provided for the same
-**      column in the new.* record.
-**
-**   *  All values specified for PRIMARY KEY columns must be non-NULL.
-**
-** Otherwise, it is an error.
-**
-** If the changegroup already contains a change for the same row (identified
-** by PRIMARY KEY columns), then the current change is combined with the
-** existing change in the same way as for sqlite3changegroup_add().
-**
-** For a patchset, all of the above rules apply except that it doesn't matter
-** whether or not values are provided for the non-PK old.* record columns
-** for an UPDATE or DELETE change. This means that code used to produce
-** a changeset using the sqlite3changegroup_change_xxx() APIs may also
-** be used to produce patchsets.
-**
-** If the call is successful, SQLITE_OK is returned. Otherwise, if an error
-** occurs, an SQLite error code is returned. If an error is returned and
-** parameter pzErr is not NULL, then (*pzErr) may be set to point to a buffer
-** containing a nul-terminated, utf-8 encoded, English language error message.
-** It is the responsibility of the caller to eventually free any such error
-** message buffer using sqlite3_free().
-*/
-SQLITE_API int sqlite3changegroup_change_finish(
-  sqlite3_changegroup*,
-  int bDiscard,
-  char **pzErr
-);
-
-/*
-** 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 pUserData pointer passed to the xCreateFunction()
-**   API when the extension function was registered.
-**
-** 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:
-**   If parameter iCol is less than zero, or greater than or equal to the
-**   number of columns in the table, SQLITE_RANGE is returned.
-**
-**   Otherwise, 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:
-**   If parameter iCol is less than zero, or greater than or equal to the
-**   number of phrases in the current query, as returned by xPhraseCount,
-**   0 is returned. Otherwise, this function 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(). If iIdx is less than zero or greater than
-**   or equal to the value returned by xInstCount(), SQLITE_RANGE is returned.
-**
-**   Otherwise, 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. SQLITE_OK is returned 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 parameter iPhrase is less than zero, or greater than or equal to
-**   the number of phrases in the query, as returned by xPhraseCount(),
-**   this function returns SQLITE_RANGE.
-**
-**   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).
-**
-**   In all cases, matches are visited in (column ASC, offset ASC) order.
-**   i.e. all those in column 0, sorted by offset, followed by those in
-**   column 1, etc.
-**
-** 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.
-**
-** xQueryToken(pFts5, iPhrase, iToken, ppToken, pnToken)
-**   This is used to access token iToken of phrase iPhrase of the current
-**   query. Before returning, output parameter *ppToken is set to point
-**   to a buffer containing the requested token, and *pnToken to the
-**   size of this buffer in bytes.
-**
-**   If iPhrase or iToken are less than zero, or if iPhrase is greater than
-**   or equal to the number of phrases in the query as reported by
-**   xPhraseCount(), or if iToken is equal to or greater than the number of
-**   tokens in the phrase, SQLITE_RANGE is returned and *ppToken and *pnToken
-     are both zeroed.
-**
-**   The output text is not a copy of the query text that specified the
-**   token. It is the output of the tokenizer module. For tokendata=1
-**   tables, this includes any embedded 0x00 and trailing data.
-**
-** xInstToken(pFts5, iIdx, iToken, ppToken, pnToken)
-**   This is used to access token iToken of phrase hit iIdx within the
-**   current row. If iIdx is less than zero or greater than or equal to the
-**   value returned by xInstCount(), SQLITE_RANGE is returned.  Otherwise,
-**   output variable (*ppToken) is set to point to a buffer containing the
-**   matching document token, and (*pnToken) to the size of that buffer in
-**   bytes.
-**
-**   The output text is not a copy of the document text that was tokenized.
-**   It is the output of the tokenizer module. For tokendata=1 tables, this
-**   includes any embedded 0x00 and trailing data.
-**
-**   This API may be slow in some cases if the token identified by parameters
-**   iIdx and iToken matched a prefix token in the query. In most cases, the
-**   first call to this API for each prefix token in the query is forced
-**   to scan the portion of the full-text index that matches the prefix
-**   token to collect the extra data required by this API. If the prefix
-**   token matches a large number of token instances in the document set,
-**   this may be a performance problem.
-**
-**   If the user knows in advance that a query may use this API for a
-**   prefix token, FTS5 may be configured to collect all required data as part
-**   of the initial querying of the full-text index, avoiding the second scan
-**   entirely. This also causes prefix queries that do not use this API to
-**   run more slowly and use more memory. FTS5 may be configured in this way
-**   either on a per-table basis using the [FTS5 insttoken | 'insttoken']
-**   option, or on a per-query basis using the
-**   [fts5_insttoken | fts5_insttoken()] user function.
-**
-**   This API can be quite slow if used with an FTS5 table created with the
-**   "detail=none" or "detail=column" option.
-**
-** xColumnLocale(pFts5, iIdx, pzLocale, pnLocale)
-**   If parameter iCol is less than zero, or greater than or equal to the
-**   number of columns in the table, SQLITE_RANGE is returned.
-**
-**   Otherwise, this function attempts to retrieve the locale associated
-**   with column iCol of the current row. Usually, there is no associated
-**   locale, and output parameters (*pzLocale) and (*pnLocale) are set
-**   to NULL and 0, respectively. However, if the fts5_locale() function
-**   was used to associate a locale with the value when it was inserted
-**   into the fts5 table, then (*pzLocale) is set to point to a nul-terminated
-**   buffer containing the name of the locale in utf-8 encoding. (*pnLocale)
-**   is set to the size in bytes of the buffer, not including the
-**   nul-terminator.
-**
-**   If successful, SQLITE_OK is returned. Or, if an error occurs, an
-**   SQLite error code is returned. The final value of the output parameters
-**   is undefined in this case.
-**
-** xTokenize_v2:
-**   Tokenize text using the tokenizer belonging to the FTS5 table. This
-**   API is the same as the xTokenize() API, except that it allows a tokenizer
-**   locale to be specified.
-*/
-struct Fts5ExtensionApi {
-  int iVersion;                   /* Currently always set to 4 */
-
-  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);
-
-  /* Below this point are iVersion>=3 only */
-  int (*xQueryToken)(Fts5Context*,
-      int iPhrase, int iToken,
-      const char **ppToken, int *pnToken
-  );
-  int (*xInstToken)(Fts5Context*, int iIdx, int iToken, const char**, int*);
-
-  /* Below this point are iVersion>=4 only */
-  int (*xColumnLocale)(Fts5Context*, int iCol, const char **pz, int *pn);
-  int (*xTokenize_v2)(Fts5Context*,
-    const char *pText, int nText,      /* Text to tokenize */
-    const char *pLocale, int nLocale,  /* Locale to pass to tokenizer */
-    void *pCtx,                        /* Context passed to xToken() */
-    int (*xToken)(void*, int, const char*, int, int, int)       /* Callback */
-  );
-};
-
-/*
-** 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_v2 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 third argument indicates the reason that FTS5 is requesting
-**   tokenization of the supplied text. This is always one of the following
-**   four values:
-**
-**   <ul><li> <b>FTS5_TOKENIZE_DOCUMENT</b> - 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.
-**
-**       <li> <b>FTS5_TOKENIZE_QUERY</b> - 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.
-**
-**       <li> <b>(FTS5_TOKENIZE_QUERY | FTS5_TOKENIZE_PREFIX)</b> - 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.
-**
-**       <li> <b>FTS5_TOKENIZE_AUX</b> - 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.
-**   </ul>
-**
-**   The sixth and seventh arguments passed to xTokenize() - pLocale and
-**   nLocale - are a pointer to a buffer containing the locale to use for
-**   tokenization (e.g. "en_US") and its size in bytes, respectively. The
-**   pLocale buffer is not nul-terminated. pLocale may be passed NULL (in
-**   which case nLocale is always 0) to indicate that the tokenizer should
-**   use its default locale.
-**
-**   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.
-**
-**   If the tokenizer is registered using an fts5_tokenizer_v2 object,
-**   then the xTokenize() method has two additional arguments - pLocale
-**   and nLocale. These specify the locale that the tokenizer should use
-**   for the current request. If pLocale and nLocale are both 0, then the
-**   tokenizer should use its default locale. Otherwise, pLocale points to
-**   an nLocale byte buffer containing the name of the locale to use as utf-8
-**   text. pLocale is not nul-terminated.
-**
-** FTS5_TOKENIZER
-**
-** There is also an fts5_tokenizer object. This is an older, deprecated,
-** version of fts5_tokenizer_v2. It is similar except that:
-**
-**  <ul>
-**    <li> There is no "iVersion" field, and
-**    <li> The xTokenize() method does not take a locale argument.
-**  </ul>
-**
-** Legacy fts5_tokenizer tokenizers must be registered using the
-** legacy xCreateTokenizer() function, instead of xCreateTokenizer_v2().
-**
-** Tokenizer implementations registered using either API may be retrieved
-** using both xFindTokenizer() and xFindTokenizer_v2().
-**
-** 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:
-**
-**   <ol><li> 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.
-**
-**       <li> 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:
-**
-**   <codeblock>
-**     ... MATCH 'first place'</codeblock>
-**
-**            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:
-**
-**   <codeblock>
-**     ... MATCH '(first OR 1st) place'</codeblock>
-**
-**            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.
-**
-**       <li> 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.
-**   </ol>
-**
-**   Whether it is parsing document or query text, any call to xToken that
-**   specifies a <i>tflags</i> 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:
-**
-**   <codeblock>
-**       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);
-**</codeblock>
-**
-**   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:
-**
-**   <codeblock>
-**     ... MATCH '1s*'</codeblock>
-**
-**   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 (3)) or query
-**   text (method (2)), not both. Doing so will not cause any errors, but is
-**   inefficient.
-*/
-typedef struct Fts5Tokenizer Fts5Tokenizer;
-typedef struct fts5_tokenizer_v2 fts5_tokenizer_v2;
-struct fts5_tokenizer_v2 {
-  int iVersion;             /* Currently always 2 */
-
-  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,
-      const char *pLocale, int nLocale,
-      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 */
-      )
-  );
-};
-
-/*
-** New code should use the fts5_tokenizer_v2 type to define tokenizer
-** implementations. The following type is included for legacy applications
-** that still use it.
-*/
-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 3 */
-
-  /* Create a new tokenizer */
-  int (*xCreateTokenizer)(
-    fts5_api *pApi,
-    const char *zName,
-    void *pUserData,
-    fts5_tokenizer *pTokenizer,
-    void (*xDestroy)(void*)
-  );
-
-  /* Find an existing tokenizer */
-  int (*xFindTokenizer)(
-    fts5_api *pApi,
-    const char *zName,
-    void **ppUserData,
-    fts5_tokenizer *pTokenizer
-  );
-
-  /* Create a new auxiliary function */
-  int (*xCreateFunction)(
-    fts5_api *pApi,
-    const char *zName,
-    void *pUserData,
-    fts5_extension_function xFunction,
-    void (*xDestroy)(void*)
-  );
-
-  /* APIs below this point are only available if iVersion>=3 */
-
-  /* Create a new tokenizer */
-  int (*xCreateTokenizer_v2)(
-    fts5_api *pApi,
-    const char *zName,
-    void *pUserData,
-    fts5_tokenizer_v2 *pTokenizer,
-    void (*xDestroy)(void*)
-  );
-
-  /* Find an existing tokenizer */
-  int (*xFindTokenizer_v2)(
-    fts5_api *pApi,
-    const char *zName,
-    void **ppUserData,
-    fts5_tokenizer_v2 **ppTokenizer
-  );
-};
-
-/*
-** END OF REGISTRATION API
-*************************************************************************/
-
-#if 0
-}  /* end of the 'extern "C"' block */
-#endif
-
-#endif /* _FTS5_H */
-
-/******** End of fts5.h *********/
-#endif /* SQLITE3_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
-#define SQLITE_MIN_LENGTH 30   /* Minimum value for the length limit */
-
-/*
-** 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
-
-/*
-** 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 32767.  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.
-**
-** An index can only have SQLITE_MAX_COLUMN columns from the user
-** point of view, but the underlying b-tree that implements the index
-** might have up to twice as many columns in a WITHOUT ROWID table,
-** since must also store the primary key at the end.  Hence the
-** column count for Index is u16 instead of i16.
-*/
-#if !defined(SQLITE_MAX_COLUMN)
-# define SQLITE_MAX_COLUMN 2000
-#elif SQLITE_MAX_COLUMN>32767
-# error SQLITE_MAX_COLUMN may not exceed 32767
-#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.
-**
-** The hard limit is the largest possible 32-bit signed integer less
-** 1024, or 2147482624.
-*/
-#ifndef SQLITE_MAX_SQL_LENGTH
-# define SQLITE_MAX_SQL_LENGTH 1000000000
-#endif
-
-/*
-** The maximum depth of an expression tree. The expression tree depth
-** is also limited indirectly by SQLITE_MAX_SQL_LENGTH and by
-** SQLITE_MAX_PARSER_DEPTH.  Reducing the maximum complexity of
-** expressions can help prevent excess memory usage by hostile SQL.
-**
-** A value of 0 for this compile-time option causes all expression
-** depth limiting code to be omitted.
-*/
-#ifndef SQLITE_MAX_EXPR_DEPTH
-# define SQLITE_MAX_EXPR_DEPTH 1000
-#endif
-
-/*
-** The maximum depth of the LALR(1) stack used in the parser that
-** interprets SQL inputs. The parser stack depth can also be limited
-** indirectly by SQLITE_MAX_SQL_LENGTH.  Limiting the parser stack
-** depth can help prevent excess memory usage and excess CPU stack
-** usage when processing hostile SQL.
-**
-** Prior to version 3.45.0 (2024-01-15), the parser stack was
-** hard-coded to 100 entries, and that worked fine for almost all
-** applications.  So the upper bound on this limit need not be large.
-*/
-#ifndef SQLITE_MAX_PARSER_DEPTH
-# define SQLITE_MAX_PARSER_DEPTH 2500
-#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 compound 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.
-**
-** This value has a hard upper limit of 32767 due to storage
-** constraints (it needs to fit inside a i16).  We keep it
-** lower than that to prevent abuse.
-*/
-#ifndef SQLITE_MAX_FUNCTION_ARG
-# define SQLITE_MAX_FUNCTION_ARG 1000
-#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
-#if SQLITE_MAX_DEFAULT_PAGE_SIZE<SQLITE_DEFAULT_PAGE_SIZE
-# undef SQLITE_MAX_DEFAULT_PAGE_SIZE
-# define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_DEFAULT_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 the
-** max_page_count macro.
-*/
-#ifndef SQLITE_MAX_PAGE_COUNT
-# define SQLITE_MAX_PAGE_COUNT 0xfffffffe /* 4294967294 */
-#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
-*/
-#include <stdint.h>
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-#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 <intrin.h>
-#      pragma intrinsic(_byteswap_ushort)
-#      pragma intrinsic(_byteswap_ulong)
-#      pragma intrinsic(_byteswap_uint64)
-#      pragma intrinsic(_ReadWriteBarrier)
-#    else
-#      include <cmnintrin.h>
-#    endif
-#  endif
-#endif
-
-/*
-** Enable SQLITE_USE_SEH by default on MSVC builds.  Only omit
-** SEH support if the -DSQLITE_OMIT_SEH option is given.
-*/
-#if defined(_MSC_VER) && !defined(SQLITE_OMIT_SEH)
-# define SQLITE_USE_SEH 1
-#else
-# undef SQLITE_USE_SEH
-#endif
-
-/*
-** Enable SQLITE_DIRECT_OVERFLOW_READ, unless the build explicitly
-** disables it using -DSQLITE_DIRECT_OVERFLOW_READ=0
-*/
-#if defined(SQLITE_DIRECT_OVERFLOW_READ) && SQLITE_DIRECT_OVERFLOW_READ+1==1
-  /* Disable if -DSQLITE_DIRECT_OVERFLOW_READ=0 */
-# undef SQLITE_DIRECT_OVERFLOW_READ
-#else
-  /* In all other cases, enable */
-# define SQLITE_DIRECT_OVERFLOW_READ 1
-#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
-
-#define SQLITE_DIGIT_SEPARATOR '_'
-
-/*
-** 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 */
-  unsigned int h;              /* hash for pKey */
-};
-
-/*
-** 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_ISNOT                           46
-#define TK_MATCH                           47
-#define TK_LIKE_KW                         48
-#define TK_BETWEEN                         49
-#define TK_IN                              50
-#define TK_ISNULL                          51
-#define TK_NOTNULL                         52
-#define TK_NE                              53
-#define TK_EQ                              54
-#define TK_GT                              55
-#define TK_LE                              56
-#define TK_LT                              57
-#define TK_GE                              58
-#define TK_ESCAPE                          59
-#define TK_ID                              60
-#define TK_COLUMNKW                        61
-#define TK_DO                              62
-#define TK_FOR                             63
-#define TK_IGNORE                          64
-#define TK_INITIALLY                       65
-#define TK_INSTEAD                         66
-#define TK_NO                              67
-#define TK_KEY                             68
-#define TK_OF                              69
-#define TK_OFFSET                          70
-#define TK_PRAGMA                          71
-#define TK_RAISE                           72
-#define TK_RECURSIVE                       73
-#define TK_REPLACE                         74
-#define TK_RESTRICT                        75
-#define TK_ROW                             76
-#define TK_ROWS                            77
-#define TK_TRIGGER                         78
-#define TK_VACUUM                          79
-#define TK_VIEW                            80
-#define TK_VIRTUAL                         81
-#define TK_WITH                            82
-#define TK_NULLS                           83
-#define TK_FIRST                           84
-#define TK_LAST                            85
-#define TK_CURRENT                         86
-#define TK_FOLLOWING                       87
-#define TK_PARTITION                       88
-#define TK_PRECEDING                       89
-#define TK_RANGE                           90
-#define TK_UNBOUNDED                       91
-#define TK_EXCLUDE                         92
-#define TK_GROUPS                          93
-#define TK_OTHERS                          94
-#define TK_TIES                            95
-#define TK_GENERATED                       96
-#define TK_ALWAYS                          97
-#define TK_MATERIALIZED                    98
-#define TK_REINDEX                         99
-#define TK_RENAME                         100
-#define TK_CTIME_KW                       101
-#define TK_ANY                            102
-#define TK_BITAND                         103
-#define TK_BITOR                          104
-#define TK_LSHIFT                         105
-#define TK_RSHIFT                         106
-#define TK_PLUS                           107
-#define TK_MINUS                          108
-#define TK_STAR                           109
-#define TK_SLASH                          110
-#define TK_REM                            111
-#define TK_CONCAT                         112
-#define TK_PTR                            113
-#define TK_COLLATE                        114
-#define TK_BITNOT                         115
-#define TK_ON                             116
-#define TK_INDEXED                        117
-#define TK_STRING                         118
-#define TK_JOIN_KW                        119
-#define TK_CONSTRAINT                     120
-#define TK_DEFAULT                        121
-#define TK_NULL                           122
-#define TK_PRIMARY                        123
-#define TK_UNIQUE                         124
-#define TK_CHECK                          125
-#define TK_REFERENCES                     126
-#define TK_AUTOINCR                       127
-#define TK_INSERT                         128
-#define TK_DELETE                         129
-#define TK_UPDATE                         130
-#define TK_SET                            131
-#define TK_DEFERRABLE                     132
-#define TK_FOREIGN                        133
-#define TK_DROP                           134
-#define TK_UNION                          135
-#define TK_ALL                            136
-#define TK_EXCEPT                         137
-#define TK_INTERSECT                      138
-#define TK_SELECT                         139
-#define TK_VALUES                         140
-#define TK_DISTINCT                       141
-#define TK_DOT                            142
-#define TK_FROM                           143
-#define TK_JOIN                           144
-#define TK_USING                          145
-#define TK_ORDER                          146
-#define TK_GROUP                          147
-#define TK_HAVING                         148
-#define TK_LIMIT                          149
-#define TK_WHERE                          150
-#define TK_RETURNING                      151
-#define TK_INTO                           152
-#define TK_NOTHING                        153
-#define TK_FLOAT                          154
-#define TK_BLOB                           155
-#define TK_INTEGER                        156
-#define TK_VARIABLE                       157
-#define TK_CASE                           158
-#define TK_WHEN                           159
-#define TK_THEN                           160
-#define TK_ELSE                           161
-#define TK_INDEX                          162
-#define TK_ALTER                          163
-#define TK_ADD                            164
-#define TK_WINDOW                         165
-#define TK_OVER                           166
-#define TK_FILTER                         167
-#define TK_COLUMN                         168
-#define TK_AGG_FUNCTION                   169
-#define TK_AGG_COLUMN                     170
-#define TK_TRUEFALSE                      171
-#define TK_FUNCTION                       172
-#define TK_UPLUS                          173
-#define TK_UMINUS                         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_QNUMBER                        183
-#define TK_SPACE                          184
-#define TK_COMMENT                        185
-#define TK_ILLEGAL                        186
-
-/************** End of parse.h ***********************************************/
-/************** Continuing where we left off in sqliteInt.h ******************/
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <stddef.h>
-#include <ctype.h>
-
-/*
-** 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 fabs(X) ((X)<0?-(X):(X))
-# define sqlite3IsOverflow(X) 0
-# define INFINITY (9223372036854775807LL)
-# 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(ST,M) ((size_t)((char*)&((ST*)0)->M - (char*)0))
-#endif
-
-/*
-** Work around C99 "flex-array" syntax for pre-C99 compilers, so as
-** to avoid complaints from -fsanitize=strict-bounds.
-*/
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
-# define FLEXARRAY
-#else
-# define FLEXARRAY 1
-#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
-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 */
-
-/* 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 */
-
-/*
-** 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;
-#define LOGEST_MIN (-32768)
-#define LOGEST_MAX (32767)
-
-/*
-** 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(__ppc__)) ||                         \
-      (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)))
-
-/*
-** P is one byte past the end of a large buffer. Return true if a span of bytes
-** between S..E crosses the end of that buffer.  In other words, return true
-** if the sub-buffer S..E-1 overflows the buffer whose last byte is P-1.
-**
-** S is the start of the span.  E is one byte past the end of end of span.
-**
-**                        P
-**     |-----------------|                FALSE
-**               |-------|
-**               S        E
-**
-**                        P
-**     |-----------------|
-**                    |-------|           TRUE
-**                    S        E
-**
-**                        P
-**     |-----------------|
-**                        |-------|       FALSE
-**                        S        E
-*/
-#define SQLITE_OVERFLOW(P,S,E) (((uptr)(S)<(uptr)(P))&&((uptr)(E)>(uptr)(P)))
-
-/*
-** 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.
-**
-** If you are building SQLite on some obscure platform for which the
-** following ifdef magic does not work, you can always include either:
-**
-**    -DSQLITE_BYTEORDER=1234
-**
-** or
-**
-**    -DSQLITE_BYTEORDER=4321
-**
-** to cause the build to work for little-endian or big-endian processors,
-** respectively.
-*/
-#ifndef SQLITE_BYTEORDER  /* Replicate changes at tag-20230904a */
-# if defined(__BYTE_ORDER__) && __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
-#   define SQLITE_BYTEORDER 4321
-# elif defined(__BYTE_ORDER__) && __BYTE_ORDER__==__ORDER_LITTLE_ENDIAN__
-#   define SQLITE_BYTEORDER 1234
-# elif defined(__BIG_ENDIAN__) && __BIG_ENDIAN__==1
-#   define SQLITE_BYTEORDER 4321
-# elif 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(__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)
-
-/*
-** Macro SMXV(n) return the maximum value that can be held in variable n,
-** assuming n is a signed integer type.  UMXV(n) is similar for unsigned
-** integer types.
-*/
-#define SMXV(n) ((((i64)1)<<(sizeof(n)*8-1))-1)
-#define UMXV(n) ((((i64)1)<<(sizeof(n)*8))-1)
-
-/*
-** 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
-#define TWO_BYTE_ALIGNMENT(X)      ((((uptr)(X) - (uptr)0)&1)==0)
-
-/*
-** 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 <TargetConditionals.h>
-#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
-**   0x00080000     NOT NULL strength reduction
-**   0x00100000     Pointers are all shown as zero
-**   0x00200000     EXISTS-to-JOIN optimization
-*/
-
-/*
-** 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 (Use 0x40000 for less detail)
-** 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 adjustments
-** 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()
-** 0x00040000   Solver overview messages
-** 0x00080000   Star-query heuristic
-** 0x00100000   Pointers are all shown as zero
-*/
-
-
-/*
-** 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 wherever 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)sqlite3RowSetClear)
-
-/*
-** 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 DbClientData DbClientData;
-typedef struct DbFixer DbFixer;
-typedef struct Schema Schema;
-typedef struct Expr Expr;
-typedef struct ExprList ExprList;
-typedef struct FKey FKey;
-typedef struct FpDecode FpDecode;
-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 RCStr RCStr;
-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 Subquery Subquery;
-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 SQLITE_OS_KV+1<=1  && SQLITE_OS_OTHER+1<=1 &&  \
-    SQLITE_OS_WIN+1<=1 && SQLITE_OS_UNIX+1<=1
-#  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 */
-
-#define isWalMode(x) ((x)==PAGER_JOURNALMODE_WAL)
-
-/*
-** 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)
-
-/*
-** 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);
-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, u64*);
-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);
-
-/* 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
-
-#if defined(SQLITE_USE_SEH) && !defined(SQLITE_OMIT_WAL)
-SQLITE_PRIVATE int sqlite3PagerWalSystemErrno(Pager*);
-#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);
-#ifdef SQLITE_DEBUG
-SQLITE_PRIVATE int sqlite3BtreeClosesWithCursor(Btree*,BtCursor*);
-#endif
-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 sqlite3BtreeIsEmpty(BtCursor *pCur, 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*);
-SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor*);
-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 */
-  sqlite3_value *aCnt,  /* OUT: entry counts for each btree in aRoot[] */
-  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 <stdio.h> */
-
-/*
-** 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;
-typedef struct SubrtnSig SubrtnSig;
-
-/*
-** A signature for a reusable subroutine that materializes the RHS of
-** an IN operator.
-*/
-struct SubrtnSig {
-  int selId;          /* SELECT-id for the SELECT statement on the RHS */
-  u8 bComplete;       /* True if fully coded and available for reusable */
-  char *zAff;         /* Affinity of the overall IN expression */
-  int iTable;         /* Ephemeral table generated by the subroutine */
-  int iAddr;          /* Subroutine entry address */
-  int regReturn;      /* Register used to hold return address */
-};
-
-/*
-** 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 */
-    SubrtnSig *pSubrtnSig; /* Used when p4type is P4_SUBRTNSIG */
-    Index *pIdx;           /* Used when p4type is P4_INDEX */
-#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 */
-#define P4_INDEX      (-6)  /* P4 is a pointer to an Index structure */
-/* Above do not own any resources.  Must free those below */
-#define P4_FREE_IF_LE (-7)
-#define P4_DYNAMIC    (-7)  /* Pointer to memory from sqliteMalloc() */
-#define P4_FUNCDEF    (-8)  /* P4 is a pointer to a FuncDef structure */
-#define P4_KEYINFO    (-9)  /* P4 is a pointer to a KeyInfo structure */
-#define P4_EXPR       (-10) /* P4 is a pointer to an Expr tree */
-#define P4_MEM        (-11) /* P4 is a pointer to a Mem*    structure */
-#define P4_VTAB       (-12) /* P4 is a pointer to an sqlite3_vtab structure */
-#define P4_REAL       (-13) /* P4 is a 64-bit floating point value */
-#define P4_INT64      (-14) /* P4 is a 64-bit signed integer */
-#define P4_INTARRAY   (-15) /* P4 is a vector of 32-bit integers */
-#define P4_FUNCCTX    (-16) /* P4 is a pointer to an sqlite3_context object */
-#define P4_TABLEREF   (-17) /* Like P4_TABLE, but reference counted */
-#define P4_SUBRTNSIG  (-18) /* P4 is a SubrtnSig pointer */
-
-/* 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 /* jump0, synopsis: Start at P2               */
-#define OP_Goto            9 /* jump                                       */
-#define OP_Gosub          10 /* jump                                       */
-#define OP_InitCoroutine  11 /* jump0                                      */
-#define OP_Yield          12 /* jump0                                      */
-#define OP_MustBeInt      13 /* jump0                                      */
-#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 /* jump0, synopsis: key=r[P3@P4]              */
-#define OP_SeekLE         22 /* jump0, synopsis: key=r[P3@P4]              */
-#define OP_SeekGE         23 /* jump0, synopsis: key=r[P3@P4]              */
-#define OP_SeekGT         24 /* jump0, 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 /* jump0, synopsis: intkey=r[P3]              */
-#define OP_NotExists      31 /* jump, synopsis: intkey=r[P3]               */
-#define OP_Last           32 /* jump0                                      */
-#define OP_IfSizeBetween  33 /* jump                                       */
-#define OP_SorterSort     34 /* jump                                       */
-#define OP_Sort           35 /* jump                                       */
-#define OP_Rewind         36 /* jump0                                      */
-#define OP_IfEmpty        37 /* jump, synopsis: if( empty(P1) ) goto P2    */
-#define OP_SorterNext     38 /* jump                                       */
-#define OP_Prev           39 /* jump                                       */
-#define OP_Next           40 /* jump                                       */
-#define OP_IdxLE          41 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_IdxGT          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_IdxLT          45 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_IdxGE          46 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_IFindKey       47 /* jump                                       */
-#define OP_RowSetRead     48 /* jump, synopsis: r[P3]=rowset(P1)           */
-#define OP_RowSetTest     49 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */
-#define OP_Program        50 /* jump0                                      */
-#define OP_IsNull         51 /* jump, same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */
-#define OP_NotNull        52 /* jump, same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */
-#define OP_Ne             53 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */
-#define OP_Eq             54 /* jump, same as TK_EQ, synopsis: IF r[P3]==r[P1] */
-#define OP_Gt             55 /* jump, same as TK_GT, synopsis: IF r[P3]>r[P1] */
-#define OP_Le             56 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */
-#define OP_Lt             57 /* jump, same as TK_LT, synopsis: IF r[P3]<r[P1] */
-#define OP_Ge             58 /* jump, same as TK_GE, synopsis: IF r[P3]>=r[P1] */
-#define OP_ElseEq         59 /* jump, same as TK_ESCAPE                    */
-#define OP_FkIfZero       60 /* jump, synopsis: if fkctr[P1]==0 goto P2    */
-#define OP_IfPos          61 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
-#define OP_IfNotZero      62 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */
-#define OP_DecrJumpZero   63 /* jump, synopsis: if (--r[P1])==0 goto P2    */
-#define OP_IncrVacuum     64 /* jump                                       */
-#define OP_VNext          65 /* jump                                       */
-#define OP_Filter         66 /* jump, synopsis: if key(P3@P4) not in filter(P1) goto P2 */
-#define OP_PureFunc       67 /* synopsis: r[P3]=func(r[P2@NP])             */
-#define OP_Function       68 /* synopsis: r[P3]=func(r[P2@NP])             */
-#define OP_Return         69
-#define OP_EndCoroutine   70
-#define OP_HaltIfNull     71 /* synopsis: if r[P3]=null halt               */
-#define OP_Halt           72
-#define OP_Integer        73 /* synopsis: r[P2]=P1                         */
-#define OP_Int64          74 /* synopsis: r[P2]=P4                         */
-#define OP_String         75 /* synopsis: r[P2]='P4' (len=P1)              */
-#define OP_BeginSubrtn    76 /* synopsis: r[P2]=NULL                       */
-#define OP_Null           77 /* synopsis: r[P2..P3]=NULL                   */
-#define OP_SoftNull       78 /* synopsis: r[P1]=NULL                       */
-#define OP_Blob           79 /* synopsis: r[P2]=P4 (len=P1)                */
-#define OP_Variable       80 /* synopsis: r[P2]=parameter(P1)              */
-#define OP_Move           81 /* synopsis: r[P2@P3]=r[P1@P3]                */
-#define OP_Copy           82 /* synopsis: r[P2@P3+1]=r[P1@P3+1]            */
-#define OP_SCopy          83 /* synopsis: r[P2]=r[P1]                      */
-#define OP_IntCopy        84 /* synopsis: r[P2]=r[P1]                      */
-#define OP_FkCheck        85
-#define OP_ResultRow      86 /* synopsis: output=r[P1@P2]                  */
-#define OP_CollSeq        87
-#define OP_AddImm         88 /* synopsis: r[P1]=r[P1]+P2                   */
-#define OP_RealAffinity   89
-#define OP_Cast           90 /* synopsis: affinity(r[P1])                  */
-#define OP_Permutation    91
-#define OP_Compare        92 /* synopsis: r[P1@P3] <-> r[P2@P3]            */
-#define OP_IsTrue         93 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */
-#define OP_ZeroOrNull     94 /* synopsis: r[P2] = 0 OR NULL                */
-#define OP_Offset         95 /* synopsis: r[P3] = sqlite_offset(P1)        */
-#define OP_Column         96 /* synopsis: r[P3]=PX cursor P1 column P2     */
-#define OP_TypeCheck      97 /* synopsis: typecheck(r[P1@P2])              */
-#define OP_Affinity       98 /* synopsis: affinity(r[P1@P2])               */
-#define OP_MakeRecord     99 /* synopsis: r[P3]=mkrec(r[P1@P2])            */
-#define OP_Count         100 /* synopsis: r[P2]=count()                    */
-#define OP_ReadCookie    101
-#define OP_SetCookie     102
-#define OP_BitAnd        103 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */
-#define OP_BitOr         104 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */
-#define OP_ShiftLeft     105 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */
-#define OP_ShiftRight    106 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */
-#define OP_Add           107 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */
-#define OP_Subtract      108 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */
-#define OP_Multiply      109 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */
-#define OP_Divide        110 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
-#define OP_Remainder     111 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
-#define OP_Concat        112 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
-#define OP_ReopenIdx     113 /* synopsis: root=P2 iDb=P3                   */
-#define OP_OpenRead      114 /* synopsis: root=P2 iDb=P3                   */
-#define OP_BitNot        115 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */
-#define OP_OpenWrite     116 /* synopsis: root=P2 iDb=P3                   */
-#define OP_OpenDup       117
-#define OP_String8       118 /* same as TK_STRING, synopsis: r[P2]='P4'    */
-#define OP_OpenAutoindex 119 /* synopsis: nColumn=P2                       */
-#define OP_OpenEphemeral 120 /* synopsis: nColumn=P2                       */
-#define OP_SorterOpen    121
-#define OP_SequenceTest  122 /* synopsis: if( cursor[P1].ctr++ ) pc = P2   */
-#define OP_OpenPseudo    123 /* synopsis: P3 columns in r[P2]              */
-#define OP_Close         124
-#define OP_ColumnsUsed   125
-#define OP_SeekScan      126 /* synopsis: Scan-ahead up to P1 rows         */
-#define OP_SeekHit       127 /* synopsis: set P2<=seekHit<=P3              */
-#define OP_Sequence      128 /* synopsis: r[P2]=cursor[P1].ctr++           */
-#define OP_NewRowid      129 /* synopsis: r[P2]=rowid                      */
-#define OP_Insert        130 /* synopsis: intkey=r[P3] data=r[P2]          */
-#define OP_RowCell       131
-#define OP_Delete        132
-#define OP_ResetCount    133
-#define OP_SorterCompare 134 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
-#define OP_SorterData    135 /* synopsis: r[P2]=data                       */
-#define OP_RowData       136 /* synopsis: r[P2]=data                       */
-#define OP_Rowid         137 /* synopsis: r[P2]=PX rowid of P1             */
-#define OP_NullRow       138
-#define OP_SeekEnd       139
-#define OP_IdxInsert     140 /* synopsis: key=r[P2]                        */
-#define OP_SorterInsert  141 /* synopsis: key=r[P2]                        */
-#define OP_IdxDelete     142 /* synopsis: key=r[P2@P3]                     */
-#define OP_DeferredSeek  143 /* synopsis: Move P3 to P1.rowid if needed    */
-#define OP_IdxRowid      144 /* synopsis: r[P2]=rowid                      */
-#define OP_FinishSeek    145
-#define OP_Destroy       146
-#define OP_Clear         147
-#define OP_ResetSorter   148
-#define OP_CreateBtree   149 /* synopsis: r[P2]=root iDb=P1 flags=P3       */
-#define OP_SqlExec       150
-#define OP_ParseSchema   151
-#define OP_LoadAnalysis  152
-#define OP_DropTable     153
-#define OP_Real          154 /* same as TK_FLOAT, synopsis: r[P2]=P4       */
-#define OP_DropIndex     155
-#define OP_DropTrigger   156
-#define OP_IntegrityCk   157
-#define OP_RowSetAdd     158 /* synopsis: rowset(P1)=r[P2]                 */
-#define OP_Param         159
-#define OP_FkCounter     160 /* synopsis: fkctr[P1]+=P2                    */
-#define OP_MemMax        161 /* synopsis: r[P1]=max(r[P1],r[P2])           */
-#define OP_OffsetLimit   162 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
-#define OP_AggInverse    163 /* synopsis: accum=r[P3] inverse(r[P2@P5])    */
-#define OP_AggStep       164 /* synopsis: accum=r[P3] step(r[P2@P5])       */
-#define OP_AggStep1      165 /* synopsis: accum=r[P3] step(r[P2@P5])       */
-#define OP_AggValue      166 /* synopsis: r[P3]=value N=P2                 */
-#define OP_AggFinal      167 /* synopsis: accum=r[P1] N=P2                 */
-#define OP_Expire        168
-#define OP_CursorLock    169
-#define OP_CursorUnlock  170
-#define OP_TableLock     171 /* synopsis: iDb=P1 root=P2 write=P3          */
-#define OP_VBegin        172
-#define OP_VCreate       173
-#define OP_VDestroy      174
-#define OP_VOpen         175
-#define OP_VCheck        176
-#define OP_VInitIn       177 /* synopsis: r[P2]=ValueList(P1,P3)           */
-#define OP_VColumn       178 /* synopsis: r[P3]=vcolumn(P2)                */
-#define OP_VRename       179
-#define OP_Pagecount     180
-#define OP_MaxPgcnt      181
-#define OP_ClrSubtype    182 /* synopsis: r[P1].subtype = 0                */
-#define OP_GetSubtype    183 /* synopsis: r[P2] = r[P1].subtype            */
-#define OP_SetSubtype    184 /* synopsis: r[P2].subtype = r[P1]            */
-#define OP_FilterAdd     185 /* synopsis: filter(P1) += key(P3@P4)         */
-#define OP_Trace         186
-#define OP_CursorHint    187
-#define OP_ReleaseReg    188 /* synopsis: release r[P1@P2] mask P3         */
-#define OP_Noop          189
-#define OP_Explain       190
-#define OP_Abortable     191
-
-/* 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_JUMP0       0x80  /* jump0:  P2 might be zero */
-#define OPFLG_INITIALIZER {\
-/*   0 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x41, 0x00,\
-/*   8 */ 0x81, 0x01, 0x01, 0x81, 0x83, 0x83, 0x01, 0x01,\
-/*  16 */ 0x03, 0x03, 0x01, 0x12, 0x01, 0xc9, 0xc9, 0xc9,\
-/*  24 */ 0xc9, 0x01, 0x49, 0x49, 0x49, 0x49, 0xc9, 0x49,\
-/*  32 */ 0xc1, 0x01, 0x41, 0x41, 0xc1, 0x01, 0x01, 0x41,\
-/*  40 */ 0x41, 0x41, 0x41, 0x26, 0x26, 0x41, 0x41, 0x09,\
-/*  48 */ 0x23, 0x0b, 0x81, 0x03, 0x03, 0x0b, 0x0b, 0x0b,\
-/*  56 */ 0x0b, 0x0b, 0x0b, 0x01, 0x01, 0x03, 0x03, 0x03,\
-/*  64 */ 0x01, 0x41, 0x01, 0x00, 0x00, 0x02, 0x02, 0x08,\
-/*  72 */ 0x00, 0x10, 0x10, 0x10, 0x00, 0x10, 0x00, 0x10,\
-/*  80 */ 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00,\
-/*  88 */ 0x02, 0x02, 0x02, 0x00, 0x00, 0x12, 0x1e, 0x20,\
-/*  96 */ 0x40, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x26,\
-/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,\
-/* 112 */ 0x26, 0x40, 0x40, 0x12, 0x00, 0x40, 0x10, 0x40,\
-/* 120 */ 0x40, 0x00, 0x00, 0x00, 0x40, 0x00, 0x40, 0x40,\
-/* 128 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,\
-/* 136 */ 0x00, 0x50, 0x00, 0x40, 0x04, 0x04, 0x00, 0x40,\
-/* 144 */ 0x50, 0x40, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00,\
-/* 152 */ 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x06, 0x10,\
-/* 160 */ 0x00, 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00,\
-/* 168 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,\
-/* 176 */ 0x10, 0x50, 0x40, 0x00, 0x10, 0x10, 0x02, 0x12,\
-/* 184 */ 0x12, 0x00, 0x00, 0x00, 0x00, 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  66  /* 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     0x3f  /* 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*);
-#ifdef SQLITE_ENABLE_PERCENTILE
-SQLITE_PRIVATE   const char *sqlite3VdbeFuncName(const sqlite3_context*);
-#endif
-
-SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(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 void sqlite3MemSetArrayInt64(sqlite3_value *aMem, int iIdx, i64 val);
-
-#ifndef SQLITE_OMIT_DATETIME_FUNCS
-SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context*);
-#endif
-#ifdef SQLITE_ENABLE_BYTECODE_VTAB
-SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3*);
-#endif
-
-/* Use SQLITE_ENABLE_EXPLAIN_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 amalgamation 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 distinguishing 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 of 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 */
-#ifdef SQLITE_CHECK_PAGES
-  u64 pageHash;                  /* Hash of page content */
-#endif
-  Pgno pgno;                     /* Page number for this page */
-  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 historical 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 database (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_PARSER_DEPTH+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 previously 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 lookaside */
-#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)
-
-/*
-** typedef for the authorization callback function.
-*/
-typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*,
-                             const char*);
-
-#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 */
-  u8 nFpDigit;                  /* Significant digits to keep on double->text */
-  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 : 2; /* 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 */
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  int setlkTimeout;             /* Blocking lock timeout, in msec. -1 -> inf. */
-  int setlkFlags;               /* Flags passed to setlk_timeout() */
-#endif
-  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() */
-  DbClientData *pDbData;        /* sqlite3_set_clientdata() content */
-  u64 nSpill;                   /* TEMP content spilled to disk */
-#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
-};
-
-/*
-** 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 */
-#define SQLITE_FkNoAction     HI(0x00008) /* Treat all FK as NO ACTION */
-#define SQLITE_AttachCreate   HI(0x00010) /* ATTACH allowed to create new dbs */
-#define SQLITE_AttachWrite    HI(0x00020) /* ATTACH allowed to open for write */
-#define SQLITE_Comments       HI(0x00040) /* Enable SQL comments */
-
-/* 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 /* WHERE-clause push-down opt */
-#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_OnePass        0x08000000 /* Single-pass DELETE and UPDATE */
-#define SQLITE_OrderBySubq    0x10000000 /* ORDER BY in subquery helps outer */
-#define SQLITE_StarQuery      0x20000000 /* Heurists for star queries */
-#define SQLITE_ExistsToJoin   0x40000000 /* The EXISTS-to-JOIN optimization */
-#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 {
-  i16 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_BYTELEN     ==  OPFLAG_BYTELENARG
-**     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 that 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_BYTELEN  0x00c0 /* Built-in octet_length() 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 */
-#define SQLITE_FUNC_RUNONLY  0x8000 /* Cannot be used by valueFromFunction */
-#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 */
-/* SQLITE_SUBTYPE            0x00100000 // Consumer of subtypes */
-#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 */
-/*  SQLITE_RESULT_SUBTYPE    0x01000000 // Generator of subtypes */
-#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, bUseCache, bWS, bRS, bJsonB, iArg, xFunc) \
-  {nArg, SQLITE_FUNC_BUILTIN|SQLITE_DETERMINISTIC|SQLITE_FUNC_CONSTANT|\
-   SQLITE_UTF8|((bUseCache)*SQLITE_FUNC_RUNONLY)|\
-   ((bRS)*SQLITE_SUBTYPE)|((bWS)*SQLITE_RESULT_SUBTYPE), \
-   SQLITE_INT_TO_PTR(iArg|((bJsonB)*JSON_BLOB)),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, {0} }
-#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 SQLITE_AFF_DEFER    0x58  /* 'X'  - defer computation until later */
-
-#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 */
-  u8 aHx[16];          /* Column aHt[K%sizeof(aHt)] might have hash K */
-};
-
-/*
-** 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_MaybeReanalyze 0x00000100 /* Maybe run ANALYZE on this table */
-#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 */
-#define TF_Imposter       0x00020000 /* An imposter table */
-
-/*
-** 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)
-
-/* Macro is true if the SQLITE_ALLOW_ROWID_IN_VIEW (mis-)feature is
-** available.  By default, this macro is false
-*/
-#ifndef SQLITE_ALLOW_ROWID_IN_VIEW
-# define ViewCanHaveRowid     0
-#else
-# define ViewCanHaveRowid     (sqlite3Config.mNoVisibleRowid==0)
-#endif
-
-/*
-** 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[FLEXARRAY];      /* One entry for each of nCol columns */
-};
-
-/* The size (in bytes) of an FKey object holding N columns.  The answer
-** does NOT include space to hold the zTo name. */
-#define SZ_FKEY(N)  (offsetof(FKey,aCol)+(N)*sizeof(struct sColMap))
-
-/*
-** 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 algorithm 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.
-**
-** The aSortOrder[] and aColl[] arrays have nAllField slots each. There
-** are nKeyField slots for the columns of an index then extra slots
-** for the rowid or key at the end.  The aSortOrder array is located after
-** the aColl[] array.
-**
-** If SQLITE_ENABLE_PREUPDATE_HOOK is defined, then aSortFlags might be NULL
-** to indicate that this object is for use by a preupdate hook.  When aSortFlags
-** is NULL, then nAllField is uninitialized and no space is allocated for
-** aColl[], so those fields may not be used.
-*/
-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[FLEXARRAY]; /* Collating sequence for each term of the key */
-};
-
-/* The size (in bytes) of a KeyInfo object with up to N fields.  This includes
-** the main body of the KeyInfo object and the aColl[] array of N elements,
-** but does not count the memory used to hold aSortFlags[]. */
-#define SZ_KEYINFO(N)  (offsetof(KeyInfo,aColl) + (N)*sizeof(CollSeq*))
-
-/* The size of a bare KeyInfo with no aColl[] entries */
-#if FLEXARRAY+1 > 1
-# define SZ_KEYINFO_0   offsetof(KeyInfo,aColl)
-#else
-# define SZ_KEYINFO_0   sizeof(KeyInfo)
-#endif
-
-/*
-** 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 closest to the key described by this object.  This object might hold
-** just a prefix of the key.  The number of fields is given by 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 nField elements) 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;  /* Comparison info for the index that is unpacked */
-  Mem *aMem;          /* Values for columns of the index */
-  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;             /* Nr columns in btree. Can be 2*Table.nCol */
-  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 */
-  u32 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 */
-    int iColumn;             /* Column number within the source table */
-    int 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 */
-    int iOBTab;              /* Ephemeral table to implement ORDER BY */
-    u8 bOBPayload;           /* iOBTab has payload columns separate from key */
-    u8 bOBUnique;            /* Enforce uniqueness on iOBTab keys */
-    u8 bUseSubtype;          /* Transfer subtype info through sorter */
-  } *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.
-*/
-#ifndef NDEBUG
-#define AggInfoColumnReg(A,I)  (assert((A)->iFirstReg),(A)->iFirstReg+(I))
-#define AggInfoFuncReg(A,I)    \
-                      (assert((A)->iFirstReg),(A)->iFirstReg+(A)->nColumn+(I))
-#else
-#define AggInfoColumnReg(A,I)  ((A)->iFirstReg+(I))
-#define AggInfoFuncReg(A,I)    \
-                      ((A)->iFirstReg+(A)->nColumn+(I))
-#endif
-
-/*
-** 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 "<lhs> IN (<y>, <z>...)".
-** Expr.x.pSelect is used if the expression is a sub-select or an expression of
-** the form "<lhs> 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: ephemeral 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 */
-    int nReg;              /* TK_NULLS: Number of registers to NULL out */
-    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 */
-#define EP_FullSize   0x020000 /* Expr structure must remain full sized */
-#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 */
-#define EP_SubtArg  0x80000000 /* Is argument to SQLITE_SUBTYPE function */
-
-/* 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&(u32)(P))!=0)
-#define ExprHasAllProperty(E,P)  (((E)->flags&(u32)(P))==(u32)(P))
-#define ExprSetProperty(E,P)     (E)->flags|=(u32)(P)
-#define ExprClearProperty(E,P)   (E)->flags&=~(u32)(P)
-#define ExprAlwaysTrue(E)   (((E)->flags&(EP_OuterON|EP_IsTrue))==EP_IsTrue)
-#define ExprAlwaysFalse(E)  (((E)->flags&(EP_OuterON|EP_IsFalse))==EP_IsFalse)
-#define ExprIsFullSize(E)   (((E)->flags&(EP_Reduced|EP_TokenOnly))==0)
-
-/* 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 ExprUseWOfst(E)     (((E)->flags&(EP_InnerON|EP_OuterON))==0)
-#define ExprUseWJoin(E)     (((E)->flags&(EP_InnerON|EP_OuterON))!=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[FLEXARRAY];          /* One slot for each expression in the list */
-};
-
-/* The size (in bytes) of an ExprList object that is big enough to hold
-** as many as N expressions. */
-#define SZ_EXPRLIST(N)  \
-             (offsetof(ExprList,a) + (N)*sizeof(struct ExprList_item))
-
-/*
-** 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 */
-#define ENAME_ROWID 3       /* "DB.TABLE._rowid_" for * expansion of rowid */
-
-/*
-** 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 */
-  struct IdList_item {
-    char *zName;      /* Name of the identifier */
-  } a[FLEXARRAY];
-};
-
-/* The size (in bytes) of an IdList object that can hold up to N IDs. */
-#define SZ_IDLIST(N)  (offsetof(IdList,a)+(N)*sizeof(struct IdList_item))
-
-/*
-** 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 */
-
-/*
-** Details of the implementation of a subquery.
-*/
-struct Subquery {
-  Select *pSelect;  /* A SELECT statement used in place of a table name */
-  int addrFillSub;  /* Address of subroutine to initialize a subquery */
-  int regReturn;    /* Register holding return address of addrFillSub */
-  int regResult;    /* Registers holding results of a co-routine */
-};
-
-/*
-** 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.
-**
-** Aggressive use of "union" helps keep the size of the object small.  This
-** has been shown to boost performance, in addition to saving memory.
-** Access to union elements is gated by the following rules which should
-** always be checked, either by an if-statement or by an assert().
-**
-**    Field              Only access if this is true
-**    ---------------    -----------------------------------
-**    u1.zIndexedBy      fg.isIndexedBy
-**    u1.pFuncArg        fg.isTabFunc
-**    u1.nRow            !fg.isTabFunc  && !fg.isIndexedBy
-**
-**    u2.pIBIndex        fg.isIndexedBy
-**    u2.pCteUse         fg.isCte
-**
-**    u3.pOn             !fg.isUsing
-**    u3.pUsing          fg.isUsing
-**
-**    u4.zDatabase       !fg.fixedSchema && !fg.isSubquery
-**    u4.pSchema         fg.fixedSchema
-**    u4.pSubq           fg.isSubquery
-**
-** See also the sqlite3SrcListDelete() routine for assert() statements that
-** check invariants on the fields of this object, especially the flags
-** inside the fg struct.
-*/
-struct SrcItem {
-  char *zName;      /* Name of the table */
-  char *zAlias;     /* The "B" part of a "A AS B" phrase.  zName is the "A" */
-  Table *pSTab;     /* Table object for zName. Mnemonic: Srcitem-TABle */
-  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 isSubquery :1;    /* True if this term is a subquery */
-    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 synthesized from NATURAL */
-    unsigned isNestedFrom :1;  /* pSelect is a SF_NestedFrom subquery */
-    unsigned rowidUsed :1;     /* The ROWID of this table is referenced */
-    unsigned fixedSchema :1;   /* Uses u4.pSchema, not u4.zDatabase */
-    unsigned hadSchema :1;     /* Had u4.zDatabase before u4.pSchema */
-    unsigned fromExists :1;    /* Comes from WHERE EXISTS(...) */
-  } fg;
-  int iCursor;      /* The VDBE cursor number used to access this table */
-  Bitmask colUsed;  /* Bit N set if column N used. Details above for N>62 */
-  union {
-    char *zIndexedBy;    /* Identifier from "INDEXED BY <zIndex>" clause */
-    ExprList *pFuncArg;  /* Arguments to table-valued-function */
-    u32 nRow;            /* Number of rows in a VALUES clause */
-  } u1;
-  union {
-    Index *pIBIndex;  /* Index structure corresponding to u1.zIndexedBy */
-    CteUse *pCteUse;  /* CTE Usage info when fg.isCte is true */
-  } u2;
-  union {
-    Expr *pOn;        /* fg.isUsing==0 =>  The ON clause of a join */
-    IdList *pUsing;   /* fg.isUsing==1 =>  The USING clause of a join */
-  } u3;
-  union {
-    Schema *pSchema;  /* Schema to which this item is fixed */
-    char *zDatabase;  /* Name of database holding this table */
-    Subquery *pSubq;  /* Description of a subquery */
-  } u4;
-};
-
-/*
-** 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[FLEXARRAY]; /* One entry for each identifier on the list */
-};
-
-/* Size (in bytes) of a SrcList object that can hold as many as N
-** SrcItem objects. */
-#define SZ_SRCLIST(N) (offsetof(SrcList,a)+(N)*sizeof(SrcItem))
-
-/* Size (in bytes( of a SrcList object that holds 1 SrcItem.  This is a
-** special case of SZ_SRCITEM(1) that comes up often. */
-#define SZ_SRCLIST_1  (offsetof(SrcList,a)+sizeof(SrcItem))
-
-/*
-** 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 */
-#define WHERE_KEEP_ALL_JOINS   0x2000 /* Do not do the omit-noop-join opt */
-#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 */
-  u32 nNestedSelect;   /* Number of nested selects using this NC */
-  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 */
-/*                   0x002000 // available for reuse */
-#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_Where     0x100000 /* Processing WHERE clause of a SELECT */
-#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 */
-  u8 isDup;                 /* True if 2nd or later with same pUpsertIdx */
-  /* 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.
-*/
-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 */
-  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_ClonedRhsIn   0x0000020 /* Cloned RHS of an IN operator */
-#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 */
-/*                       0x0008000 // available for reuse */
-#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 */
-/*                       0x0400000 // available for reuse */
-#define SF_UFSrcCheck    0x0800000 /* Check pSrc as required by UPDATE...FROM */
-#define SF_PushDown      0x1000000 /* Modified by WHERE-clause 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 */
-#define SF_Correlated   0x20000000 /* True if references the outer context */
-#define SF_OnToWhere    0x40000000 /* One or more ON clauses moved to WHERE */
-
-/* True if SrcItem X is a subquery that has SF_NestedFrom */
-#define IsNestedFrom(X) \
-   ((X)->fg.isSubquery && \
-    ((X)->u4.pSubq->pSelect->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_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.  if pDest->iSDParm2 is positive, then it is
-**                     a register holding a Bloom filter for the IN operator
-**                     that should be populated in addition to the
-**                     pDest->iSDParm table.  This SRT is 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_Exists       1  /* Store 1 if the result is not empty */
-#define SRT_Discard      2  /* Do not save the results anywhere */
-#define SRT_DistFifo     3  /* Like SRT_Fifo, but unique results only */
-#define SRT_DistQueue    4  /* 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        5  /* Store result in an queue */
-#define SRT_Fifo         6  /* 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       7  /* Output each row of result */
-#define SRT_Mem          8  /* Store result in a memory cell */
-#define SRT_Set          9  /* Store results as keys in an index */
-#define SRT_EphemTab    10  /* Create transient tab and store like SRT_Table */
-#define SRT_Coroutine   11  /* Generate a single row of result */
-#define SRT_Table       12  /* Store result as data with an automatic rowid */
-#define SRT_Upfrom      13  /* 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 */
-  LogEst nQueryLoop;   /* Est number of iterations of a query (10*log2(N)) */
-  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 disableLookaside; /* Number of times lookaside has been disabled */
-  u8 prepFlags;        /* SQLITE_PREPARE_* flags */
-  u8 withinRJSubrtn;   /* Nesting level for RIGHT JOIN body subroutines */
-  u8 mSubrtnSig;       /* mini Bloom filter on available SubrtnSig.selId */
-  u8 eTriggerOp;       /* TK_UPDATE, TK_INSERT or TK_DELETE */
-  u8 eOrconf;          /* Default ON CONFLICT policy for trigger steps */
-#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 */
-  u8 isCreate;         /* CREATE TABLE, INDEX, or VIEW (but not TRIGGER)
-                       ** and ALTER TABLE ADD COLUMN. */
-#endif
-  bft disableTriggers:1; /* True to disable triggers */
-  bft mayAbort :1;     /* True if statement may throw an ABORT exception */
-  bft hasCompound :1;  /* Need to invoke convertCompoundSelectToSubquery() */
-  bft bReturning :1;   /* Coding a RETURNING trigger */
-  bft bHasExists :1;   /* Has a correlated "EXISTS (SELECT ....)" expression */
-  bft colNamesSet :1;  /* TRUE after OP_ColumnName has been issued to pVdbe */
-  bft bHasWith :1;     /* True if statement contains WITH */
-  bft okConstFactor:1; /* OK to factor out constants */
-  bft checkSchema :1;  /* Causes schema cookie check after an error */
-  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 */
-  IndexedExpr *pIdxPartExpr; /* Exprs constrained by index WHERE clauses */
-  yDbMask writeMask;   /* Start a write transaction on these databases */
-  yDbMask cookieMask;  /* Bitmask of schema verified databases */
-  int nMaxArg;         /* Max args to xUpdate and xFilter vtab methods */
-  int nSelect;         /* Number of SELECT stmts. Counter for Select.selId */
-#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
-  u32 nProgressSteps;  /* xProgress steps taken during sqlite3_prepare() */
-#endif
-#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 */
-
-  /**************************************************************************
-  ** 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 */
-  u32 oldmask;            /* Mask of old.* columns referenced */
-  u32 newmask;            /* Mask of new.* columns referenced */
-  union {
-    struct {  /* These fields available when isCreate is true */
-      int addrCrTab;        /* Address of OP_CreateBtree on CREATE TABLE */
-      int regRowid;         /* Register holding rowid of CREATE TABLE entry */
-      int regRoot;          /* Register holding root page for new objects */
-      Token constraintName; /* Name of the constraint currently being parsed */
-    } cr;
-    struct {  /* These fields available to all other statements */
-      Returning *pReturning; /* The RETURNING clause */
-    } d;
-  } u1;
-
-  /************************************************************************
-  ** 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 */
-  int addrExplain;          /* Address of current OP_Explain opcode */
-  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_BYTELENARG    0xc0    /* OP_Column only for octet_length() */
-#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 <column-list> trigger,
-                             the <column-list> 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.
-** pSrc      -> Table to insert into.
-** pIdList   -> If this is an INSERT INTO ... (<column-names>) VALUES ...
-**              statement, then this stores the column-names to be
-**              inserted into.
-** pUpsert   -> The ON CONFLICT clauses for an Upsert
-**
-** (op == TK_DELETE)
-** pSrc      -> Table to delete from
-** pWhere    -> The WHERE clause of the DELETE statement if one is specified.
-**              Otherwise NULL.
-**
-** (op == TK_UPDATE)
-** pSrc      -> Table to update, followed by any FROM clause tables.
-** 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 ... */
-  SrcList *pSrc;       /* Table to insert/update/delete */
-  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 */
-  char zName[40];       /* Name of trigger: "sqlite_returning_%p" */
-};
-
-/*
-** An object 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 zText is allocated space */
-
-#define isMalloced(X)  (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
-
-/*
-** The following object is the header for an "RCStr" or "reference-counted
-** string".  An RCStr is passed around and used like any other char*
-** that has been dynamically allocated.  The important interface
-** differences:
-**
-**   1.  RCStr strings are reference counted.  They are deallocated
-**       when the reference count reaches zero.
-**
-**   2.  Use sqlite3RCStrUnref() to free an RCStr string rather than
-**       sqlite3_free()
-**
-**   3.  Make a (read-only) copy of a read-only RCStr string using
-**       sqlite3RCStrRef().
-**
-** "String" is in the name, but an RCStr object can also be used to hold
-** binary data.
-*/
-struct RCStr {
-  u64 nRCRef;            /* Number of references */
-  /* Total structure size should be a multiple of 8 bytes for alignment */
-};
-
-/*
-** 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     0x0007  /* 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 */
-#define INITFLAG_AlterDropCons 0x0004  /* 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
-** optimal 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 */
-#ifdef SQLITE_DEBUG
-  u8 bJsonSelfcheck;                /* Double-check JSON parsing */
-#endif
-  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
-#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
-  u32 mNoVisibleRowid;              /* TF_NoVisibleRowid if the ROWID_IN_VIEW
-                                    ** feature is disabled.  0 if rowids can
-                                    ** occur in views. */
-#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 */
-  u16 mWFlags;                              /* Use-dependent flags */
-  union {                                   /* Extra data for callback */
-    NameContext *pNC;                         /* Naming context */
-    int n;                                    /* A counter */
-    int iCur;                                 /* A cursor number */
-    int sz;                                   /* String literal length */
-    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() */
-    struct CheckOnCtx *pCheckOnCtx;           /* See selectCheckOnClauses() */
-  } 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 sqlite3WalkExprNN(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[FLEXARRAY];       /* For each CTE in the WITH clause.... */
-};
-
-/* The size (in bytes) of a With object that can hold as many
-** as N different CTEs. */
-#define SZ_WITH(N)  (offsetof(With,a) + (N)*sizeof(Cte))
-
-/*
-** 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 */
-};
-
-
-/* Client data associated with sqlite3_set_clientdata() and
-** sqlite3_get_clientdata().
-*/
-struct DbClientData {
-  DbClientData *pNext;        /* Next in a linked list */
-  void *pData;                /* The data */
-  void (*xDestructor)(void*); /* Destructor.  Might be NULL */
-  char zName[FLEXARRAY];      /* Name of this client data. MUST BE LAST */
-};
-
-/* The size (in bytes) of a DbClientData object that can has a name
-** that is N bytes long, including the zero-terminator. */
-#define SZ_DBCLIENTDATA(N) (offsetof(DbClientData,zName)+(N))
-
-#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 "<expr> PRECEDING" */
-  Expr *pEnd;             /* Expression for "<expr> 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 */
-};
-
-SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow);
-SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal);
-
-#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 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);
-
-
-/* The SQLITE_THREAD_MISUSE_WARNINGS compile-time option used to be called
-** SQLITE_ENABLE_MULTITHREADED_CHECKS.  Keep that older macro for backwards
-** compatibility, at least for a while... */
-#ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS
-# define SQLITE_THREAD_MISUSE_WARNINGS 1
-#endif
-
-/* SQLITE_THREAD_MISUSE_ABORT implies SQLITE_THREAD_MISUSE_WARNINGS */
-#ifdef SQLITE_THREAD_MISUSE_ABORT
-# define SQLITE_THREAD_MISUSE_WARNINGS 1
-#endif
-
-#if defined(SQLITE_THREAD_MISUSE_WARNINGS) && !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)
-# define IsOvfl(X) (((X)&EXP754)==EXP754)
-SQLITE_PRIVATE   int sqlite3IsNaN(double);
-SQLITE_PRIVATE   int sqlite3IsOverflow(double);
-#else
-# define IsNaN(X)             0
-# define sqlite3IsNaN(X)      0
-# define sqlite3IsOVerflow(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 */
-};
-
-/*
-** Maxium number of base-10 digits in an unsigned 64-bit integer
-*/
-#define SQLITE_U64_DIGITS 20
-
-/*
-** An instance of this object receives the decoding of a floating point
-** value into an approximate decimal representation.
-*/
-struct FpDecode {
-  int n;                           /* Significant digits in the decode */
-  int iDP;                         /* Location of the decimal point */
-  char *z;                         /* Start of significant digits */
-  char zBuf[SQLITE_U64_DIGITS+1];  /* Storage for significant digits */
-  char sign;                       /* '+' or '-' */
-  char isSpecial;                  /* 1: Infinity  2: NaN */
-};
-
-SQLITE_PRIVATE void sqlite3FpDecode(FpDecode*,double,int,int);
-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
-SQLITE_PRIVATE   void sqlite3ShowBitvec(Bitvec*);
-#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 sqlite3DequoteNumber(Parse*, Expr*);
-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 Expr *sqlite3ExprInt32(sqlite3*,int);
-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 sqlite3ExprAddFunctionOrderBy(Parse*,Expr*,ExprList*);
-SQLITE_PRIVATE void sqlite3ExprOrderByAggregateError(Parse*,Expr*);
-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 sqlite3ExprDeleteGeneric(sqlite3*,void*);
-SQLITE_PRIVATE int 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 void sqlite3ExprListDeleteGeneric(sqlite3*,void*);
-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 int sqlite3TableColumnToIndex(Index*, int);
-#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 **);
-#define sqlite3CodecQueryParameters(A,B,C) 0
-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 sqlite3DeleteTableGeneric(sqlite3*, void*);
-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 void sqlite3SubqueryDelete(sqlite3*,Subquery*);
-SQLITE_PRIVATE Select *sqlite3SubqueryDetach(sqlite3*,SrcItem*);
-SQLITE_PRIVATE int sqlite3SrcItemAttachSubquery(Parse*, SrcItem*, Select*, int);
-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*,int,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 void sqlite3SelectDeleteGeneric(sqlite3*,void*);
-SQLITE_PRIVATE void sqlite3SelectCheckOnClauses(Parse *pParse, Select *pSelect);
-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 sqlite3ExprToRegister(Expr *pExpr, int iReg);
-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 void sqlite3ExprNullRegisterRange(Parse*, int, 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,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(Parse*,Expr*);
-SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*, u8);
-SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*);
-SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint(Expr*,const SrcList*,int,int);
-#ifdef SQLITE_ENABLE_CURSOR_HINTS
-SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr*);
-#endif
-SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr*, int*, Parse*);
-SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*);
-SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char);
-SQLITE_PRIVATE int sqlite3ExprIsLikeOperator(const Expr*);
-SQLITE_PRIVATE int sqlite3IsRowid(const char*);
-SQLITE_PRIVATE const char *sqlite3RowidAlias(Table *pTab);
-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*,int);
-SQLITE_PRIVATE int sqlite3AppendOneUtf8Character(char*, u32);
-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   Module *sqlite3JsonVtabRegister(sqlite3*,const char*);
-#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_VIRTUALTABLE) && defined(SQLITE_ENABLE_CARRAY)
-SQLITE_PRIVATE   Module *sqlite3CarrayRegister(sqlite3*);
-#endif
-
-#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*,SrcList*, IdList*,
-                                        Select*,u8,Upsert*,
-                                        const char*,const char*);
-SQLITE_PRIVATE   TriggerStep *sqlite3TriggerUpdateStep(Parse*,SrcList*,SrcList*,ExprList*,
-                                        Expr*, u8, const char*,const char*);
-SQLITE_PRIVATE   TriggerStep *sqlite3TriggerDeleteStep(Parse*,SrcList*, 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);
-# 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
-#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*);
-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 nByte, int nChar);
-#endif
-SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
-SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8**);
-SQLITE_PRIVATE int sqlite3Utf8ReadLimited(const u8*, int, u32*);
-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);
-#if !defined(SQLITE_OMIT_BLOB_LITERAL)
-SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
-#endif
-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 sqlite3ValueIsOfClass(const sqlite3_value*, void(*)(void*));
-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 void sqlite3AlterDropConstraint(Parse*,SrcList*,Token*,Token*);
-SQLITE_PRIVATE void sqlite3AlterAddConstraint(Parse*,SrcList*,Token*,Token*,const char*,int);
-SQLITE_PRIVATE void sqlite3AlterSetNotNull(Parse*, SrcList*, Token*, Token*);
-SQLITE_PRIVATE i64 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, 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*,
-  int*
-);
-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 char *sqlite3RCStrRef(char*);
-SQLITE_PRIVATE void sqlite3RCStrUnref(void*);
-SQLITE_PRIVATE char *sqlite3RCStrNew(u64);
-SQLITE_PRIVATE char *sqlite3RCStrResize(char*,u64);
-
-SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int);
-SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum*, i64);
-SQLITE_PRIVATE int sqlite3StrAccumEnlargeIfNeeded(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   void sqlite3WithDeleteGeneric(sqlite3*,void*);
-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*,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 void sqlite3ExprSetErrorOffset(Expr*,int);
-
-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_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_ROWID_IN_VIEW
-  "ALLOW_ROWID_IN_VIEW",
-#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_BUG_COMPATIBLE_20250510
-  "BUG_COMPATIBLE_20250510",
-#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_CARRAY
-  "ENABLE_CARRAY",
-#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_ORDERED_SET_AGGREGATES
-  "ENABLE_ORDERED_SET_AGGREGATES",
-#endif
-#ifdef SQLITE_ENABLE_OVERSIZE_CELL_CHECK
-  "ENABLE_OVERSIZE_CELL_CHECK",
-#endif
-#ifdef SQLITE_ENABLE_PERCENTILE
-  "ENABLE_PERCENTILE",
-#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_SETLK_TIMEOUT
-  "ENABLE_SETLK_TIMEOUT",
-#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_AUTOEXT
-  "EXTRA_AUTOEXT=" CTIMEOPT_VAL(SQLITE_EXTRA_AUTOEXT),
-#endif
-#ifdef SQLITE_EXTRA_IFNULLROW
-  "EXTRA_IFNULLROW",
-#endif
-#ifdef SQLITE_EXTRA_INIT
-  "EXTRA_INIT=" CTIMEOPT_VAL(SQLITE_EXTRA_INIT),
-#endif
-#ifdef SQLITE_EXTRA_INIT_MUTEXED
-  "EXTRA_INIT_MUTEXED=" CTIMEOPT_VAL(SQLITE_EXTRA_INIT_MUTEXED),
-#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
-#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_LEGACY_JSON_VALID
-  "LEGACY_JSON_VALID",
-#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_SEH
-  "OMIT_SEH",
-#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_STRICT_SUBTYPE
-  "STRICT_SUBTYPE",
-#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_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.
-*/
-#ifndef SQLITE_USE_URI
-# define SQLITE_USE_URI 0
-#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 */
-#ifdef SQLITE_DEBUG
-   0,                         /* bJsonSelfcheck */
-#endif
-   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
-#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
-   0,                         /* mNoVisibleRowid.  0 == allow rowid-in-view */
-#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;
-
-/* A cache of large TEXT or BLOB values in a VdbeCursor */
-typedef struct VdbeTxtBlbCache VdbeTxtBlbCache;
-
-/* 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 */
-  Bool colCache:1;        /* pCache pointer is initialized and non-NULL */
-  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
-  VdbeTxtBlbCache *pCache; /* Cache of large TEXT or BLOB values */
-
-  /* Space is allocated for aType to hold at least 2*nField+1 entries:
-  ** nField slots for aType[] and nField+1 array slots for aOffset[] */
-  u32 aType[FLEXARRAY];    /* Type values record decode.  MUST BE LAST */
-};
-
-/*
-** The size (in bytes) of a VdbeCursor object that has an nField value of N
-** or less.  The value of SZ_VDBECURSOR(n) is guaranteed to be a multiple
-** of 8.
-*/
-#define SZ_VDBECURSOR(N) \
-    (ROUND8(offsetof(VdbeCursor,aType)) + ((N)+1)*sizeof(u64))
-
-/* 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
-
-/*
-** Large TEXT or BLOB values can be slow to load, so we want to avoid
-** loading them more than once.  For that reason, large TEXT and BLOB values
-** can be stored in a cache defined by this object, and attached to the
-** VdbeCursor using the pCache field.
-*/
-struct VdbeTxtBlbCache {
-  char *pCValue;        /* A RCStr buffer to hold the value */
-  i64 iOffset;          /* File offset of the row being cached */
-  int iCol;             /* Column for which the cache is valid */
-  u32 cacheStatus;      /* Vdbe.cacheCtr value */
-  u32 colCacheCtr;      /* Column cache counter */
-};
-
-/*
-** 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 */
-  u8  bScopy;         /* The pScopyFrom of some other Mem *might* point here */
-#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.nZero 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 */
-  u16 argc;               /* Number of arguments */
-  sqlite3_value *argv[FLEXARRAY]; /* Argument set */
-};
-
-/*
-** The size (in bytes) of an sqlite3_context object that holds N
-** argv[] arguments.
-*/
-#define SZ_CONTEXT(N)  \
-   (offsetof(sqlite3_context,argv)+(N)*sizeof(sqlite3_value*))
-
-
-/* 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 xUpdate and xFilter vtab methods */
-  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 */
-  int napArg;             /* Size of the apArg[] array */
-#endif
-  u16 nResColumn;         /* Number of columns in one row of the result set */
-  u16 nResAlloc;          /* Column slots allocated to aColName[] */
-  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;          /* 0: normal, 1: EXPLAIN, 2: EXPLAIN QUERY PLAN */
-  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 */
-  bft haveEqpOps:1;       /* Bytecode supports EXPLAIN QUERY PLAN */
-  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 *pKeyinfo;              /* Key information */
-  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 oldipk;                     /* Memory cell holding "old" IPK value */
-  Mem *aNew;                      /* Array of new.* values */
-  Table *pTab;                    /* Schema object being updated */
-  Index *pPk;                     /* PK index if pTab is WITHOUT ROWID */
-  sqlite3_value **apDflt;         /* Array of default values, if required */
-  struct {
-    u8 keyinfoSpace[SZ_KEYINFO_0];  /* Space to hold pKeyinfo[0] content */
-  } uKey;
-};
-
-/*
-** 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 int sqlite3VdbeMemSetText(Mem*, const char*, i64, 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 sqlite3VdbeMemZeroTerminateIfAble(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 sqlite3MemRealValueRC(Mem*, double*);
-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 sqlite3VdbeFindIndexKey(BtCursor*, Index*, UnpackedRecord*, int*, int);
-
-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 sqlite3VdbeCheckFkImmediate(Vdbe*);
-SQLITE_PRIVATE int sqlite3VdbeCheckFkDeferred(Vdbe*);
-#else
-# define sqlite3VdbeCheckFkImmediate(p) 0
-# define sqlite3VdbeCheckFkDeferred(p) 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<ArraySize(wsdStat.nowValue) );
-  assert( op>=0 && op<ArraySize(statMutex) );
-  assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
-                                           : sqlite3MallocMutex()) );
-  return wsdStat.nowValue[op];
-}
-
-/*
-** Add N to the value of a status record.  The caller must hold the
-** appropriate mutex.  (Locking is checked by assert()).
-**
-** The StatusUp() routine can accept positive or negative values for N.
-** The value of N is added to the current status value and the high-water
-** mark is adjusted if necessary.
-**
-** The StatusDown() routine lowers the current value by N.  The highwater
-** mark is unchanged.  N must be non-negative for StatusDown().
-*/
-SQLITE_PRIVATE void sqlite3StatusUp(int op, int N){
-  wsdStatInit;
-  assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
-  assert( op>=0 && op<ArraySize(statMutex) );
-  assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
-                                           : sqlite3MallocMutex()) );
-  wsdStat.nowValue[op] += N;
-  if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
-    wsdStat.mxValue[op] = wsdStat.nowValue[op];
-  }
-}
-SQLITE_PRIVATE void sqlite3StatusDown(int op, int N){
-  wsdStatInit;
-  assert( N>=0 );
-  assert( op>=0 && op<ArraySize(statMutex) );
-  assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
-                                           : sqlite3MallocMutex()) );
-  assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
-  wsdStat.nowValue[op] -= N;
-}
-
-/*
-** Adjust the highwater mark if necessary.
-** The caller must hold the appropriate mutex.
-*/
-SQLITE_PRIVATE void sqlite3StatusHighwater(int op, int X){
-  sqlite3StatValueType newValue;
-  wsdStatInit;
-  assert( X>=0 );
-  newValue = (sqlite3StatValueType)X;
-  assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
-  assert( op>=0 && op<ArraySize(statMutex) );
-  assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
-                                           : sqlite3MallocMutex()) );
-  assert( op==SQLITE_STATUS_MALLOC_SIZE
-          || op==SQLITE_STATUS_PAGECACHE_SIZE
-          || op==SQLITE_STATUS_PARSER_STACK );
-  if( newValue>wsdStat.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 */
-  assert( db->lookaside.nSlot >= nInit+nFree );
-  if( pHighwater ) *pHighwater = (int)(db->lookaside.nSlot - nInit);
-  return (int)(db->lookaside.nSlot - (nInit+nFree));
-}
-
-/*
-** Query status information for a single database connection
-*/
-SQLITE_API int sqlite3_db_status64(
-  sqlite3 *db,             /* The database connection whose status is desired */
-  int op,                  /* Status verb */
-  sqlite3_int64 *pCurrent, /* Write current value here */
-  sqlite3_int64 *pHighwtr, /* 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|| pHighwtr==0 ){
-    return SQLITE_MISUSE_BKPT;
-  }
-#endif
-  sqlite3_mutex_enter(db->mutex);
-  switch( op ){
-    case SQLITE_DBSTATUS_LOOKASIDE_USED: {
-      int H = 0;
-      *pCurrent = sqlite3LookasideUsed(db, &H);
-      *pHighwtr = H;
-      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;
-      *pHighwtr = 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: {
-      sqlite3_int64 totalUsed = 0;
-      int i;
-      sqlite3BtreeEnterAll(db);
-      for(i=0; i<db->nDb; 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;
-      *pHighwtr = 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.  *pHighwtr 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; i<db->nDb; 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);
-
-      *pHighwtr = 0;
-      *pCurrent = nByte;
-      break;
-    }
-
-    /*
-    ** *pCurrent gets an accurate estimate of the amount of memory used
-    ** to store all prepared statements.
-    ** *pHighwtr 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;
-
-      *pHighwtr = 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. *pHighwtr 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;
-      u64 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; i<db->nDb; i++){
-        if( db->aDb[i].pBt ){
-          Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
-          sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet);
-        }
-      }
-      *pHighwtr = 0; /* IMP: R-42420-56072 */
-                       /* IMP: R-54100-20147 */
-                       /* IMP: R-29431-39229 */
-      *pCurrent = nRet;
-      break;
-    }
-
-    /* Set *pCurrent to the number of bytes that the db database connection
-    ** has spilled to the filesystem in temporary files that could have been
-    ** stored in memory, had sufficient memory been available.
-    ** The *pHighwater is always set to zero.
-    */
-    case SQLITE_DBSTATUS_TEMPBUF_SPILL: {
-      u64 nRet = 0;
-      if( db->aDb[1].pBt ){
-        Pager *pPager = sqlite3BtreePager(db->aDb[1].pBt);
-        sqlite3PagerCacheStat(pPager, SQLITE_DBSTATUS_CACHE_WRITE,
-                              resetFlag, &nRet);
-        nRet *= sqlite3BtreeGetPageSize(db->aDb[1].pBt);
-      }
-      nRet += db->nSpill;
-      if( resetFlag ) db->nSpill = 0;
-      *pHighwtr = 0;
-      *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 *pHighwtr is always set to zero.
-    */
-    case SQLITE_DBSTATUS_DEFERRED_FKS: {
-      *pHighwtr = 0;  /* IMP: R-11967-56545 */
-      *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0;
-      break;
-    }
-
-    default: {
-      rc = SQLITE_ERROR;
-    }
-  }
-  sqlite3_mutex_leave(db->mutex);
-  return rc;
-}
-
-/*
-** 32-bit variant of sqlite3_db_status64()
-*/
-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 *pHighwtr,           /* Write high-water mark here */
-  int resetFlag            /* Reset high-water mark if true */
-){
-  sqlite3_int64 C = 0, H = 0;
-  int rc;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwtr==0 ){
-    return SQLITE_MISUSE_BKPT;
-  }
-#endif
-  rc = sqlite3_db_status64(db, op, &C, &H, resetFlag);
-  if( rc==0 ){
-    *pCurrent = C & 0x7fffffff;
-    *pHighwtr = H & 0x7fffffff;
-  }
-  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 <stdlib.h> */
-/* #include <assert.h> */
-#include <time.h>
-
-#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 validYMD;      /* True (1) if Y,M,D are valid */
-  char validHMS;      /* True (1) if h,m,s are valid */
-  char nFloor;            /* Days to implement "floor" */
-  unsigned rawS      : 1; /* Raw numeric value stored in s */
-  unsigned isError   : 1; /* An overflow has occurred */
-  unsigned useSubsec : 1; /* Display subsecond precision */
-  unsigned isUtc     : 1; /* Time is known to be UTC */
-  unsigned isLocal   : 1; /* Time is known to be localtime */
-};
-
-
-/*
-** 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, 14712 };
-  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++;
-    p->isLocal = 0;
-    p->isUtc = 1;
-    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);
-  if( p->tz==0 ){   /* Forum post 2025-09-17T10:12:14z */
-    p->isLocal = 0;
-    p->isUtc = 1;
-  }
-zulu_time:
-  while( sqlite3Isspace(*zDate) ){ zDate++; }
-  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;
-      /* Truncate to avoid problems with sub-milliseconds
-      ** rounding. https://sqlite.org/forum/forumpost/766a2c9231 */
-      if( ms>0.999 ) ms = 0.999;
-    }
-  }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;
-  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+4800)/100;
-  B = 38 - 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->tz ){
-      p->iJD -= p->tz*60000;
-      p->validYMD = 0;
-      p->validHMS = 0;
-      p->tz = 0;
-      p->isUtc = 1;
-      p->isLocal = 0;
-    }
-  }
-}
-
-/*
-** Given the YYYY-MM-DD information current in p, determine if there
-** is day-of-month overflow and set nFloor to the number of days that
-** would need to be subtracted from the date in order to bring the
-** date back to the end of the month.
-*/
-static void computeFloor(DateTime *p){
-  assert( p->validYMD || p->isError );
-  assert( p->D>=0 && p->D<=31 );
-  assert( p->M>=0 && p->M<=12 );
-  if( p->D<=28 ){
-    p->nFloor = 0;
-  }else if( (1<<p->M) & 0x15aa ){
-    p->nFloor = 0;
-  }else if( p->M!=2 ){
-    p->nFloor = (p->D==31);
-  }else if( p->Y%4!=0 || (p->Y%100==0 && p->Y%400!=0) ){
-    p->nFloor = p->D - 28;
-  }else{
-    p->nFloor = p->D - 29;
-  }
-}
-
-/*
-** 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;
-  computeFloor(p);
-  if( p->tz ){
-    computeJD(p);
-  }
-  return 0;
-}
-
-
-static void clearYMD_HMS_TZ(DateTime *p);  /* Forward declaration */
-
-/*
-** 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;
-    p->isUtc = 1;
-    p->isLocal = 0;
-    clearYMD_HMS_TZ(p);
-    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)>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, alpha, 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);
-    alpha = (int)((Z + 32044.75)/36524.25) - 52;
-    A = Z + 1 + alpha - ((alpha+100)/4) + 25;
-    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 day_ms, day_min; /* milliseconds, minutes into the day */
-  if( p->validHMS ) return;
-  computeJD(p);
-  day_ms = (int)((p->iJD + 43200000) % 86400000);
-  p->s = (day_ms % 60000)/1000.0;
-  day_min = day_ms/60000;
-  p->m = day_min % 60;
-  p->h = day_min / 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->tz = 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->tz = 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[] = {
-  /* 0 */ { 6, "second",   4.6427e+14,         1.0  },
-  /* 1 */ { 6, "minute",   7.7379e+12,        60.0  },
-  /* 2 */ { 4, "hour",     1.2897e+11,      3600.0  },
-  /* 3 */ { 3, "day",      5373485.0,      86400.0  },
-  /* 4 */ { 5, "month",    176546.0,     2592000.0  },
-  /* 5 */ { 4, "year",     14713.0,     31536000.0  },
-};
-
-/*
-** If the DateTime p is raw number, try to figure out if it is
-** a julian day number of a unix timestamp.  Set the p value
-** appropriately.
-*/
-static void autoAdjustDate(DateTime *p){
-  if( !p->rawS || p->validJD ){
-    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 */
-  ){
-    double r = p->s*1000.0 + 210866760000000.0;
-    clearYMD_HMS_TZ(p);
-    p->iJD = (sqlite3_int64)(r + 0.5);
-    p->validJD = 1;
-    p->rawS = 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
-**     +/-YYYY-MM-DD HH:MM:SS.SSS
-**     ceiling
-**     floor
-**     start of month
-**     start of year
-**     start of week
-**     start of day
-**     weekday N
-**     unixepoch
-**     auto
-**     localtime
-**     utc
-**     subsec
-**     subsecond
-**
-** 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 */
-        autoAdjustDate(p);
-        rc = 0;
-      }
-      break;
-    }
-    case 'c': {
-      /*
-      **    ceiling
-      **
-      ** Resolve day-of-month overflow by rolling forward into the next
-      ** month.  As this is the default action, this modifier is really
-      ** a no-op that is only included for symmetry.  See "floor".
-      */
-      if( sqlite3_stricmp(z, "ceiling")==0 ){
-        computeJD(p);
-        clearYMD_HMS_TZ(p);
-        rc = 0;
-        p->nFloor = 0;
-      }
-      break;
-    }
-    case 'f': {
-      /*
-      **    floor
-      **
-      ** Resolve day-of-month overflow by rolling back to the end of the
-      ** previous month.
-      */
-      if( sqlite3_stricmp(z, "floor")==0 ){
-        computeJD(p);
-        p->iJD -= p->nFloor*86400000;
-        clearYMD_HMS_TZ(p);
-        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 = p->isLocal ? SQLITE_OK : toLocaltime(p, pCtx);
-        p->isUtc = 0;
-        p->isLocal = 1;
-      }
-      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->isUtc==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->isUtc = 1;
-          p->isLocal = 0;
-        }
-        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)>0
-               && r>=0.0 && r<7.0 && (n=(int)r)==r ){
-        sqlite3_int64 Z;
-        computeYMD_HMS(p);
-        p->tz = 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->tz = 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, rx;
-      int Y,M,D,h,m,x;
-      const char *z2 = z;
-      char *zCopy;
-      sqlite3 *db = sqlite3_context_db_handle(pCtx);
-      char z0 = z[0];
-      for(n=1; z[n]; n++){
-        if( z[n]==':' ) break;
-        if( sqlite3Isspace(z[n]) ) break;
-        if( z[n]=='-' ){
-          if( n==5 && getDigits(&z[1], "40f", &Y)==1 ) break;
-          if( n==6 && getDigits(&z[1], "50f", &Y)==1 ) break;
-        }
-      }
-      zCopy = sqlite3DbStrNDup(db, z, n);
-      if( zCopy==0 ) break;
-      rx = sqlite3AtoF(zCopy, &r)<=0;
-      sqlite3DbFree(db, zCopy);
-      if( rx ){
-        assert( rc==1 );
-        break;
-      }
-      if( z[n]=='-' ){
-        /* A modifier of the form (+|-)YYYY-MM-DD adds or subtracts the
-        ** specified number of years, months, and days.  MM is limited to
-        ** the range 0-11 and DD is limited to 0-30.
-        */
-        if( z0!='+' && z0!='-' ) break;  /* Must start with +/- */
-        if( n==5 ){
-          if( getDigits(&z[1], "40f-20a-20d", &Y, &M, &D)!=3 ) break;
-        }else{
-          assert( n==6 );
-          if( getDigits(&z[1], "50f-20a-20d", &Y, &M, &D)!=3 ) break;
-          z++;
-        }
-        if( M>=12 ) break;                   /* M range 0..11 */
-        if( D>=31 ) break;                   /* D range 0..30 */
-        computeYMD_HMS(p);
-        p->validJD = 0;
-        if( z0=='-' ){
-          p->Y -= Y;
-          p->M -= M;
-          D = -D;
-        }else{
-          p->Y += Y;
-          p->M += M;
-        }
-        x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
-        p->Y += x;
-        p->M -= x*12;
-        computeFloor(p);
-        computeJD(p);
-        p->validHMS = 0;
-        p->validYMD = 0;
-        p->iJD += (i64)D*86400000;
-        if( z[11]==0 ){
-          rc = 0;
-          break;
-        }
-        if( sqlite3Isspace(z[11])
-         && getDigits(&z[12], "20c:20e", &h, &m)==2
-        ){
-          z2 = &z[12];
-          n = 2;
-        }else{
-          break;
-        }
-      }
-      if( z2[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.
-        */
-
-        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( z0=='-' ) 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<3 || n>10 ) break;
-      if( sqlite3UpperToLower[(u8)z[n-1]]=='s' ) n--;
-      computeJD(p);
-      assert( rc==1 );
-      rRounder = r<0 ? -0.5 : +0.5;
-      p->nFloor = 0;
-      for(i=0; i<ArraySize(aXformType); i++){
-        if( aXformType[i].nName==n
-         && sqlite3_strnicmp(aXformType[i].zName, z, n)==0
-         && r>-aXformType[i].rLimit && r<aXformType[i].rLimit
-        ){
-          switch( i ){
-            case 4: { /* Special processing to add months */
-              assert( strcmp(aXformType[4].zName,"month")==0 );
-              computeYMD_HMS(p);
-              p->M += (int)r;
-              x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
-              p->Y += x;
-              p->M -= x*12;
-              computeFloor(p);
-              p->validJD = 0;
-              r -= (int)r;
-              break;
-            }
-            case 5: { /* Special processing to add years */
-              int y = (int)r;
-              assert( strcmp(aXformType[5].zName,"year")==0 );
-              computeYMD_HMS(p);
-              assert( p->M>=0 && p->M<=12 );
-              p->Y += y;
-              computeFloor(p);
-              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; i<argc; i++){
-    z = sqlite3_value_text(argv[i]);
-    n = sqlite3_value_bytes(argv[i]);
-    if( z==0 || parseModifier(context, (char*)z, n, p, i) ) return 1;
-  }
-  computeJD(p);
-  if( p->isError || !validJulianDay(p->iJD) ) return 1;
-  if( argc==1 && p->validYMD && p->D>28 ){
-    /* Make sure a YYYY-MM-DD is normalized.
-    ** Example: 2023-02-31 -> 2023-03-03 */
-    assert( p->validJD );
-    p->validYMD = 0;
-  }
-  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 + 0.5);
-      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 + 0.5);
-      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);
-    }
-  }
-}
-
-/*
-** Compute the number of days after the most recent January 1.
-**
-** In other words, compute the zero-based day number for the
-** current year:
-**
-**   Jan01 = 0,  Jan02 = 1, ..., Jan31 = 30, Feb01 = 31, ...
-**   Dec31 = 364 or 365.
-*/
-static int daysAfterJan01(DateTime *pDate){
-  DateTime jan01 = *pDate;
-  assert( jan01.validYMD );
-  assert( jan01.validHMS );
-  assert( pDate->validJD );
-  jan01.validJD = 0;
-  jan01.M = 1;
-  jan01.D = 1;
-  computeJD(&jan01);
-  return (int)((pDate->iJD-jan01.iJD+43200000)/86400000);
-}
-
-/*
-** Return the number of days after the most recent Monday.
-**
-** In other words, return the day of the week according
-** to this code:
-**
-**   0=Monday, 1=Tuesday, 2=Wednesday, ..., 6=Sunday.
-*/
-static int daysAfterMonday(DateTime *pDate){
-  assert( pDate->validJD );
-  return (int)((pDate->iJD+43200000)/86400000) % 7;
-}
-
-/*
-** Return the number of days after the most recent Sunday.
-**
-** In other words, return the day of the week according
-** to this code:
-**
-**   0=Sunday, 1=Monday, 2=Tuesday, ..., 6=Saturday
-*/
-static int daysAfterSunday(DateTime *pDate){
-  assert( pDate->validJD );
-  return (int)((pDate->iJD+129600000)/86400000) % 7;
-}
-
-/*
-**    strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
-**
-** Return a string described by FORMAT.  Conversions as follows:
-**
-**   %d  day of month  01-31
-**   %e  day of month  1-31
-**   %f  ** fractional seconds  SS.SSS
-**   %F  ISO date.  YYYY-MM-DD
-**   %G  ISO year corresponding to %V 0000-9999.
-**   %g  2-digit ISO year corresponding to %V 00-99
-**   %H  hour 00-24
-**   %k  hour  0-24  (leading zero converted to space)
-**   %I  hour 01-12
-**   %j  day of year 001-366
-**   %J  ** julian day number
-**   %l  hour  1-12  (leading zero converted to space)
-**   %m  month 01-12
-**   %M  minute 00-59
-**   %p  "AM" or "PM"
-**   %P  "am" or "pm"
-**   %R  time as HH:MM
-**   %s  seconds since 1970-01-01
-**   %S  seconds 00-59
-**   %T  time as HH:MM:SS
-**   %u  day of week 1-7  Monday==1, Sunday==7
-**   %w  day of week 0-6  Sunday==0, Monday==1
-**   %U  week of year 00-53  (First Sunday is start of week 01)
-**   %V  week of year 01-53  (First week containing Thursday is week 01)
-**   %W  week of year 00-53  (First Monday is start of week 01)
-**   %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++){
-    char cf;
-    if( zFmt[i]!='%' ) continue;
-    if( j<i ) sqlite3_str_append(&sRes, zFmt+j, (int)(i-j));
-    i++;
-    j = i + 1;
-    cf = zFmt[i];
-    switch( cf ){
-      case 'd':  /* Fall thru */
-      case 'e': {
-        sqlite3_str_appendf(&sRes, cf=='d' ? "%02d" : "%2d", x.D);
-        break;
-      }
-      case 'f': {  /* Fractional seconds.  (Non-standard) */
-        double s = x.s;
-        if( NEVER(s>59.999) ) s = 59.999;
-        sqlite3_str_appendf(&sRes, "%06.3f", s);
-        break;
-      }
-      case 'F': {
-        sqlite3_str_appendf(&sRes, "%04d-%02d-%02d", x.Y, x.M, x.D);
-        break;
-      }
-      case 'G': /* Fall thru */
-      case 'g': {
-        DateTime y = x;
-        assert( y.validJD );
-        /* Move y so that it is the Thursday in the same week as x */
-        y.iJD += (3 - daysAfterMonday(&x))*86400000;
-        y.validYMD = 0;
-        computeYMD(&y);
-        if( cf=='g' ){
-          sqlite3_str_appendf(&sRes, "%02d", y.Y%100);
-        }else{
-          sqlite3_str_appendf(&sRes, "%04d", y.Y);
-        }
-        break;
-      }
-      case 'H':
-      case 'k': {
-        sqlite3_str_appendf(&sRes, cf=='H' ? "%02d" : "%2d", x.h);
-        break;
-      }
-      case 'I': /* Fall thru */
-      case 'l': {
-        int h = x.h;
-        if( h>12 ) h -= 12;
-        if( h==0 ) h = 12;
-        sqlite3_str_appendf(&sRes, cf=='I' ? "%02d" : "%2d", h);
-        break;
-      }
-      case 'j': {  /* Day of year.  Jan01==1, Jan02==2, and so forth */
-        sqlite3_str_appendf(&sRes,"%03d",daysAfterJan01(&x)+1);
-        break;
-      }
-      case 'J': {  /* Julian day number.  (Non-standard) */
-        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 'p': /* Fall thru */
-      case 'P': {
-        if( x.h>=12 ){
-          sqlite3_str_append(&sRes, cf=='p' ? "PM" : "pm", 2);
-        }else{
-          sqlite3_str_append(&sRes, cf=='p' ? "AM" : "am", 2);
-        }
-        break;
-      }
-      case 'R': {
-        sqlite3_str_appendf(&sRes, "%02d:%02d", x.h, 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 'T': {
-        sqlite3_str_appendf(&sRes,"%02d:%02d:%02d", x.h, x.m, (int)x.s);
-        break;
-      }
-      case 'u':    /* Day of week.  1 to 7.  Monday==1, Sunday==7 */
-      case 'w': {  /* Day of week.  0 to 6.  Sunday==0, Monday==1 */
-        char c = (char)daysAfterSunday(&x) + '0';
-        if( c=='0' && cf=='u' ) c = '7';
-        sqlite3_str_appendchar(&sRes, 1, c);
-        break;
-      }
-      case 'U': {  /* Week num. 00-53. First Sun of the year is week 01 */
-        sqlite3_str_appendf(&sRes,"%02d",
-              (daysAfterJan01(&x)-daysAfterSunday(&x)+7)/7);
-        break;
-      }
-      case 'V': {  /* Week num. 01-53. First week with a Thur is week 01 */
-        DateTime y = x;
-        /* Adjust y so that is the Thursday in the same week as x */
-        assert( y.validJD );
-        y.iJD += (3 - daysAfterMonday(&x))*86400000;
-        y.validYMD = 0;
-        computeYMD(&y);
-        sqlite3_str_appendf(&sRes,"%02d", daysAfterJan01(&y)/7+1);
-        break;
-      }
-      case 'W': {  /* Week num. 00-53. First Mon of the year is week 01 */
-        sqlite3_str_appendf(&sRes,"%02d",
-           (daysAfterJan01(&x)-daysAfterMonday(&x)+7)/7);
-        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( j<i ) sqlite3_str_append(&sRes, zFmt+j, (int)(i-j));
-  sqlite3ResultStrAccum(context, &sRes);
-}
-
-/*
-** current_time()
-**
-** This function returns the same value as time('now').
-*/
-static void ctimeFunc(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **NotUsed2
-){
-  UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  timeFunc(context, 0, 0);
-}
-
-/*
-** current_date()
-**
-** This function returns the same value as date('now').
-*/
-static void cdateFunc(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **NotUsed2
-){
-  UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  dateFunc(context, 0, 0);
-}
-
-/*
-** timediff(DATE1, DATE2)
-**
-** Return the amount of time that must be added to DATE2 in order to
-** convert it into DATE2.  The time difference format is:
-**
-**     +YYYY-MM-DD HH:MM:SS.SSS
-**
-** The initial "+" becomes "-" if DATE1 occurs before DATE2.  For
-** date/time values A and B, the following invariant should hold:
-**
-**     datetime(A) == (datetime(B, timediff(A,B))
-**
-** Both DATE arguments must be either a julian day number, or an
-** ISO-8601 string.  The unix timestamps are not supported by this
-** routine.
-*/
-static void timediffFunc(
-  sqlite3_context *context,
-  int NotUsed1,
-  sqlite3_value **argv
-){
-  char sign;
-  int Y, M;
-  DateTime d1, d2;
-  sqlite3_str sRes;
-  UNUSED_PARAMETER(NotUsed1);
-  if( isDate(context, 1, &argv[0], &d1) ) return;
-  if( isDate(context, 1, &argv[1], &d2) ) return;
-  computeYMD_HMS(&d1);
-  computeYMD_HMS(&d2);
-  if( d1.iJD>=d2.iJD ){
-    sign = '+';
-    Y = d1.Y - d2.Y;
-    if( Y ){
-      d2.Y = d1.Y;
-      d2.validJD = 0;
-      computeJD(&d2);
-    }
-    M = d1.M - d2.M;
-    if( M<0 ){
-      Y--;
-      M += 12;
-    }
-    if( M!=0 ){
-      d2.M = d1.M;
-      d2.validJD = 0;
-      computeJD(&d2);
-    }
-    while( d1.iJD<d2.iJD ){
-      M--;
-      if( M<0 ){
-        M = 11;
-        Y--;
-      }
-      d2.M--;
-      if( d2.M<1 ){
-        d2.M = 12;
-        d2.Y--;
-      }
-      d2.validJD = 0;
-      computeJD(&d2);
-    }
-    d1.iJD -= d2.iJD;
-    d1.iJD += (u64)1486995408 * (u64)100000;
-  }else /* d1<d2 */{
-    sign = '-';
-    Y = d2.Y - d1.Y;
-    if( Y ){
-      d2.Y = d1.Y;
-      d2.validJD = 0;
-      computeJD(&d2);
-    }
-    M = d2.M - d1.M;
-    if( M<0 ){
-      Y--;
-      M += 12;
-    }
-    if( M!=0 ){
-      d2.M = d1.M;
-      d2.validJD = 0;
-      computeJD(&d2);
-    }
-    while( d1.iJD>d2.iJD ){
-      M--;
-      if( M<0 ){
-        M = 11;
-        Y--;
-      }
-      d2.M++;
-      if( d2.M>12 ){
-        d2.M = 1;
-        d2.Y++;
-      }
-      d2.validJD = 0;
-      computeJD(&d2);
-    }
-    d1.iJD = d2.iJD - d1.iJD;
-    d1.iJD += (u64)1486995408 * (u64)100000;
-  }
-  clearYMD_HMS_TZ(&d1);
-  computeYMD_HMS(&d1);
-  sqlite3StrAccumInit(&sRes, 0, 0, 0, 100);
-  sqlite3_str_appendf(&sRes, "%c%04d-%02d-%02d %02d:%02d:%06.3f",
-       sign, Y, M, d1.D-1, d1.h, d1.m, d1.s);
-  sqlite3ResultStrAccum(context, &sRes);
-}
-
-
-/*
-** current_timestamp()
-**
-** This function returns the same value as datetime('now').
-*/
-static void ctimestampFunc(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **NotUsed2
-){
-  UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  datetimeFunc(context, 0, 0);
-}
-#endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */
-
-#ifdef SQLITE_OMIT_DATETIME_FUNCS
-/*
-** If the library is compiled to omit the full-scale date and time
-** handling (to get a smaller binary), the following minimal version
-** of the functions current_time(), current_date() and current_timestamp()
-** are included instead. This is to support column declarations that
-** include "DEFAULT CURRENT_TIME" etc.
-**
-** This function uses the C-library functions time(), gmtime()
-** and strftime(). The format string to pass to strftime() is supplied
-** as the user-data for the function.
-*/
-static void currentTimeFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  time_t t;
-  char *zFormat = (char *)sqlite3_user_data(context);
-  sqlite3_int64 iT;
-  struct tm *pTm;
-  struct tm sNow;
-  char zBuf[20];
-
-  UNUSED_PARAMETER(argc);
-  UNUSED_PARAMETER(argv);
-
-  iT = sqlite3StmtCurrentTime(context);
-  if( iT<=0 ) return;
-  t = iT/1000 - 10000*(sqlite3_int64)21086676;
-#if HAVE_GMTIME_R
-  pTm = gmtime_r(&t, &sNow);
-#else
-  sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN));
-  pTm = gmtime(&t);
-  if( pTm ) memcpy(&sNow, pTm, sizeof(sNow));
-  sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN));
-#endif
-  if( pTm ){
-    strftime(zBuf, 20, zFormat, &sNow);
-    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
-  }
-}
-#endif
-
-#if !defined(SQLITE_OMIT_DATETIME_FUNCS) && defined(SQLITE_DEBUG)
-/*
-**   datedebug(...)
-**
-** This routine returns JSON that describes the internal DateTime object.
-** Used for debugging and testing only.  Subject to change.
-*/
-static void datedebugFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  DateTime x;
-  if( isDate(context, argc, argv, &x)==0 ){
-    char *zJson;
-    zJson = sqlite3_mprintf(
-      "{iJD:%lld,Y:%d,M:%d,D:%d,h:%d,m:%d,tz:%d,"
-      "s:%.3f,validJD:%d,validYMD:%d,validHMS:%d,"
-      "nFloor:%d,rawS:%d,isError:%d,useSubsec:%d,"
-      "isUtc:%d,isLocal:%d}",
-      x.iJD, x.Y, x.M, x.D, x.h, x.m, x.tz,
-      x.s, x.validJD, x.validYMD, x.validHMS,
-      x.nFloor, x.rawS, x.isError, x.useSubsec,
-      x.isUtc, x.isLocal);
-    sqlite3_result_text(context, zJson, -1, sqlite3_free);
-  }
-}
-#endif /* !SQLITE_OMIT_DATETIME_FUNCS && SQLITE_DEBUG */
-
-
-/*
-** This function registered all of the above C functions as SQL
-** functions.  This should be the only routine in this file with
-** external linkage.
-*/
-SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){
-  static FuncDef aDateTimeFuncs[] = {
-#ifndef SQLITE_OMIT_DATETIME_FUNCS
-    PURE_DATE(julianday,        -1, 0, 0, juliandayFunc ),
-    PURE_DATE(unixepoch,        -1, 0, 0, unixepochFunc ),
-    PURE_DATE(date,             -1, 0, 0, dateFunc      ),
-    PURE_DATE(time,             -1, 0, 0, timeFunc      ),
-    PURE_DATE(datetime,         -1, 0, 0, datetimeFunc  ),
-    PURE_DATE(strftime,         -1, 0, 0, strftimeFunc  ),
-    PURE_DATE(timediff,          2, 0, 0, timediffFunc  ),
-#ifdef SQLITE_DEBUG
-    PURE_DATE(datedebug,        -1, 0, 0, datedebugFunc ),
-#endif
-    DFUNCTION(current_time,      0, 0, 0, ctimeFunc     ),
-    DFUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc),
-    DFUNCTION(current_date,      0, 0, 0, cdateFunc     ),
-#else
-    STR_FUNCTION(current_time,      0, "%H:%M:%S",          0, currentTimeFunc),
-    STR_FUNCTION(current_date,      0, "%Y-%m-%d",          0, currentTimeFunc),
-    STR_FUNCTION(current_timestamp, 0, "%Y-%m-%d %H:%M:%S", 0, currentTimeFunc),
-#endif
-  };
-  sqlite3InsertBuiltinFuncs(aDateTimeFuncs, ArraySize(aDateTimeFuncs));
-}
-
-/************** End of date.c ************************************************/
-/************** Begin file os.c **********************************************/
-/*
-** 2005 November 29
-**
-** 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 OS interface code that is common to all
-** architectures.
-*/
-/* #include "sqliteInt.h" */
-
-/*
-** 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 int sqlite3_io_error_hit = 0;            /* Total number of I/O Errors */
-SQLITE_API int sqlite3_io_error_hardhit = 0;        /* Number of non-benign errors */
-SQLITE_API int sqlite3_io_error_pending = 0;        /* Count down to first I/O error */
-SQLITE_API int sqlite3_io_error_persist = 0;        /* True if I/O errors persist */
-SQLITE_API int sqlite3_io_error_benign = 0;         /* True if errors are benign */
-SQLITE_API int sqlite3_diskfull_pending = 0;
-SQLITE_API int sqlite3_diskfull = 0;
-#endif /* defined(SQLITE_TEST) */
-
-/*
-** When testing, also keep a count of the number of open files.
-*/
-#if defined(SQLITE_TEST)
-SQLITE_API int sqlite3_open_file_count = 0;
-#endif /* defined(SQLITE_TEST) */
-
-/*
-** The default SQLite sqlite3_vfs implementations do not allocate
-** memory (actually, os_unix.c allocates a small amount of memory
-** from within OsOpen()), but some third-party implementations may.
-** So we test the effects of a malloc() failing and the sqlite3OsXXX()
-** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
-**
-** The following functions are instrumented for malloc() failure
-** testing:
-**
-**     sqlite3OsRead()
-**     sqlite3OsWrite()
-**     sqlite3OsSync()
-**     sqlite3OsFileSize()
-**     sqlite3OsLock()
-**     sqlite3OsCheckReservedLock()
-**     sqlite3OsFileControl()
-**     sqlite3OsShmMap()
-**     sqlite3OsOpen()
-**     sqlite3OsDelete()
-**     sqlite3OsAccess()
-**     sqlite3OsFullPathname()
-**
-*/
-#if defined(SQLITE_TEST)
-SQLITE_API int sqlite3_memdebug_vfs_oom_test = 1;
-  #define DO_OS_MALLOC_TEST(x)                                       \
-  if (sqlite3_memdebug_vfs_oom_test && (!x || !sqlite3JournalIsInMemory(x))) { \
-    void *pTstAlloc = sqlite3Malloc(10);                             \
-    if (!pTstAlloc) return SQLITE_IOERR_NOMEM_BKPT;                  \
-    sqlite3_free(pTstAlloc);                                         \
-  }
-#else
-  #define DO_OS_MALLOC_TEST(x)
-#endif
-
-/*
-** The following routines are convenience wrappers around methods
-** of the sqlite3_file object.  This is mostly just syntactic sugar. All
-** of this would be completely automatic if SQLite were coded using
-** C++ instead of plain old C.
-*/
-SQLITE_PRIVATE void sqlite3OsClose(sqlite3_file *pId){
-  if( pId->pMethods ){
-    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 command 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 <sys/sysctl.h>
-#include <malloc/malloc.h>
-#ifdef SQLITE_MIGHT_BE_SINGLE_CORE
-#include <libkern/OSAtomic.h>
-#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 <malloc.h>
-#  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 intercepted 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.activecpu 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 <stdio.h> */
-
-/*
-** 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)(nByte<pOldHdr->iSize ? 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<NCSIZE-1; i++){
-    if( mem.nAlloc[i] ){
-      fprintf(out, "   %5d: %10d %10d %10d\n",
-            i*8, mem.nAlloc[i], mem.nCurrent[i], mem.mxCurrent[i]);
-    }
-  }
-  if( mem.nAlloc[NCSIZE-1] ){
-    fprintf(out, "   %5d: %10d %10d %10d\n",
-             NCSIZE*8-8, mem.nAlloc[NCSIZE-1],
-             mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]);
-  }
-  fclose(out);
-}
-
-/*
-** Return the number of times sqlite3MemMalloc() has been called.
-*/
-SQLITE_PRIVATE int sqlite3MemdebugMallocCount(){
-  int i;
-  int nTotal = 0;
-  for(i=0; i<NCSIZE; i++){
-    nTotal += mem.nAlloc[i];
-  }
-  return nTotal;
-}
-
-
-#endif /* SQLITE_MEMDEBUG */
-
-/************** End of mem2.c ************************************************/
-/************** Begin file mem3.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 SQLite user supplies 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_MEMSYS3 is defined.
-*/
-/* #include "sqliteInt.h" */
-
-/*
-** This version of the memory allocator is only built into the library
-** SQLITE_ENABLE_MEMSYS3 is defined. Defining this symbol does not
-** mean that the library will use a memory-pool by default, just that
-** it is available. The mempool allocator is activated by calling
-** sqlite3_config().
-*/
-#ifdef SQLITE_ENABLE_MEMSYS3
-
-/*
-** Maximum size (in Mem3Blocks) of a "small" chunk.
-*/
-#define MX_SMALL 10
-
-
-/*
-** Number of freelist hash slots
-*/
-#define N_HASH  61
-
-/*
-** A memory allocation (also called a "chunk") consists of two or
-** more blocks where each block is 8 bytes.  The first 8 bytes are
-** a header that is not returned to the user.
-**
-** A chunk is two or more blocks that is either checked out or
-** free.  The first block has format u.hdr.  u.hdr.size4x is 4 times the
-** size of the allocation in blocks if the allocation is free.
-** The u.hdr.size4x&1 bit is true if the chunk is checked out and
-** false if the chunk is on the freelist.  The u.hdr.size4x&2 bit
-** is true if the previous chunk is checked out and false if the
-** previous chunk is free.  The u.hdr.prevSize field is the size of
-** the previous chunk in blocks if the previous chunk is on the
-** freelist. If the previous chunk is checked out, then
-** u.hdr.prevSize can be part of the data for that chunk and should
-** not be read or written.
-**
-** We often identify a chunk by its index in mem3.aPool[].  When
-** this is done, the chunk index refers to the second block of
-** the chunk.  In this way, the first chunk has an index of 1.
-** A chunk index of 0 means "no such chunk" and is the equivalent
-** of a NULL pointer.
-**
-** The second block of free chunks is of the form u.list.  The
-** two fields form a double-linked list of chunks of related sizes.
-** Pointers to the head of the list are stored in mem3.aiSmall[]
-** for smaller chunks and mem3.aiHash[] for larger chunks.
-**
-** The second block of a chunk is user data if the chunk is checked
-** out.  If a chunk is checked out, the user data may extend into
-** the u.hdr.prevSize value of the following chunk.
-*/
-typedef struct Mem3Block Mem3Block;
-struct Mem3Block {
-  union {
-    struct {
-      u32 prevSize;   /* Size of previous chunk in Mem3Block elements */
-      u32 size4x;     /* 4x the size of current chunk in Mem3Block elements */
-    } hdr;
-    struct {
-      u32 next;       /* Index in mem3.aPool[] of next free chunk */
-      u32 prev;       /* Index in mem3.aPool[] of previous free chunk */
-    } list;
-  } u;
-};
-
-/*
-** All of the static variables used by this module are collected
-** into a single structure named "mem3".  This is to keep the
-** static variables organized and to reduce namespace pollution
-** when this module is combined with other in the amalgamation.
-*/
-static SQLITE_WSD struct Mem3Global {
-  /*
-  ** Memory available for allocation. nPool is the size of the array
-  ** (in Mem3Blocks) pointed to by aPool less 2.
-  */
-  u32 nPool;
-  Mem3Block *aPool;
-
-  /*
-  ** True if we are evaluating an out-of-memory callback.
-  */
-  int alarmBusy;
-
-  /*
-  ** Mutex to control access to the memory allocation subsystem.
-  */
-  sqlite3_mutex *mutex;
-
-  /*
-  ** The minimum amount of free space that we have seen.
-  */
-  u32 mnKeyBlk;
-
-  /*
-  ** iKeyBlk is the index of the key chunk.  Most new allocations
-  ** occur off of this chunk.  szKeyBlk is the size (in Mem3Blocks)
-  ** of the current key chunk.  iKeyBlk is 0 if there is no key chunk.
-  ** The key chunk is not in either the aiHash[] or aiSmall[].
-  */
-  u32 iKeyBlk;
-  u32 szKeyBlk;
-
-  /*
-  ** Array of lists of free blocks according to the block size
-  ** for smaller chunks, or a hash on the block size for larger
-  ** chunks.
-  */
-  u32 aiSmall[MX_SMALL-1];   /* For sizes 2 through MX_SMALL, inclusive */
-  u32 aiHash[N_HASH];        /* For sizes MX_SMALL+1 and larger */
-} mem3 = { 97535575 };
-
-#define mem3 GLOBAL(struct Mem3Global, mem3)
-
-/*
-** Unlink the chunk at mem3.aPool[i] from list it is currently
-** on.  *pRoot is the list that i is a member of.
-*/
-static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
-  u32 next = mem3.aPool[i].u.list.next;
-  u32 prev = mem3.aPool[i].u.list.prev;
-  assert( sqlite3_mutex_held(mem3.mutex) );
-  if( prev==0 ){
-    *pRoot = next;
-  }else{
-    mem3.aPool[prev].u.list.next = next;
-  }
-  if( next ){
-    mem3.aPool[next].u.list.prev = prev;
-  }
-  mem3.aPool[i].u.list.next = 0;
-  mem3.aPool[i].u.list.prev = 0;
-}
-
-/*
-** Unlink the chunk at index i from
-** whatever list is currently a member of.
-*/
-static void memsys3Unlink(u32 i){
-  u32 size, hash;
-  assert( sqlite3_mutex_held(mem3.mutex) );
-  assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
-  assert( 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<N_HASH; i++){
-      memsys3Merge(&mem3.aiHash[i]);
-    }
-    for(i=0; i<MX_SMALL-1; i++){
-      memsys3Merge(&mem3.aiSmall[i]);
-    }
-    if( mem3.szKeyBlk ){
-      memsys3Unlink(mem3.iKeyBlk);
-      if( mem3.szKeyBlk>=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<nBytes ){
-      memcpy(p, pPrior, nOld);
-    }else{
-      memcpy(p, pPrior, nBytes);
-    }
-    memsys3FreeUnsafe(pPrior);
-  }
-  memsys3Leave();
-  return p;
-}
-
-/*
-** Initialize this module.
-*/
-static int memsys3Init(void *NotUsed){
-  UNUSED_PARAMETER(NotUsed);
-  if( !sqlite3GlobalConfig.pHeap ){
-    return SQLITE_ERROR;
-  }
-
-  /* Store a pointer to the memory block in global structure mem3. */
-  assert( sizeof(Mem3Block)==8 );
-  mem3.aPool = (Mem3Block *)sqlite3GlobalConfig.pHeap;
-  mem3.nPool = (sqlite3GlobalConfig.nHeap / sizeof(Mem3Block)) - 2;
-
-  /* Initialize the key block. */
-  mem3.szKeyBlk = mem3.nPool;
-  mem3.mnKeyBlk = mem3.szKeyBlk;
-  mem3.iKeyBlk = 1;
-  mem3.aPool[0].u.hdr.size4x = (mem3.szKeyBlk<<2) + 2;
-  mem3.aPool[mem3.nPool].u.hdr.prevSize = mem3.nPool;
-  mem3.aPool[mem3.nPool].u.hdr.size4x = 1;
-
-  return SQLITE_OK;
-}
-
-/*
-** Deinitialize this module.
-*/
-static void memsys3Shutdown(void *NotUsed){
-  UNUSED_PARAMETER(NotUsed);
-  mem3.mutex = 0;
-  return;
-}
-
-
-
-/*
-** Open the file indicated and write a log of all unfreed memory
-** allocations into that log.
-*/
-SQLITE_PRIVATE void sqlite3Memsys3Dump(const char *zFilename){
-#ifdef SQLITE_DEBUG
-  FILE *out;
-  u32 i, j;
-  u32 size;
-  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;
-    }
-  }
-  memsys3Enter();
-  fprintf(out, "CHUNKS:\n");
-  for(i=1; i<=mem3.nPool; i+=size/4){
-    size = mem3.aPool[i-1].u.hdr.size4x;
-    if( size/4<=1 ){
-      fprintf(out, "%p size error\n", &mem3.aPool[i]);
-      assert( 0 );
-      break;
-    }
-    if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
-      fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
-      assert( 0 );
-      break;
-    }
-    if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>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; i<MX_SMALL-1; i++){
-    if( mem3.aiSmall[i]==0 ) continue;
-    fprintf(out, "small(%2d):", i);
-    for(j = mem3.aiSmall[i]; j>0; 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; i<N_HASH; i++){
-    if( mem3.aiHash[i]==0 ) continue;
-    fprintf(out, "hash(%2d):", i);
-    for(j = mem3.aiHash[i]; j>0; 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<<LOGMAX)*mem5.szAtom). Since
-** mem5.szAtom is always at least 8 and 32-bit integers are used,
-** it is not actually possible to reach this limit.
-*/
-#define LOGMAX 30
-
-/*
-** Masks used for mem5.aCtrl[] elements.
-*/
-#define CTRL_LOGSIZE  0x1f    /* Log2 Size of this block */
-#define CTRL_FREE     0x20    /* True if not checked out */
-
-/*
-** All of the static variables used by this module are collected
-** into a single structure named "mem5".  This is to keep the
-** static variables organized and to reduce namespace pollution
-** when this module is combined with other in the amalgamation.
-*/
-static SQLITE_WSD struct Mem5Global {
-  /*
-  ** Memory available for allocation
-  */
-  int szAtom;      /* Smallest possible allocation in bytes */
-  int nBlock;      /* Number of szAtom sized blocks in zPool */
-  u8 *zPool;       /* Memory available to be allocated */
-
-  /*
-  ** Mutex to control access to the memory allocation subsystem.
-  */
-  sqlite3_mutex *mutex;
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
-  /*
-  ** Performance statistics
-  */
-  u64 nAlloc;         /* Total number of calls to malloc */
-  u64 totalAlloc;     /* Total of all malloc calls - includes internal frag */
-  u64 totalExcess;    /* Total internal fragmentation */
-  u32 currentOut;     /* Current checkout, including internal fragmentation */
-  u32 currentCount;   /* Current number of distinct checkouts */
-  u32 maxOut;         /* Maximum instantaneous currentOut */
-  u32 maxCount;       /* Maximum instantaneous currentCount */
-  u32 maxRequest;     /* Largest allocation (exclusive of internal frag) */
-#endif
-
-  /*
-  ** Lists of free blocks.  aiFreelist[0] is a list of free blocks of
-  ** size mem5.szAtom.  aiFreelist[1] holds blocks of size szAtom*2.
-  ** aiFreelist[2] holds free blocks of size szAtom*4.  And so forth.
-  */
-  int aiFreelist[LOGMAX+1];
-
-  /*
-  ** Space for tracking which blocks are checked out and the size
-  ** of each block.  One byte per block.
-  */
-  u8 *aCtrl;
-
-} mem5;
-
-/*
-** Access the static variable through a macro for SQLITE_OMIT_WSD.
-*/
-#define mem5 GLOBAL(struct Mem5Global, mem5)
-
-/*
-** Assuming mem5.zPool is divided up into an array of Mem5Link
-** structures, return a pointer to the idx-th such link.
-*/
-#define MEM5LINK(idx) ((Mem5Link *)(&mem5.zPool[(idx)*mem5.szAtom]))
-
-/*
-** Unlink the chunk at mem5.aPool[i] from list it is currently
-** on.  It should be found on mem5.aiFreelist[iLogsize].
-*/
-static void memsys5Unlink(int i, int iLogsize){
-  int next, prev;
-  assert( i>=0 && i<mem5.nBlock );
-  assert( iLogsize>=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<mem5.nBlock );
-  assert( iLogsize>=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( x<mem5.nBlock );
-    MEM5LINK(x)->prev = 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 && i<mem5.nBlock );
-  iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE));
-  return iSize;
-}
-
-/*
-** Return a block of memory of at least nBytes in size.
-** Return NULL if unable.  Return NULL if nBytes==0.
-**
-** The caller guarantees that nByte is positive.
-**
-** The caller has obtained a mutex prior to invoking this
-** routine so there is never any chance that two or more
-** threads can be in this routine at the same time.
-*/
-static void *memsys5MallocUnsafe(int nByte){
-  int i;           /* Index of a mem5.aPool[] slot */
-  int iBin;        /* Index into mem5.aiFreelist[] */
-  int iFullSz;     /* Size of allocation rounded up to power of 2 */
-  int iLogsize;    /* Log2 of iFullSz/POW2_MIN */
-
-  /* nByte must be a positive */
-  assert( nByte>0 );
-
-  /* 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; iFullSz<nByte; iFullSz*=2,iLogsize++){}
-
-  /* Make sure mem5.aiFreelist[iLogsize] contains at least one free
-  ** block.  If not, then split a block of the next larger power of
-  ** two in order to create a new free block of size iLogsize.
-  */
-  for(iBin=iLogsize; iBin<=LOGMAX && mem5.aiFreelist[iBin]<0; iBin++){}
-  if( iBin>LOGMAX ){
-    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<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
-  if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
-#endif
-
-#ifdef SQLITE_DEBUG
-  /* Make sure the allocated memory does not assume that it is set to zero
-  ** or retains a value from a previous allocation */
-  memset(&mem5.zPool[i*mem5.szAtom], 0xAA, iFullSz);
-#endif
-
-  /* Return a pointer to the allocated memory. */
-  return (void*)&mem5.zPool[i*mem5.szAtom];
-}
-
-/*
-** Free an outstanding memory allocation.
-*/
-static void memsys5FreeUnsafe(void *pOld){
-  u32 size, iLogsize;
-  int iBlock;
-
-  /* Set iBlock to the index of the block pointed to by pOld in
-  ** the array of mem5.szAtom byte blocks pointed to by mem5.zPool.
-  */
-  iBlock = (int)(((u8 *)pOld-mem5.zPool)/mem5.szAtom);
-
-  /* Check that the pointer pOld points to a valid, non-free block. */
-  assert( iBlock>=0 && iBlock<mem5.nBlock );
-  assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );
-  assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 );
-
-  iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE;
-  size = 1<<iLogsize;
-  assert( iBlock+size-1<(u32)mem5.nBlock );
-
-  mem5.aCtrl[iBlock] |= CTRL_FREE;
-  mem5.aCtrl[iBlock+size-1] |= CTRL_FREE;
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
-  assert( mem5.currentCount>0 );
-  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<LOGMAX) ){
-    int iBuddy;
-    if( (iBlock>>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( iBuddy<iBlock ){
-      mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
-      mem5.aCtrl[iBlock] = 0;
-      iBlock = iBuddy;
-    }else{
-      mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
-      mem5.aCtrl[iBuddy] = 0;
-    }
-    size *= 2;
-  }
-
-#ifdef SQLITE_DEBUG
-  /* Overwrite freed memory with the 0x55 bit pattern to verify that it is
-  ** not used after being freed */
-  memset(&mem5.zPool[iBlock*mem5.szAtom], 0x55, size);
-#endif
-
-  memsys5Link(iBlock, iLogsize);
-}
-
-/*
-** Allocate nBytes of memory.
-*/
-static void *memsys5Malloc(int nBytes){
-  sqlite3_int64 *p = 0;
-  if( nBytes>0 ){
-    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<n; iFullSz *= 4);
-  if( (iFullSz/2)>=(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<<iLog)<iValue; iLog++);
-  return iLog;
-}
-
-/*
-** Initialize the memory allocator.
-**
-** This routine is not threadsafe.  The caller must be holding a mutex
-** to prevent multiple threads from entering at the same time.
-*/
-static int memsys5Init(void *NotUsed){
-  int ii;            /* Loop counter */
-  int nByte;         /* Number of bytes of memory available to this allocator */
-  u8 *zByte;         /* Memory usable by this allocator */
-  int nMinLog;       /* Log base 2 of minimum allocation size in bytes */
-  int iOffset;       /* An offset into mem5.aCtrl[] */
-
-  UNUSED_PARAMETER(NotUsed);
-
-  /* For the purposes of this routine, disable the mutex */
-  mem5.mutex = 0;
-
-  /* The size of a Mem5Link object must be a power of two.  Verify that
-  ** this is case.
-  */
-  assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 );
-
-  nByte = sqlite3GlobalConfig.nHeap;
-  zByte = (u8*)sqlite3GlobalConfig.pHeap;
-  assert( zByte!=0 );  /* sqlite3_config() does not allow otherwise */
-
-  /* boundaries on sqlite3GlobalConfig.mnReq are enforced in sqlite3_config() */
-  nMinLog = memsys5Log(sqlite3GlobalConfig.mnReq);
-  mem5.szAtom = (1<<nMinLog);
-  while( (int)sizeof(Mem5Link)>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<<ii);
-    if( (iOffset+nAlloc)<=mem5.nBlock ){
-      mem5.aCtrl[iOffset] = ii | CTRL_FREE;
-      memsys5Link(iOffset, ii);
-      iOffset += nAlloc;
-    }
-    assert((iOffset+nAlloc)>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_THREAD_MISUSE_WARNINGS
-/*
-** This block (enclosed by SQLITE_THREAD_MISUSE_WARNINGS) 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() then a warning is emitted via
-** sqlite3_log().  Furthermore, if SQLITE_THREAD_MISUSE_ABORT is
-** defined then abort() is called after the sqlite3_log() warning.
-**
-** This type of mutex is used on the database handle mutex when testing
-** apps that usually use SQLITE_CONFIG_MULTITHREAD mode.  A failure
-** indicates that the app ought to be using SQLITE_OPEN_FULLMUTEX or
-** similar because it is trying to use the same database handle from
-** two different connections at the same time.
-*/
-
-/*
-** Type for all mutexes used when SQLITE_THREAD_MISUSE_WARNINGS
-** 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 pGlobalMutexMethods->xMutexInit();
-}
-static int checkMutexEnd(void){
-  int rc = pGlobalMutexMethods->xMutexEnd();
-  pGlobalMutexMethods = 0;
-  return rc;
-}
-
-/*
-** 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 );
-
-#ifdef 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"
-    );
-#if SQLITE_THREAD_MISUSE_ABORT
-    abort();
-#endif
-  }
-  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_THREAD_MISUSE_WARNINGS */
-
-/*
-** 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_THREAD_MISUSE_WARNINGS
-      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.
-**
-** Because these routines raise false-positive alerts in TSAN, disable
-** them (make them always return 1) when compiling with TSAN.
-*/
-SQLITE_API int sqlite3_mutex_held(sqlite3_mutex *p){
-# if defined(__has_feature)
-#   if __has_feature(thread_sanitizer)
-      p = 0;
-#   endif
-# endif
-  assert( p==0 || sqlite3GlobalConfig.mutex.xMutexHeld );
-  return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
-}
-SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex *p){
-# if defined(__has_feature)
-#   if __has_feature(thread_sanitizer)
-      p = 0;
-#   endif
-# endif
-  assert( p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld );
-  return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
-}
-#endif /* NDEBUG */
-
-#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 <pthread.h>
-
-/*
-** The sqlite3_mutex.id, sqlite3_mutex.nRef, and sqlite3_mutex.owner fields
-** are necessary under two conditions:  (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:
-**
-** <ul>
-** <li>  SQLITE_MUTEX_FAST
-** <li>  SQLITE_MUTEX_RECURSIVE
-** <li>  SQLITE_MUTEX_STATIC_MAIN
-** <li>  SQLITE_MUTEX_STATIC_MEM
-** <li>  SQLITE_MUTEX_STATIC_OPEN
-** <li>  SQLITE_MUTEX_STATIC_PRNG
-** <li>  SQLITE_MUTEX_STATIC_LRU
-** <li>  SQLITE_MUTEX_STATIC_PMEM
-** <li>  SQLITE_MUTEX_STATIC_APP1
-** <li>  SQLITE_MUTEX_STATIC_APP2
-** <li>  SQLITE_MUTEX_STATIC_APP3
-** <li>  SQLITE_MUTEX_STATIC_VFS1
-** <li>  SQLITE_MUTEX_STATIC_VFS2
-** <li>  SQLITE_MUTEX_STATIC_VFS3
-** </ul>
-**
-** 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 );
-#ifdef 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 <sys/cygwin.h>
-# include <sys/stat.h> /* amalgamator: dontcache */
-# include <unistd.h> /* amalgamator: dontcache */
-# include <errno.h> /* 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
-
-/*
-** 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_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 entrances */
-  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>=1400
-  _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<ArraySize(winMutex_staticMutexes); i++){
-      InitializeCriticalSection(&winMutex_staticMutexes[i].mutex);
-    }
-    winMutex_isInit = 1;
-  }else{
-    /* Another thread is (in the process of) initializing the static
-    ** mutexes */
-    while( !winMutex_isInit ){
-      sqlite3_win32_sleep(1);
-    }
-  }
-  return SQLITE_OK;
-}
-
-static int winMutexEnd(void){
-  /* The first to decrement to 0 does actual shutdown
-  ** (which should be the last to shutdown.) */
-  if( InterlockedCompareExchange(&winMutex_lock, 0, 1)==1 ){
-    if( winMutex_isInit==1 ){
-      int i;
-      for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
-        DeleteCriticalSection(&winMutex_staticMutexes[i].mutex);
-      }
-      winMutex_isInit = 0;
-    }
-  }
-  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:
-**
-** <ul>
-** <li>  SQLITE_MUTEX_FAST
-** <li>  SQLITE_MUTEX_RECURSIVE
-** <li>  SQLITE_MUTEX_STATIC_MAIN
-** <li>  SQLITE_MUTEX_STATIC_MEM
-** <li>  SQLITE_MUTEX_STATIC_OPEN
-** <li>  SQLITE_MUTEX_STATIC_PRNG
-** <li>  SQLITE_MUTEX_STATIC_LRU
-** <li>  SQLITE_MUTEX_STATIC_PMEM
-** <li>  SQLITE_MUTEX_STATIC_APP1
-** <li>  SQLITE_MUTEX_STATIC_APP2
-** <li>  SQLITE_MUTEX_STATIC_APP3
-** <li>  SQLITE_MUTEX_STATIC_VFS1
-** <li>  SQLITE_MUTEX_STATIC_VFS2
-** <li>  SQLITE_MUTEX_STATIC_VFS3
-** </ul>
-**
-** 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
-        InitializeCriticalSection(&p->mutex);
-      }
-      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 <stdarg.h> */
-
-/*
-** 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( n<mem0.alarmThreshold || mem0.alarmThreshold==0 ){
-      mem0.alarmThreshold = n;
-    }
-  }
-  sqlite3_mutex_leave(mem0.mutex);
-  return priorLimit;
-}
-
-
-/*
-** Initialize the memory allocation subsystem.
-*/
-SQLITE_PRIVATE int sqlite3MallocInit(void){
-  int rc;
-  if( sqlite3GlobalConfig.m.xMalloc==0 ){
-    sqlite3MemSetDefault();
-  }
-  mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
-  if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512
-      || sqlite3GlobalConfig.nPage<=0 ){
-    sqlite3GlobalConfig.pPage = 0;
-    sqlite3GlobalConfig.szPage = 0;
-  }
-  rc = sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
-  if( rc!=SQLITE_OK ) memset(&mem0, 0, sizeof(mem0));
-  return rc;
-}
-
-/*
-** Return true if the heap is currently under memory pressure - in other
-** words if the amount of heap used is close to the limit set by
-** sqlite3_soft_heap_limit().
-*/
-SQLITE_PRIVATE int sqlite3HeapNearlyFull(void){
-  return AtomicLoad(&mem0.nearlyFull);
-}
-
-/*
-** Deinitialize the memory allocation subsystem.
-*/
-SQLITE_PRIVATE void sqlite3MallocEnd(void){
-  if( sqlite3GlobalConfig.m.xShutdown ){
-    sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
-  }
-  memset(&mem0, 0, sizeof(mem0));
-}
-
-/*
-** Return the amount of memory currently checked out.
-*/
-SQLITE_API sqlite3_int64 sqlite3_memory_used(void){
-  sqlite3_int64 res, mx;
-  sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, 0);
-  return res;
-}
-
-/*
-** Return the maximum amount of memory that has ever been
-** checked out since either the beginning of this process
-** or since the most recent reset.
-*/
-SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
-  sqlite3_int64 res, mx;
-  sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, resetFlag);
-  return mx;
-}
-
-/*
-** Trigger the alarm
-*/
-static void sqlite3MallocAlarm(int nByte){
-  if( mem0.alarmThreshold<=0 ) return;
-  sqlite3_mutex_leave(mem0.mutex);
-  sqlite3_release_memory(nByte);
-  sqlite3_mutex_enter(mem0.mutex);
-}
-
-#ifdef SQLITE_DEBUG
-/*
-** This routine is called whenever an out-of-memory condition is seen,
-** It's only purpose to to serve as a breakpoint for gdb or similar
-** code debuggers when working on out-of-memory conditions, for example
-** caused by PRAGMA hard_heap_limit=N.
-*/
-static SQLITE_NOINLINE void test_oom_breakpoint(u64 n){
-  static u64 nOomFault = 0;
-  nOomFault += n;
-  /* The assert() is never reached in a human lifetime.  It  is here mostly
-  ** to prevent code optimizers from optimizing out this function. */
-  assert( (nOomFault>>32) < 0xffffffff );
-}
-#else
-# define test_oom_breakpoint(X)   /* No-op for production builds */
-#endif
-
-/*
-** Do a memory allocation with statistics and alarms.  Assume the
-** lock is already held.
-*/
-static void mallocWithAlarm(int n, void **pp){
-  void *p;
-  int nFull;
-  assert( sqlite3_mutex_held(mem0.mutex) );
-  assert( n>0 );
-
-  /* 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 ){
-          test_oom_breakpoint(1);
-          *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;
-}
-
-/*
-** 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 p<db->lookaside.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>SQLITE_MAX_ALLOCATION_SIZE ){
-    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);
-        test_oom_breakpoint(1);
-        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]<zEnd ); }
-#endif
-  while( sqlite3Isspace(zStart[0]) ) zStart++;
-  n = (int)(zEnd - zStart);
-  while( sqlite3Isspace(zStart[n-1]) ) n--;
-  return sqlite3DbStrNDup(db, zStart, n);
-}
-
-/*
-** Free any prior content in *pz and replace it with a copy of zNew.
-*/
-SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){
-  char *z = sqlite3DbStrDup(db, zNew);
-  sqlite3DbFree(db, *pz);
-  *pz = z;
-}
-
-/*
-** Call this routine to record the fact that an OOM (out-of-memory) error
-** has happened.  This routine will set db->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 0;
-}
-
-/************** 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 etESCAPE_q    9  /* Strings with '\'' doubled.  %q */
-#define etESCAPE_Q    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 etESCAPE_w    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 */
-  char iNxt;               /* Next with same hash, or 0 for end of chain */
-} 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 table is searched by hash.  In the case of %C where C is the character
-** and that character has ASCII value j, then the hash is j%23.
-**
-** The order of the entries in fmtinfo[] and the hash chain was entered
-** manually, but based on the output of the following TCL script:
-*/
-#if 0  /*****  Beginning of script ******/
-foreach c {d s g z q Q w c o u x X f e E G i n % p T S r} {
-  scan $c %c x
-  set n($c) $x
-}
-set mx [llength [array names n]]
-puts "count: $mx"
-
-set mx 27
-puts "*********** mx=$mx ************"
-for {set r 0} {$r<$mx} {incr r} {
-  puts -nonewline [format %2d: $r]
-  foreach c [array names n] {
-    if {($n($c))%$mx==$r} {puts -nonewline " $c"}
-  }
-  puts ""
-}
-#endif /***** End of script ********/
-
-static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
-static const char aPrefix[] = "-x0\000X0";
-static const et_info fmtinfo[23] = {
-  /*  0 */  {  's',  0, 4, etSTRING,     0,  0,  1 },
-  /*  1 */  {  'E',  0, 1, etEXP,        14, 0,  0 },  /* Hash: 0 */
-  /*  2 */  {  'u', 10, 0, etDECIMAL,    0,  0,  3 },
-  /*  3 */  {  'G',  0, 1, etGENERIC,    14, 0,  0 },  /* Hash: 2 */
-  /*  4 */  {  'w',  0, 4, etESCAPE_w,   0,  0,  0 },
-  /*  5 */  {  'x', 16, 0, etRADIX,      16, 1,  0 },
-  /*  6 */  {  'c',  0, 0, etCHARX,      0,  0,  0 },  /* Hash: 7 */
-  /*  7 */  {  'z',  0, 4, etDYNSTRING,  0,  0,  6 },
-  /*  8 */  {  'd', 10, 1, etDECIMAL,    0,  0,  0 },
-  /*  9 */  {  'e',  0, 1, etEXP,        30, 0,  0 },
-  /* 10 */  {  'f',  0, 1, etFLOAT,      0,  0,  0 },
-  /* 11 */  {  'g',  0, 1, etGENERIC,    30, 0,  0 },
-  /* 12 */  {  'Q',  0, 4, etESCAPE_Q,   0,  0,  0 },
-  /* 13 */  {  'i', 10, 1, etDECIMAL,    0,  0,  0 },
-  /* 14 */  {  '%',  0, 0, etPERCENT,    0,  0, 16 },
-  /* 15 */  {  'T',  0, 0, etTOKEN,      0,  0,  0 },
-  /* 16 */  {  'S',  0, 0, etSRCITEM,    0,  0,  0 },  /* Hash: 14 */
-  /* 17 */  {  'X', 16, 0, etRADIX,      0,  4,  0 },  /* Hash: 19 */
-  /* 18 */  {  'n',  0, 0, etSIZE,       0,  0,  0 },
-  /* 19 */  {  'o',  8, 0, etRADIX,      0,  2, 17 },
-  /* 20 */  {  'p', 16, 0, etPOINTER,    0,  1,  0 },
-  /* 21 */  {  'q',  0, 4, etESCAPE_q,   0,  0,  0 },
-  /* 22 */  {  'r', 10, 1, etORDINAL,    0,  0,  0 }
-};
-
-/* Additional Notes:
-**
-**    %S    Takes a pointer to SrcItem.  Shows name or database.name
-**    %!S   Like %S but prefer the zName over the zAlias
-*/
-
-/*
-** 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 = sqlite3_malloc(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 */
-  double realvalue;          /* Value for real types */
-  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 */
-  int exp, e2;               /* exponent of real numbers */
-  etByte flag_dp;            /* True if decimal point should be shown */
-  etByte flag_rtz;           /* True if trailing zeros should be removed */
-
-  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
-      fmt = strchr(fmt, '%');
-      if( fmt==0 ){
-        fmt = bufpt + strlen(bufpt);
-      }
-#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 */
-#ifdef SQLITE_EBCDIC
-    /* The hash table only works for ASCII.  For EBCDIC, we need to do
-    ** a linear search of the table */
-    infop = &fmtinfo[0];
-    xtype = etINVALID;
-    for(idx=0; idx<ArraySize(fmtinfo); idx++){
-      if( c==fmtinfo[idx].fmttype ){
-        infop = &fmtinfo[idx];
-        xtype = infop->type;
-        break;
-      }
-    }
-#else
-    /* Fast hash-table lookup */
-    assert( ArraySize(fmtinfo)==23 );
-    idx = ((unsigned)c) % 23;
-    if( fmtinfo[idx].fmttype==c
-     || fmtinfo[idx = fmtinfo[idx].iNxt].fmttype==c
-    ){
-      infop = &fmtinfo[idx];
-      xtype = infop->type;
-    }else{
-      infop = &fmtinfo[0];
-      xtype = etINVALID;
-    }
-#endif
-
-    /*
-    ** 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 WHERETRACE_ENABLED
-        if( xtype==etPOINTER && sqlite3WhereTrace & 0x100000 ) longvalue = 0;
-#endif
-#if TREETRACE_ENABLED
-        if( xtype==etPOINTER && sqlite3TreeTrace & 0x100000 ) longvalue = 0;
-#endif
-
-        if( longvalue==0 ) flag_alternateform = 0;
-        if( flag_zeropad && precision<width-(prefix!=0) ){
-          precision = width-(prefix!=0);
-        }
-        if( precision<etBUFSIZE-10-etBUFSIZE/3 ){
-          nOut = etBUFSIZE;
-          zOut = buf;
-        }else{
-          u64 n;
-          n = (u64)precision + 10;
-          if( cThousand ) n += precision/3;
-          zOut = zExtra = printfTempBuf(pAccum, n);
-          if( zOut==0 ) return;
-          nOut = (int)n;
-        }
-        bufpt = &zOut[nOut-1];
-        if( xtype==etORDINAL ){
-          static const char zOrd[] = "thstndrd";
-          int x = (int)(longvalue % 10);
-          if( x>=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);
-        if( precision>length ){                         /* zero pad */
-          int nn = precision-length;
-          bufpt -= nn;
-          memset(bufpt,'0',nn);
-          length = precision;
-        }
-        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: {
-        FpDecode s;
-        int iRound;
-        int j;
-        i64 szBufNeeded;       /* Size needed to hold the output */
-
-        if( bArgList ){
-          realvalue = getDoubleArg(pArgList);
-        }else{
-          realvalue = va_arg(ap,double);
-        }
-        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( xtype==etFLOAT ){
-          iRound = -precision;
-        }else if( xtype==etGENERIC ){
-          if( precision==0 ) precision = 1;
-          iRound = precision;
-        }else{
-          iRound = precision+1;
-        }
-        sqlite3FpDecode(&s, realvalue, iRound, flag_altform2 ? 20 : 16);
-        if( s.isSpecial ){
-          if( s.isSpecial==2 ){
-            bufpt = flag_zeropad ? "null" : "NaN";
-            length = sqlite3Strlen30(bufpt);
-            break;
-          }else if( flag_zeropad ){
-            s.z[0] = '9';
-            s.iDP = 1000;
-            s.n = 1;
-          }else{
-            memcpy(buf, "-Inf", 5);
-            bufpt = buf;
-            if( s.sign=='-' ){
-              /* no-op */
-            }else if( flag_prefix ){
-              buf[0] = flag_prefix;
-            }else{
-              bufpt++;
-            }
-            length = sqlite3Strlen30(bufpt);
-            break;
-          }
-        }
-        if( s.sign=='-' ){
-          if( flag_alternateform
-           && !flag_prefix
-           && xtype==etFLOAT
-           && s.iDP<=iRound
-          ){
-            /* Suppress the minus sign if all of the following are true:
-            **   *  The value displayed is zero
-            **   *  The '#' flag is used
-            **   *  The '+' flag is not used, and
-            **   *  The format is %f
-            */
-            prefix = 0;
-          }else{
-            prefix = '-';
-          }
-        }else{
-          prefix = flag_prefix;
-        }
-
-        exp = s.iDP-1;
-
-        /*
-        ** If the field type is etGENERIC, then convert to either etEXP
-        ** or etFLOAT, as appropriate.
-        */
-        if( xtype==etGENERIC ){
-          assert( precision>0 );
-          precision--;
-          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 = s.iDP - 1;
-        }
-
-        szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+10;
-        if( cThousand && e2>0 ) szBufNeeded += (e2+2)/3;
-        if( szBufNeeded + pAccum->nChar >= pAccum->nAlloc ){
-          if( pAccum->mxAlloc==0 && pAccum->accError==0 ){
-            /* Unable to allocate space in pAccum, perhaps because it
-            ** is coming from sqlite3_snprintf() or similar.  We'll have
-            ** to render into temporary space and the memcpy() it over. */
-            bufpt = sqlite3_malloc(szBufNeeded);
-            if( bufpt==0 ){
-              sqlite3StrAccumSetError(pAccum, SQLITE_NOMEM);
-              return;
-            }
-            zExtra = bufpt;
-          }else if( sqlite3StrAccumEnlarge(pAccum, szBufNeeded)<szBufNeeded ){
-            width = length = 0;
-            break;
-          }else{
-            bufpt = pAccum->zText + pAccum->nChar;
-          }
-        }else{
-          bufpt = pAccum->zText + pAccum->nChar;
-        }
-        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 */
-        j = 0;
-        assert( s.n>0 );
-        if( e2<0 ){
-          *(bufpt++) = '0';
-        }else if( cThousand ){
-          for(; e2>=0; e2--){
-            *(bufpt++) = j<s.n ? s.z[j++] : '0';
-            if( (e2%3)==0 && e2>1 ) *(bufpt++) = ',';
-          }
-        }else{
-          j = e2+1;
-          if( j>s.n ) j = s.n;
-          memcpy(bufpt, s.z, j);
-          bufpt += j;
-          e2 -= j;
-          if( e2>=0 ){
-            memset(bufpt, '0', e2+1);
-            bufpt += e2+1;
-            e2 = -1;
-          }
-        }
-        /* The decimal point */
-        if( flag_dp ){
-          *(bufpt++) = '.';
-        }
-        /* "0" digits after the decimal point but before the first
-        ** significant digit of the number */
-        if( e2<(-1) && precision>0 ){
-          int nn = -1-e2;
-          if( nn>precision ) nn = precision;
-          memset(bufpt, '0', nn);
-          bufpt += nn;
-          precision -= nn;
-        }
-        /* Significant digits after the decimal point */
-        if( precision>0 ){
-          int nn = s.n - j;
-          if( NEVER(nn>precision) ) nn = precision;
-          if( nn>0 ){
-            memcpy(bufpt, s.z+j, nn);
-            bufpt += nn;
-            precision -= nn;
-          }
-          if( precision>0 && !flag_rtz ){
-            memset(bufpt, '0', precision);
-            bufpt += precision;
-          }
-        }
-        /* 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 ){
-          exp = s.iDP - 1;
-          *(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 */
-        }
-
-        length = (int)(bufpt-zOut);
-        assert( length <= szBufNeeded );
-        if( length<width ){
-          i64 nPad = width - length;
-          if( flag_leftjustify ){
-            memset(bufpt, ' ', nPad);
-          }else if( !flag_zeropad ){
-            memmove(zOut+nPad, zOut, length);
-            memset(zOut, ' ', nPad);
-          }else{
-            int adj = prefix!=0;
-            memmove(zOut+nPad+adj, zOut+adj, length-adj);
-            memset(zOut+adj, '0', nPad);
-          }
-          length = width;
-        }
-
-        if( zExtra==0 ){
-          /* The result is being rendered directory into pAccum.  This
-          ** is the command and fast case */
-          pAccum->nChar += length;
-          zOut[length] = 0;
-          continue;
-        }else{
-          /* We were unable to render directly into pAccum because we
-          ** couldn't allocate sufficient memory.  We need to memcpy()
-          ** the rendering (or some prefix thereof) into the output
-          ** buffer. */
-          bufpt[0] = 0;
-          bufpt = zExtra;
-          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);
-          length = sqlite3AppendOneUtf8Character(buf, ch);
-        }
-        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( sqlite3StrAccumEnlargeIfNeeded(pAccum, nCopyBytes) ){
-              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; length<precision && bufpt[length]; length++){}
-          }
-        }else{
-          length = 0x7fffffff & (int)strlen(bufpt);
-        }
-      adjust_width_for_utf8:
-        if( flag_altform2 && width>0 ){
-          /* 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 etESCAPE_q:          /* %q: Escape ' characters */
-      case etESCAPE_Q:          /* %Q: Escape ' and enclose in '...' */
-      case etESCAPE_w: {        /* %w: Escape " characters */
-        i64 i, j, k, n;
-        int needQuote = 0;
-        char ch;
-        char *escarg;
-        char q;
-
-        if( bArgList ){
-          escarg = getTextArg(pArgList);
-        }else{
-          escarg = va_arg(ap,char*);
-        }
-        if( escarg==0 ){
-          escarg = (xtype==etESCAPE_Q ? "NULL" : "(NULL)");
-        }else if( xtype==etESCAPE_Q ){
-          needQuote = 1;
-        }
-        if( xtype==etESCAPE_w ){
-          q = '"';
-          flag_alternateform = 0;
-        }else{
-          q = '\'';
-        }
-        /* 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++; }
-          }
-        }
-        if( flag_alternateform ){
-          /* For %#q, do unistr()-style backslash escapes for
-          ** all control characters, and for backslash itself.
-          ** For %#Q, do the same but only if there is at least
-          ** one control character. */
-          u32 nBack = 0;
-          u32 nCtrl = 0;
-          for(k=0; k<i; k++){
-            if( escarg[k]=='\\' ){
-              nBack++;
-            }else if( ((u8*)escarg)[k]<=0x1f ){
-              nCtrl++;
-            }
-          }
-          if( nCtrl || xtype==etESCAPE_q ){
-            n += nBack + 5*nCtrl;
-            if( xtype==etESCAPE_Q ){
-              n += 10;
-              needQuote = 2;
-            }
-          }else{
-            flag_alternateform = 0;
-          }
-        }
-        n += i + 3;
-        if( n>etBUFSIZE ){
-          bufpt = zExtra = printfTempBuf(pAccum, n);
-          if( bufpt==0 ) return;
-        }else{
-          bufpt = buf;
-        }
-        j = 0;
-        if( needQuote ){
-          if( needQuote==2 ){
-            memcpy(&bufpt[j], "unistr('", 8);
-            j += 8;
-          }else{
-            bufpt[j++] = '\'';
-          }
-        }
-        k = i;
-        if( flag_alternateform ){
-          for(i=0; i<k; i++){
-            bufpt[j++] = ch = escarg[i];
-            if( ch==q ){
-              bufpt[j++] = ch;
-            }else if( ch=='\\' ){
-              bufpt[j++] = '\\';
-            }else if( ((unsigned char)ch)<=0x1f ){
-              bufpt[j-1] = '\\';
-              bufpt[j++] = 'u';
-              bufpt[j++] = '0';
-              bufpt[j++] = '0';
-              bufpt[j++] = ch>=0x10 ? '1' : '0';
-              bufpt[j++] = "0123456789abcdef"[ch&0xf];
-            }
-          }
-        }else{
-          for(i=0; i<k; i++){
-            bufpt[j++] = ch = escarg[i];
-            if( ch==q ) bufpt[j++] = ch;
-          }
-        }
-        if( needQuote ){
-          bufpt[j++] = '\'';
-          if( needQuote==2 ) bufpt[j++] = ')';
-        }
-        bufpt[j] = 0;
-        length = j;
-        goto adjust_width_for_utf8;
-      }
-      case etTOKEN: {
-        if( (pAccum->printfFlags & 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->fg.fixedSchema==0
-           && pItem->fg.isSubquery==0
-           && pItem->u4.zDatabase!=0
-          ){
-            sqlite3_str_appendall(pAccum, pItem->u4.zDatabase);
-            sqlite3_str_append(pAccum, ".", 1);
-          }
-          sqlite3_str_appendall(pAccum, pItem->zName);
-        }else if( pItem->zAlias ){
-          sqlite3_str_appendall(pAccum, pItem->zAlias);
-        }else if( ALWAYS(pItem->fg.isSubquery) ){/* Because of tag-20240424-1 */
-          Select *pSel = pItem->u4.pSubq->pSelect;
-          assert( pSel!=0 );
-          if( pSel->selFlags & SF_NestedFrom ){
-            sqlite3_str_appendf(pAccum, "(join-%u)", pSel->selId);
-          }else if( pSel->selFlags & SF_MultiValue ){
-            assert( !pItem->fg.isTabFunc && !pItem->fg.isIndexedBy );
-            sqlite3_str_appendf(pAccum, "%u-ROW VALUES CLAUSE",
-                                pItem->u1.nRow);
-          }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;
-  if( ExprHasProperty(pExpr, EP_FromDDL) ) 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;
-}
-
-SQLITE_PRIVATE int sqlite3StrAccumEnlargeIfNeeded(StrAccum *p, i64 N){
-  if( N + p->nChar >= p->nAlloc ){
-    sqlite3StrAccumEnlarge(p, N);
-  }
-  return p->accError;
-}
-
-/*
-** 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, 1+(u64)p->nChar );
-  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;
-}
-
-/* Truncate the text of the string to be no more than N bytes. */
-SQLITE_API void sqlite3_str_truncate(sqlite3_str *p, int N){
-  if( p!=0 && N>=0 && (u32)N<p->nChar ){
-    p->nChar = N;
-    p->zText[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;
-}
-
-/*
-** Destroy a dynamically allocate sqlite3_str object and all
-** of its content, all in one call.
-*/
-SQLITE_API void sqlite3_str_free(sqlite3_str *p){
-  if( p!=0 && p!=&sqlite3OomStr ){
-    sqlite3_str_reset(p);
-    sqlite3_free(p);
-  }
-}
-
-/*
-** 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;
-}
-
-/* Maximum size of an sqlite3_log() message. */
-#if defined(SQLITE_MAX_LOG_MESSAGE)
-  /* Leave the definition as supplied */
-#elif SQLITE_PRINT_BUF_SIZE*10>10000
-# define SQLITE_MAX_LOG_MESSAGE 10000
-#else
-# define SQLITE_MAX_LOG_MESSAGE (SQLITE_PRINT_BUF_SIZE*10)
-#endif
-
-/*
-** 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_MAX_LOG_MESSAGE];     /* 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);
-}
-
-
-/*****************************************************************************
-** Reference counted string/blob storage
-*****************************************************************************/
-
-/*
-** Increase the reference count of the string by one.
-**
-** The input parameter is returned.
-*/
-SQLITE_PRIVATE char *sqlite3RCStrRef(char *z){
-  RCStr *p = (RCStr*)z;
-  assert( p!=0 );
-  p--;
-  p->nRCRef++;
-  return z;
-}
-
-/*
-** Decrease the reference count by one.  Free the string when the
-** reference count reaches zero.
-*/
-SQLITE_PRIVATE void sqlite3RCStrUnref(void *z){
-  RCStr *p = (RCStr*)z;
-  assert( p!=0 );
-  p--;
-  assert( p->nRCRef>0 );
-  if( p->nRCRef>=2 ){
-    p->nRCRef--;
-  }else{
-    sqlite3_free(p);
-  }
-}
-
-/*
-** Create a new string that is capable of holding N bytes of text, not counting
-** the zero byte at the end.  The string is uninitialized.
-**
-** The reference count is initially 1.  Call sqlite3RCStrUnref() to free the
-** newly allocated string.
-**
-** This routine returns 0 on an OOM.
-*/
-SQLITE_PRIVATE char *sqlite3RCStrNew(u64 N){
-  RCStr *p = sqlite3_malloc64( N + sizeof(*p) + 1 );
-  if( p==0 ) return 0;
-  p->nRCRef = 1;
-  return (char*)&p[1];
-}
-
-/*
-** Change the size of the string so that it is able to hold N bytes.
-** The string might be reallocated, so return the new allocation.
-*/
-SQLITE_PRIVATE char *sqlite3RCStrResize(char *z, u64 N){
-  RCStr *p = (RCStr*)z;
-  RCStr *pNew;
-  assert( p!=0 );
-  p--;
-  assert( p->nRCRef==1 );
-  pNew = sqlite3_realloc64(p, N+sizeof(RCStr)+1);
-  if( pNew==0 ){
-    sqlite3_free(p);
-    return 0;
-  }else{
-    return (char*)&pNew[1];
-  }
-}
-
-/************** 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; i<p->iLevel && 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; i<nCol; i++){
-    u16 flg = aCol[i].colFlags;
-    int colMoreToFollow = i<(nCol - 1);
-    sqlite3TreeViewPush(&pView, colMoreToFollow);
-    sqlite3TreeViewLine(pView, 0);
-    printf(" %s", aCol[i].zCnName);
-    switch( aCol[i].eCType ){
-      case COLTYPE_ANY:      printf(" ANY");        break;
-      case COLTYPE_BLOB:     printf(" BLOB");       break;
-      case COLTYPE_INT:      printf(" INT");        break;
-      case COLTYPE_INTEGER:  printf(" INTEGER");    break;
-      case COLTYPE_REAL:     printf(" REAL");       break;
-      case COLTYPE_TEXT:     printf(" TEXT");       break;
-      case COLTYPE_CUSTOM: {
-        if( flg & COLFLAG_HASTYPE ){
-          const char *z = aCol[i].zCnName;
-          z += strlen(z)+1;
-          printf(" X-%s", z);
-          break;
-        }
-      }
-    }
-    if( flg & COLFLAG_PRIMKEY ) printf(" PRIMARY KEY");
-    if( flg & COLFLAG_HIDDEN ) printf(" HIDDEN");
-#ifdef COLFLAG_NOEXPAND
-    if( flg & COLFLAG_NOEXPAND ) printf(" NO-EXPAND");
-#endif
-    if( flg ) printf(" flags=%04x", flg);
-    printf("\n");
-    fflush(stdout);
-    sqlite3TreeViewPop(&pView);
-  }
-  sqlite3TreeViewPop(&pView);
-}
-
-/*
-** Generate a human-readable description of a WITH clause.
-*/
-SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 moreToFollow){
-  int i;
-  if( pWith==0 ) return;
-  if( pWith->nCte==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; i<pWith->nCte; 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; j<pCte->pCols->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, i<pWith->nCte-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; i<pSrc->nSrc; 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->pSTab ){
-      sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx%s",
-           pItem->pSTab->zName, pItem->pSTab->nCol, pItem->pSTab,
-           pItem->colUsed,
-           pItem->fg.rowidUsed ? "+rowid" : "");
-    }
-    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 ){
-      static const char *aMat[] = {",MAT", "", ",NO-MAT"};
-      sqlite3_str_appendf(&x, " CteUse=%d%s",
-                          pItem->u2.pCteUse->nUse,
-                          aMat[pItem->u2.pCteUse->eM10d]);
-    }
-    if( pItem->fg.isOn || (pItem->fg.isUsing==0 && pItem->u3.pOn!=0) ){
-      sqlite3_str_appendf(&x, " isOn");
-    }
-    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");
-    if( pItem->fg.fixedSchema )    sqlite3_str_appendf(&x, " fixedSchema");
-    if( pItem->fg.hadSchema )      sqlite3_str_appendf(&x, " hadSchema");
-    if( pItem->fg.isSubquery )     sqlite3_str_appendf(&x, " isSubquery");
-
-    sqlite3StrAccumFinish(&x);
-    sqlite3TreeViewItem(pView, zLine, i<pSrc->nSrc-1);
-    n = 0;
-    if( pItem->fg.isSubquery ) n++;
-    if( pItem->fg.isTabFunc ) n++;
-    if( pItem->fg.isUsing || pItem->u3.pOn!=0 ) n++;
-    if( pItem->fg.isUsing ){
-      sqlite3TreeViewIdList(pView, pItem->u3.pUsing, (--n)>0, "USING");
-    }else if( pItem->u3.pOn!=0 ){
-      sqlite3TreeViewItem(pView, "ON", (--n)>0);
-      sqlite3TreeViewExpr(pView, pItem->u3.pOn, 0);
-      sqlite3TreeViewPop(&pView);
-    }
-    if( pItem->fg.isSubquery ){
-      assert( n==1 );
-      if( pItem->pSTab ){
-        Table *pTab = pItem->pSTab;
-        sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1);
-      }
-      assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem) );
-      sqlite3TreeViewSelect(pView, pItem->u4.pSubq->pSelect, 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 && p->pSrc->nAlloc ) 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 && p->pSrc->nAlloc ){
-      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", 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);
-    if( pWin->eFrmType==TK_FILTER ) return;
-  }
-  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!=0 && pWin->eFrmType!=TK_FILTER ) 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!=0 && pWin->eFrmType!=TK_FILTER ){
-    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( sqlite3ExprSkipCollateAndLikely(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 = IsWindowFunc(pExpr) ? 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 || pExpr->pLeft, 0);
-        if( pExpr->pLeft ){
-          Expr *pOB = pExpr->pLeft;
-          assert( pOB->op==TK_ORDER );
-          assert( ExprUseXList(pOB) );
-          sqlite3TreeViewExprList(pView, pOB->x.pList, pWin!=0, "ORDERBY");
-        }
-      }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-      if( pWin ){
-        sqlite3TreeViewWindow(pView, pWin, 0);
-      }
-#endif
-      break;
-    }
-    case TK_ORDER: {
-      sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, "ORDERBY");
-      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%s", zFlgs);
-      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", zType);
-      sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
-      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; i<pList->nExpr; i++){
-      int j = pList->a[i].u.x.iOrderByCol;
-      u8 sortFlags = pList->a[i].fg.sortFlags;
-      char *zName = pList->a[i].zEName;
-      int moreToFollow = i<pList->nExpr - 1;
-      if( j || zName || sortFlags ){
-        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);
-        }
-        if( sortFlags & KEYINFO_ORDER_DESC ){
-          fprintf(stdout, "DESC ");
-        }else if( sortFlags & KEYINFO_ORDER_BIGNULL ){
-          fprintf(stdout, "NULLS-LAST");
-        }
-        fprintf(stdout, "\n");
-        fflush(stdout);
-      }
-      sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
-      if( j || zName || sortFlags ){
-        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; i<pList->nId; i++){
-      char *zName = pList->a[i].zName;
-      int moreToFollow = i<pList->nId - 1;
-      if( zName==0 ) zName = "(null)";
-      sqlite3TreeViewPush(&pView, moreToFollow);
-      sqlite3TreeViewLine(pView, 0);
-      fprintf(stdout, "%s\n", zName);
-      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.
-**
-** See Also:
-**
-**     sqlite3ShowWhereTerm() in where.c
-*/
-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){
-  TreeView *pView = 0;
-  sqlite3TreeViewPush(&pView, 0);
-  sqlite3TreeViewLine(pView, "SRCLIST");
-  sqlite3TreeViewSrcList(pView,p);
-  sqlite3TreeViewPop(&pView);
-}
-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 <pthread.h> */
-
-/* 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 <process.h>
-
-/* 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);
-    (void)bRc;  /* Prevent warning when assert() is a no-op */
-    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 <assert.h> */
-/* #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);                                       \
-  }                                                                 \
-}
-
-/*
-** Write a single UTF8 character whose value is v into the
-** buffer starting at zOut.  zOut must be sized to hold at
-** least four bytes.  Return the number of bytes needed
-** to encode the new character.
-*/
-SQLITE_PRIVATE int sqlite3AppendOneUtf8Character(char *zOut, u32 v){
-  if( v<0x00080 ){
-    zOut[0] = (u8)(v & 0xff);
-    return 1;
-  }
-  if( v<0x00800 ){
-    zOut[0] = 0xc0 + (u8)((v>>6) & 0x1f);
-    zOut[1] = 0x80 + (u8)(v & 0x3f);
-    return 2;
-  }
-  if( v<0x10000 ){
-    zOut[0] = 0xe0 + (u8)((v>>12) & 0x0f);
-    zOut[1] = 0x80 + (u8)((v>>6) & 0x3f);
-    zOut[2] = 0x80 + (u8)(v & 0x3f);
-    return 3;
-  }
-  zOut[0] = 0xf0 + (u8)((v>>18) & 0x07);
-  zOut[1] = 0x80 + (u8)((v>>12) & 0x3f);
-  zOut[2] = 0x80 + (u8)((v>>6) & 0x3f);
-  zOut[3] = 0x80 + (u8)(v & 0x3f);
-  return 4;
-}
-
-/*
-** 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;
-}
-
-/*
-** Read a single UTF8 character out of buffer z[], but reading no
-** more than n characters from the buffer.  z[] is not zero-terminated.
-**
-** Return the number of bytes used to construct the character.
-**
-** Invalid UTF8 might generate a strange result.  No effort is made
-** to detect invalid UTF8.
-**
-** At most 4 bytes will be read out of z[].  The return value will always
-** be between 1 and 4.
-*/
-SQLITE_PRIVATE int sqlite3Utf8ReadLimited(
-  const u8 *z,
-  int n,
-  u32 *piOut
-){
-  u32 c;
-  int i = 1;
-  assert( n>0 );
-  c = z[0];
-  if( c>=0xc0 ){
-    c = sqlite3Utf8Trans1[c-0xc0];
-    if( n>4 ) n = 4;
-    while( i<n && (z[i] & 0xc0)==0x80 ){
-      c = (c<<6) + (0x3f & z[i]);
-      i++;
-    }
-  }
-  *piOut = c;
-  return i;
-}
-
-
-/*
-** 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( zIn<zTerm ){
-      temp = *zIn;
-      *zIn = *(zIn+1);
-      zIn++;
-      *zIn++ = temp;
-    }
-    pMem->enc = 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<zTerm ){
-        READ_UTF8(zIn, zTerm, c);
-        WRITE_UTF16LE(z, c);
-      }
-    }else{
-      assert( desiredEnc==SQLITE_UTF16BE );
-      /* UTF-8 -> UTF-16 Big-endian */
-      while( zIn<zTerm ){
-        READ_UTF8(zIn, zTerm, c);
-        WRITE_UTF16BE(z, c);
-      }
-    }
-    pMem->n = (int)(z - zOut);
-    *z++ = 0;
-  }else{
-    assert( desiredEnc==SQLITE_UTF8 );
-    if( pMem->enc==SQLITE_UTF16LE ){
-      /* UTF-16 Little-endian -> UTF-8 */
-      while( zIn<zTerm ){
-        c = *(zIn++);
-        c += (*(zIn++))<<8;
-        if( c>=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<zTerm ){
-            int c2 = (*zIn++);
-            c2 += ((*zIn++)<<8);
-            c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);
-          }
-#endif
-        }
-        WRITE_UTF8(z, c);
-      }
-    }else{
-      /* UTF-16 Big-endian -> UTF-8 */
-      while( zIn<zTerm ){
-        c = (*(zIn++))<<8;
-        c += *(zIn++);
-        if( c>=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( zIn<zTerm ){
-            int c2 = ((*zIn++)<<8);
-            c2 += (*zIn++);
-            c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);
-          }
-#endif
-        }
-        WRITE_UTF8(z, c);
-      }
-    }
-    pMem->n = (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 && z<zTerm ){
-    SQLITE_SKIP_UTF8(z);
-    r++;
-  }
-  return r;
-}
-
-/* This test function is not currently used by the automated test-suite.
-** Hence it is only available in debug builds.
-*/
-#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
-/*
-** Translate UTF-8 to UTF-8.
-**
-** This has the effect of making sure that the string is well-formed
-** UTF-8.  Miscoded characters are removed.
-**
-** The translation is done in-place and aborted if the output
-** overruns the input.
-*/
-SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char *zIn){
-  unsigned char *zOut = zIn;
-  unsigned char *zStart = zIn;
-  u32 c;
-
-  while( zIn[0] && zOut<=zIn ){
-    c = sqlite3Utf8Read((const u8**)&zIn);
-    if( c!=0xfffd ){
-      WRITE_UTF8(zOut, c);
-    }
-  }
-  *zOut = 0;
-  return (int)(zOut - zStart);
-}
-#endif
-
-#ifndef SQLITE_OMIT_UTF16
-/*
-** Convert a UTF-16 string in the native encoding into a UTF-8 string.
-** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
-** be freed by the calling function.
-**
-** NULL is returned if there is an allocation error.
-*/
-SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
-  Mem m;
-  memset(&m, 0, sizeof(m));
-  m.db = db;
-  sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
-  sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);
-  if( db->mallocFailed ){
-    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 nByte bytes long.
-** Return the number of bytes in the first nChar unicode characters
-** in pZ.  nChar must be non-negative.  Surrogate pairs count as a single
-** character.
-*/
-SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nByte, int nChar){
-  int c;
-  unsigned char const *z = zIn;
-  unsigned char const *zEnd = &z[nByte-1];
-  int n = 0;
-
-  if( SQLITE_UTF16NATIVE==SQLITE_UTF16LE ) z++;
-  while( n<nChar && z<=zEnd ){
-    c = z[0];
-    z += 2;
-    if( c>=0xd8 && c<0xdc && z<=zEnd && 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 <stdarg.h> */
-#ifndef SQLITE_OMIT_FLOATING_POINT
-#include <math.h>
-#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 further 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 */
-
-#ifndef SQLITE_OMIT_FLOATING_POINT
-/*
-** Return true if the floating point value is NaN or +Inf or -Inf.
-*/
-SQLITE_PRIVATE int sqlite3IsOverflow(double x){
-  int rc;   /* The value return */
-  u64 y;
-  memcpy(&y,&x,sizeof(y));
-  rc = IsOvfl(y);
-  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;
-#if defined(SQLITE_USE_SEH) && !defined(SQLITE_OMIT_WAL)
-  if( rc==SQLITE_IOERR_IN_PAGE ){
-    int ii;
-    int iErr;
-    sqlite3BtreeEnterAll(db);
-    for(ii=0; ii<db->nDb; ii++){
-      if( db->aDb[ii].pBt ){
-        iErr = sqlite3PagerWalSystemErrno(sqlite3BtreePager(db->aDb[ii].pBt));
-        if( iErr ){
-          db->iSysErrno = iErr;
-        }
-      }
-    }
-    sqlite3BtreeLeaveAll(db);
-    return;
-  }
-#endif
-  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 ){
-    if( p->rc==SQLITE_INTERRUPT ){
-      p->nProgressSteps = 0;
-    }else if( (++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);
-}
-
-/*
-** Expression p is a QNUMBER (quoted number). Dequote the value in p->u.zToken
-** and set the type to INTEGER or FLOAT. "Quoted" integers or floats are those
-** that contain '_' characters that must be removed before further processing.
-*/
-SQLITE_PRIVATE void sqlite3DequoteNumber(Parse *pParse, Expr *p){
-  assert( p!=0 || pParse->db->mallocFailed );
-  if( p ){
-    const char *pIn = p->u.zToken;
-    char *pOut = p->u.zToken;
-    int bHex = (pIn[0]=='0' && (pIn[1]=='x' || pIn[1]=='X'));
-    int iValue;
-    assert( p->op==TK_QNUMBER );
-    p->op = TK_INTEGER;
-    do {
-      if( *pIn!=SQLITE_DIGIT_SEPARATOR ){
-        *pOut++ = *pIn;
-        if( *pIn=='e' || *pIn=='E' || *pIn=='.' ) p->op = TK_FLOAT;
-      }else{
-        if( (bHex==0 && (!sqlite3Isdigit(pIn[-1]) || !sqlite3Isdigit(pIn[1])))
-         || (bHex==1 && (!sqlite3Isxdigit(pIn[-1]) || !sqlite3Isxdigit(pIn[1])))
-        ){
-          sqlite3ErrorMsg(pParse, "unrecognized token: \"%s\"", p->u.zToken);
-        }
-      }
-    }while( *pIn++ );
-    if( bHex ) p->op = TK_INTEGER;
-
-    /* tag-20240227-a: If after dequoting, the number is an integer that
-    ** fits in 32 bits, then it must be converted into EP_IntValue.  Other
-    ** parts of the code expect this.  See also tag-20240227-b. */
-    if( p->op==TK_INTEGER && sqlite3GetInt32(p->u.zToken, &iValue) ){
-      p->u.iValue = iValue;
-      p->flags |= EP_IntValue;
-    }
-  }
-}
-
-/*
-** 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; i<p->n-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;
-}
-
-#if !defined(SQLITE_DISABLE_INTRINSIC)               \
-  && (defined(__GNUC__) || defined(__clang__))       \
-  && (defined(__x86_64__) || defined(__aarch64__) || \
-      (defined(__riscv) && defined(__riscv_xlen) && (__riscv_xlen>32)))
-#define SQLITE_USE_UINT128
-#endif
-
-/*
-** Two inputs are multiplied to get a 128-bit result.  Write the
-** lower 64-bits of the result into *pLo, and return the high-order
-** 64 bits.
-*/
-static u64 sqlite3Multiply128(u64 a, u64 b, u64 *pLo){
-#if defined(SQLITE_USE_UINT128)
-  __uint128_t r = (__uint128_t)a * b;
-  *pLo = (u64)r;
-  return (u64)(r>>64);
-#elif defined(_WIN64) && !defined(SQLITE_DISABLE_INTRINSIC)
-  *pLo = a*b;
-  return __umulh(a, b);
-#else
-  u64 a0 = (u32)a;
-  u64 a1 = a >> 32;
-  u64 b0 = (u32)b;
-  u64 b1 = b >> 32;
-  u64 a0b0 = a0 * b0;
-  u64 a1b1 = a1 * b1;
-  u64 a0b1 = a0 * b1;
-  u64 a1b0 = a1 * b0;
-  u64 t = (a0b0 >> 32) + (u32)a0b1 + (u32)a1b0;
-  *pLo = (a0b0 & UINT64_C(0xffffffff)) | (t << 32);
-  return a1b1 + (a0b1>>32) + (a1b0>>32) + (t>>32);
-#endif
-}
-
-/*
-** A is an unsigned 96-bit integer formed by (a<<32)+aLo.
-** B is an unsigned 64-bit integer.
-**
-** Compute the upper 96 bits of 160-bit result of A*B.
-**
-** Write ((A*B)>>64 & 0xffffffff) (the middle 32 bits of A*B)
-** into *pLo.  Return the upper 64 bits of A*B.
-**
-** The lower 64 bits of A*B are discarded.
-*/
-static u64 sqlite3Multiply160(u64 a, u32 aLo, u64 b, u32 *pLo){
-#if defined(SQLITE_USE_UINT128)
-  __uint128_t r = (__uint128_t)a * b;
-  r += ((__uint128_t)aLo * b) >> 32;
-  *pLo = (r>>32)&0xffffffff;
-  return r>>64;
-#elif defined(_WIN64) && !defined(SQLITE_DISABLE_INTRINSIC)
-  u64 r1_hi = __umulh(a,b);
-  u64 r1_lo = a*b;
-  u64 r2 = (__umulh((u64)aLo,b)<<32) + ((aLo*b)>>32);
-  u64 t = r1_lo + r2;
-  if( t<r1_lo ) r1_hi++;
-  *pLo = t>>32;
-  return r1_hi;
-#else
-  u64 x2 = a>>32;
-  u64 x1 = a&0xffffffff;
-  u64 x0 = aLo;
-  u64 y1 = b>>32;
-  u64 y0 = b&0xffffffff;
-  u64 x2y1 = x2*y1;
-  u64 r4 = x2y1>>32;
-  u64 x2y0 = x2*y0;
-  u64 x1y1 = x1*y1;
-  u64 r3 = (x2y1 & 0xffffffff) + (x2y0 >>32) + (x1y1 >>32);
-  u64 x1y0 = x1*y0;
-  u64 x0y1 = x0*y1;
-  u64 r2 = (x2y0 & 0xffffffff) + (x1y1 & 0xffffffff) +
-             (x1y0 >>32) + (x0y1>>32);
-  u64 x0y0 = x0*y0;
-  u64 r1 = (x1y0 & 0xffffffff) + (x0y1 & 0xffffffff) +
-             (x0y0 >>32);
-  r2 += r1>>32;
-  r3 += r2>>32;
-  *pLo = r2&0xffffffff;
-  return (r4<<32) + r3;
-#endif
-}
-
-#undef SQLITE_USE_UINT128
-
-/*
-** Return a u64 with the N-th bit set.
-*/
-#define U64_BIT(N)  (((u64)1)<<(N))
-
-/*
-** Range of powers of 10 that we need to deal with when converting
-** IEEE754 doubles to and from decimal.
-*/
-#define POWERSOF10_FIRST (-348)
-#define POWERSOF10_LAST  (+347)
-
-/*
-** For any p between -348 and +347, return the integer part of
-**
-**    pow(10,p) * pow(2,63-pow10to2(p))
-**
-** Or, in other words, for any p in range, return the most significant
-** 64 bits of pow(10,p).  The pow(10,p) value is shifted left or right,
-** as appropriate so the most significant 64 bits fit exactly into a
-** 64-bit unsigned integer.
-**
-** Write into *pLo the next 32 significant bits of the answer after
-** the first 64.
-**
-** Algorithm:
-**
-** (1) For p between 0 and 26, return the value directly from the aBase[]
-**     lookup table.
-**
-** (2) For p outside the range 0 to 26, use aScale[] for the initial value
-**     then refine that result (if necessary) by a single multiplication
-**     against aBase[].
-**
-** The constant tables aBase[], aScale[], and aScaleLo[] are generated
-** by the C program at ../tool/mkfptab.c run with the --round option.
-*/
-static u64 powerOfTen(int p, u32 *pLo){
-  static const u64 aBase[] = {
-    UINT64_C(0x8000000000000000), /*  0: 1.0e+0 << 63 */
-    UINT64_C(0xa000000000000000), /*  1: 1.0e+1 << 60 */
-    UINT64_C(0xc800000000000000), /*  2: 1.0e+2 << 57 */
-    UINT64_C(0xfa00000000000000), /*  3: 1.0e+3 << 54 */
-    UINT64_C(0x9c40000000000000), /*  4: 1.0e+4 << 50 */
-    UINT64_C(0xc350000000000000), /*  5: 1.0e+5 << 47 */
-    UINT64_C(0xf424000000000000), /*  6: 1.0e+6 << 44 */
-    UINT64_C(0x9896800000000000), /*  7: 1.0e+7 << 40 */
-    UINT64_C(0xbebc200000000000), /*  8: 1.0e+8 << 37 */
-    UINT64_C(0xee6b280000000000), /*  9: 1.0e+9 << 34 */
-    UINT64_C(0x9502f90000000000), /* 10: 1.0e+10 << 30 */
-    UINT64_C(0xba43b74000000000), /* 11: 1.0e+11 << 27 */
-    UINT64_C(0xe8d4a51000000000), /* 12: 1.0e+12 << 24 */
-    UINT64_C(0x9184e72a00000000), /* 13: 1.0e+13 << 20 */
-    UINT64_C(0xb5e620f480000000), /* 14: 1.0e+14 << 17 */
-    UINT64_C(0xe35fa931a0000000), /* 15: 1.0e+15 << 14 */
-    UINT64_C(0x8e1bc9bf04000000), /* 16: 1.0e+16 << 10 */
-    UINT64_C(0xb1a2bc2ec5000000), /* 17: 1.0e+17 << 7 */
-    UINT64_C(0xde0b6b3a76400000), /* 18: 1.0e+18 << 4 */
-    UINT64_C(0x8ac7230489e80000), /* 19: 1.0e+19 >> 0 */
-    UINT64_C(0xad78ebc5ac620000), /* 20: 1.0e+20 >> 3 */
-    UINT64_C(0xd8d726b7177a8000), /* 21: 1.0e+21 >> 6 */
-    UINT64_C(0x878678326eac9000), /* 22: 1.0e+22 >> 10 */
-    UINT64_C(0xa968163f0a57b400), /* 23: 1.0e+23 >> 13 */
-    UINT64_C(0xd3c21bcecceda100), /* 24: 1.0e+24 >> 16 */
-    UINT64_C(0x84595161401484a0), /* 25: 1.0e+25 >> 20 */
-    UINT64_C(0xa56fa5b99019a5c8), /* 26: 1.0e+26 >> 23 */
-  };
-  static const u64 aScale[] = {
-    UINT64_C(0x8049a4ac0c5811ae), /*  0: 1.0e-351 << 1229 */
-    UINT64_C(0xcf42894a5dce35ea), /*  1: 1.0e-324 << 1140 */
-    UINT64_C(0xa76c582338ed2621), /*  2: 1.0e-297 << 1050 */
-    UINT64_C(0x873e4f75e2224e68), /*  3: 1.0e-270 << 960 */
-    UINT64_C(0xda7f5bf590966848), /*  4: 1.0e-243 << 871 */
-    UINT64_C(0xb080392cc4349dec), /*  5: 1.0e-216 << 781 */
-    UINT64_C(0x8e938662882af53e), /*  6: 1.0e-189 << 691 */
-    UINT64_C(0xe65829b3046b0afa), /*  7: 1.0e-162 << 602 */
-    UINT64_C(0xba121a4650e4ddeb), /*  8: 1.0e-135 << 512 */
-    UINT64_C(0x964e858c91ba2655), /*  9: 1.0e-108 << 422 */
-    UINT64_C(0xf2d56790ab41c2a2), /* 10: 1.0e-81 << 333 */
-    UINT64_C(0xc428d05aa4751e4c), /* 11: 1.0e-54 << 243 */
-    UINT64_C(0x9e74d1b791e07e48), /* 12: 1.0e-27 << 153 */
-    UINT64_C(0xcccccccccccccccc), /* 13: 1.0e-1 << 67 (special case) */
-    UINT64_C(0xcecb8f27f4200f3a), /* 14: 1.0e+27 >> 26 */
-    UINT64_C(0xa70c3c40a64e6c51), /* 15: 1.0e+54 >> 116 */
-    UINT64_C(0x86f0ac99b4e8dafd), /* 16: 1.0e+81 >> 206 */
-    UINT64_C(0xda01ee641a708de9), /* 17: 1.0e+108 >> 295 */
-    UINT64_C(0xb01ae745b101e9e4), /* 18: 1.0e+135 >> 385 */
-    UINT64_C(0x8e41ade9fbebc27d), /* 19: 1.0e+162 >> 475 */
-    UINT64_C(0xe5d3ef282a242e81), /* 20: 1.0e+189 >> 564 */
-    UINT64_C(0xb9a74a0637ce2ee1), /* 21: 1.0e+216 >> 654 */
-    UINT64_C(0x95f83d0a1fb69cd9), /* 22: 1.0e+243 >> 744 */
-    UINT64_C(0xf24a01a73cf2dccf), /* 23: 1.0e+270 >> 833 */
-    UINT64_C(0xc3b8358109e84f07), /* 24: 1.0e+297 >> 923 */
-    UINT64_C(0x9e19db92b4e31ba9), /* 25: 1.0e+324 >> 1013 */
-  };
-  static const unsigned int aScaleLo[] = {
-    0x205b896d, /*  0: 1.0e-351 << 1229 */
-    0x52064cad, /*  1: 1.0e-324 << 1140 */
-    0xaf2af2b8, /*  2: 1.0e-297 << 1050 */
-    0x5a7744a7, /*  3: 1.0e-270 << 960 */
-    0xaf39a475, /*  4: 1.0e-243 << 871 */
-    0xbd8d794e, /*  5: 1.0e-216 << 781 */
-    0x547eb47b, /*  6: 1.0e-189 << 691 */
-    0x0cb4a5a3, /*  7: 1.0e-162 << 602 */
-    0x92f34d62, /*  8: 1.0e-135 << 512 */
-    0x3a6a07f9, /*  9: 1.0e-108 << 422 */
-    0xfae27299, /* 10: 1.0e-81 << 333 */
-    0xaa97e14c, /* 11: 1.0e-54 << 243 */
-    0x775ea265, /* 12: 1.0e-27 << 153 */
-    0xcccccccc, /* 13: 1.0e-1 << 67 (special case) */
-    0x00000000, /* 14: 1.0e+27 >> 26 */
-    0x999090b6, /* 15: 1.0e+54 >> 116 */
-    0x69a028bb, /* 16: 1.0e+81 >> 206 */
-    0xe80e6f48, /* 17: 1.0e+108 >> 295 */
-    0x5ec05dd0, /* 18: 1.0e+135 >> 385 */
-    0x14588f14, /* 19: 1.0e+162 >> 475 */
-    0x8f1668c9, /* 20: 1.0e+189 >> 564 */
-    0x6d953e2c, /* 21: 1.0e+216 >> 654 */
-    0x4abdaf10, /* 22: 1.0e+243 >> 744 */
-    0xbc633b39, /* 23: 1.0e+270 >> 833 */
-    0x0a862f81, /* 24: 1.0e+297 >> 923 */
-    0x6c07a2c2, /* 25: 1.0e+324 >> 1013 */
-  };
-  int g, n;
-  u64 s, x;
-  u32 lo;
-
-  assert( p>=POWERSOF10_FIRST && p<=POWERSOF10_LAST );
-  if( p<0 ){
-    if( p==(-1) ){
-      *pLo = aScaleLo[13];
-      return aScale[13];
-    }
-    g = p/27;
-    n = p%27;
-    if( n ){
-      g--;
-      n += 27;
-    }
-  }else if( p<27 ){
-    *pLo = 0;
-    return aBase[p];
-  }else{
-    g = p/27;
-    n = p%27;
-  }
-  s = aScale[g+13];
-  if( n==0 ){
-    *pLo = aScaleLo[g+13];
-    return s;
-  }
-  x = sqlite3Multiply160(s,aScaleLo[g+13],aBase[n],&lo);
-  if( (U64_BIT(63) & x)==0 ){
-    x  = x<<1 | ((lo>>31)&1);
-    lo = (lo<<1) | 1;
-  }
-  *pLo = lo;
-  return x;
-}
-
-/*
-** pow10to2(x) computes floor(log2(pow(10,x))).
-** pow2to10(y) computes floor(log10(pow(2,y))).
-**
-** Conceptually, pow10to2(p) converts a base-10 exponent p into
-** a corresponding base-2 exponent, and pow2to10(e) converts a base-2
-** exponent into a base-10 exponent.
-**
-** The conversions are based on the observation that:
-**
-**     ln(10.0)/ln(2.0) == 108853/32768     (approximately)
-**     ln(2.0)/ln(10.0) == 78913/262144     (approximately)
-**
-** These ratios are approximate, but they are accurate to 5 digits,
-** which is close enough for the usage here.  Right-shift is used
-** for division so that rounding of negative numbers happens in the
-** right direction.
-*/
-static int pwr10to2(int p){ return (p*108853) >> 15; }
-static int pwr2to10(int p){ return (p*78913) >> 18; }
-
-/*
-** Count leading zeros for a 64-bit unsigned integer.
-*/
-static int countLeadingZeros(u64 m){
-#if (defined(__GNUC__) || defined(__clang__)) \
-    && !defined(SQLITE_DISABLE_INTRINSIC)
-  return __builtin_clzll(m);
-#else
-  int n = 0;
-  if( m <= 0x00000000ffffffffULL) { n += 32; m <<= 32; }
-  if( m <= 0x0000ffffffffffffULL) { n += 16; m <<= 16; }
-  if( m <= 0x00ffffffffffffffULL) { n += 8;  m <<= 8;  }
-  if( m <= 0x0fffffffffffffffULL) { n += 4;  m <<= 4;  }
-  if( m <= 0x3fffffffffffffffULL) { n += 2;  m <<= 2;  }
-  if( m <= 0x7fffffffffffffffULL) { n += 1;            }
-  return n;
-#endif
-}
-
-/*
-** Given m and e, which represent a quantity r == m*pow(2,e),
-** return values *pD and *pP such that r == (*pD)*pow(10,*pP),
-** approximately.  *pD should contain at least n significant digits.
-**
-** The input m is required to have its highest bit set.  In other words,
-** m should be left-shifted, and e decremented, to maximize the value of m.
-*/
-static void sqlite3Fp2Convert10(u64 m, int e, int n, u64 *pD, int *pP){
-  int p;
-  u64 h, d1;
-  u32 d2;
-  assert( n>=1 && n<=18 );
-  p = n - 1 - pwr2to10(e+63);
-  h = sqlite3Multiply128(m, powerOfTen(p,&d2), &d1);
-  assert( -(e + pwr10to2(p) + 2) >= 0  );
-  assert( -(e + pwr10to2(p) + 1) <= 63 );
-  if( n==18 ){
-    h >>= -(e + pwr10to2(p) + 2);
-    *pD = (h + ((h<<1)&2))>>1;
-  }else{
-    *pD = h >> -(e + pwr10to2(p) + 1);
-  }
-  *pP = -p;
-}
-
-/*
-** Return an IEEE754 floating point value that approximates d*pow(10,p).
-**
-** The (current) algorithm is adapted from the work of Ross Cox at
-** https://github.com/rsc/fpfmt
-*/
-static double sqlite3Fp10Convert2(u64 d, int p){
-  int b, lp, e, adj, s;
-  u32 pwr10l, mid1;
-  u64 pwr10h, x, hi, lo, sticky, u, m;
-  double r;
-  if( p<POWERSOF10_FIRST ) return 0.0;
-  if( p>POWERSOF10_LAST ) return INFINITY;
-  b = 64 - countLeadingZeros(d);
-  lp = pwr10to2(p);
-  e = 53 - b - lp;
-  if( e > 1074 ){
-    if( e>=1130 ) return 0.0;
-    e = 1074;
-  }
-  s = -(e-(64-b) + lp + 3);
-  pwr10h = powerOfTen(p, &pwr10l);
-  if( pwr10l!=0 ){
-    pwr10h++;
-    pwr10l = ~pwr10l;
-  }
-  x = d<<(64-b);
-  hi = sqlite3Multiply128(x,pwr10h,&lo);
-  mid1 = lo>>32;
-  sticky = 1;
-  if( (hi & (U64_BIT(s)-1))==0 ) {
-    u32 mid2 = sqlite3Multiply128(x,((u64)pwr10l)<<32,&lo)>>32;
-    sticky = (mid1-mid2 > 1);
-    hi -= mid1 < mid2;
-  }
-  u = (hi>>s) | sticky;
-  adj = (u >= U64_BIT(55)-2);
-  if( adj ){
-    u = (u>>adj) | (u&1);
-    e -= adj;
-  }
-  m = (u + 1 + ((u>>2)&1)) >> 2;
-  if( e<=(-972) ) return INFINITY;
-  if((m & U64_BIT(52)) != 0){
-    m = (m & ~U64_BIT(52)) | ((u64)(1075-e)<<52);
-  }
-  memcpy(&r,&m,8);
-  return r;
-}
-
-/*
-** The string z[] is an text representation of a real number.
-** Convert this string to a double and write it into *pResult.
-**
-** z[] must be UTF-8 and zero-terminated.
-**
-** Return positive if the result is a valid real number (or integer) and
-** zero or negative if the string is empty or contains extraneous text.
-** Lower bits of the return value contain addition information about the
-** parse:
-**
-**   bit 0       =>   Set if any prefix of the input is valid.  Clear if
-**                    there is no prefix of the input that can be seen as
-**                    a valid floating point number.
-**   bit 1       =>   Set if the input contains a decimal point or eNNN
-**                    clause.  Zero if the input is an integer.
-**   bit 2       =>   The input is exactly 0.0, not an underflow from
-**                    some value near zero.
-**   bit 3       =>   Set if there are more than about 19 significant
-**                    digits in the input.
-**
-** If the input contains a syntax error but begins with text that might
-** be a valid number of some kind, then the result is negative.  The
-** result is only zero if no prefix of the input could be interpreted as
-** a number.
-**
-** Leading and trailing whitespace is ignored.  Valid numbers are in
-** one of the formats below:
-**
-**    [+-]digits[E[+-]digits]
-**    [+-]digits.[digits][E[+-]digits]
-**    [+-].digits[E[+-]digits]
-**
-** Algorithm sketch:  Compute an unsigned 64-bit integer s and a base-10
-** exponent d such that the value encoding by the input is s*pow(10,d).
-** Then invoke sqlite3Fp10Convert2() to calculated the closest possible
-** IEEE754 double.  The sign is added back afterwards, if the input string
-** starts with a "-".  The use of an unsigned 64-bit s mantissa means that
-** only about the first 19 significant digits of the input can contribute
-** to the result.  This can result in suboptimal rounding decisions when
-** correct rounding requires more than 19 input digits.  For example,
-** this routine renders "3500000000000000.2500001" as
-** 3500000000000000.0 instead of 3500000000000000.5 because the decision
-** to round up instead of using banker's rounding to round down is determined
-** by the 23rd significant digit, which this routine ignores. It is not
-** possible to do better without some kind of BigNum.
-*/
-SQLITE_PRIVATE int sqlite3AtoF(const char *zIn, double *pResult){
-#ifndef SQLITE_OMIT_FLOATING_POINT
-  const unsigned char *z = (const unsigned char*)zIn;
-  int neg = 0;       /* True for a negative value */
-  u64 s = 0;         /* mantissa */
-  int d = 0;         /* Value is s * pow(10,d) */
-  int mState = 0;    /* 1: digit seen 2: fp 4: hard-zero */
-  unsigned v;        /* Value of a single digit */
-
-  start_of_text:
-  if( (v = (unsigned)z[0] - '0')<10 ){
-    parse_integer_part:
-    mState = 1;
-    s = v;
-    z++;
-    while( (v = (unsigned)z[0] - '0')<10 ){
-      s = s*10 + v;
-      z++;
-      if( s>=(LARGEST_UINT64-9)/10 ){
-        mState = 9;
-        while( sqlite3Isdigit(z[0]) ){ z++; d++; }
-        break;
-      }
-    }
-  }else if( z[0]=='-' ){
-    neg = 1;
-    z++;
-    if( (v = (unsigned)z[0] - '0')<10 ) goto parse_integer_part;
-  }else if( z[0]=='+' ){
-    z++;
-    if( (v = (unsigned)z[0] - '0')<10 ) goto parse_integer_part;
-  }else if( sqlite3Isspace(z[0]) ){
-    do{ z++; }while( sqlite3Isspace(z[0]) );
-    goto start_of_text;
-  }else{
-    s = 0;
-  }
-
-  /* if decimal point is present */
-  if( *z=='.' ){
-    z++;
-    if( sqlite3Isdigit(z[0]) ){
-      mState |= 1;
-      do{
-        if( s<(LARGEST_UINT64-9)/10 ){
-          s = s*10 + z[0] - '0';
-          d--;
-        }else{
-          mState = 11;
-        }
-      }while( sqlite3Isdigit(*++z) );
-    }else if( mState==0 ){
-      *pResult = 0.0;
-      return 0;
-    }
-    mState |= 2;
-  }else if( mState==0 ){
-    *pResult = 0.0;
-    return 0;
-  }
-
-  /* if exponent is present */
-  if( *z=='e' || *z=='E' ){
-    int esign;
-    z++;
-
-    /* get sign of exponent */
-    if( *z=='-' ){
-      esign = -1;
-      z++;
-    }else{
-      esign = +1;
-      if( *z=='+' ){
-        z++;
-      }
-    }
-    /* copy digits to exponent */
-    if( (v = (unsigned)z[0] - '0')<10 ){
-      int exp = v;
-      z++;
-      mState |= 2;
-      while( (v = (unsigned)z[0] - '0')<10 ){
-        exp = exp<10000 ? (exp*10 + v) : 10000;
-        z++;
-      }
-      d += esign*exp;
-    }else{
-      z--;  /* Leave z[0] at 'e' or '+' or '-',
-            ** so that the return is 0 or -1 */
-    }
-  }
-
-  /* Convert s*pow(10,d) into real */
-  if( s==0 ){
-    *pResult = 0.0;
-    mState |= 4;
-  }else{
-    *pResult = sqlite3Fp10Convert2(s,d);
-  }
-  if( neg ) *pResult = -*pResult;
-  assert( !sqlite3IsNaN(*pResult) );
-
-  /* return true if number and no extra non-whitespace characters after */
-  if( z[0]==0 ){
-    return mState;
-  }
-  if( sqlite3Isspace(z[0]) ){
-    do{ z++; }while( sqlite3Isspace(*z) );
-    if( z[0]==0 ){
-      return mState;
-    }
-  }
-  return 0xfffffff0 | mState;
-#else
-  return sqlite3Atoi64(z, pResult, strlen(z), SQLITE_UTF8)==0;
-#endif /* SQLITE_OMIT_FLOATING_POINT */
-}
-
-/*
-** Digit pairs used to convert a U64 or I64 into text, two digits
-** at a time.
-*/
-static const union {
-  char a[201];
-  short int forceAlignment;
-} sqlite3DigitPairs = {
-  "00010203040506070809"
-  "10111213141516171819"
-  "20212223242526272829"
-  "30313233343536373839"
-  "40414243444546474849"
-  "50515253545556575859"
-  "60616263646566676869"
-  "70717273747576777879"
-  "80818283848586878889"
-  "90919293949596979899"
-};
-
-/*
-** ARMv6, ARMv7, PPC32 are known to not support hardware u64 division.
-*/
-#if (defined(__arm__) && !defined(__aarch64__)) || \
-    (defined(__ppc__) && !defined(__ppc64__))
-# define SQLITE_AVOID_U64_DIVIDE 1
-#endif
-
-#ifdef SQLITE_AVOID_U64_DIVIDE
-/*
-** Render an unsigned 64-bit integer as text onto the end of a 2-byte
-** aligned buffer that is SQLITE_U64_DIGIT+1 bytes long.  The last byte
-** of the buffer will be filled with a \000 byte.
-**
-** Return the index into the buffer of the first byte.
-**
-** This routine is used on platforms where u64-division is slow because
-** it is not available in hardware and has to be emulated in software.
-** It seeks to minimize the number of u64 divisions and use u32 divisions
-** instead.  It is slower on platforms that have hardware u64 division,
-** but much faster on platforms that do not.
-*/
-static int sqlite3UInt64ToText(u64 v, char *zOut){
-  u32 x32, kk;
-  int i;
-  zOut[SQLITE_U64_DIGITS] = 0;
-  i = SQLITE_U64_DIGITS;
-  assert( TWO_BYTE_ALIGNMENT(&sqlite3DigitPairs.a[0]) );
-  assert( TWO_BYTE_ALIGNMENT(zOut) );
-  while( (v>>32)!=0 ){
-    u32 y, x0, x1, y0, y1;
-    x32 = v % 100000000;
-    v   = v / 100000000;
-    y = x32 % 10000;
-    x32 /= 10000;
-    x1 = x32 / 100;
-    x0 = x32 % 100;
-    y1 = y / 100;
-    y0 = y % 100;
-    assert( i>=8 );
-    i -= 8;
-    *(u16*)(&zOut[i]) = *(u16*)&sqlite3DigitPairs.a[x1*2];
-    *(u16*)(&zOut[i+2]) = *(u16*)&sqlite3DigitPairs.a[x0*2];
-    *(u16*)(&zOut[i+4]) = *(u16*)&sqlite3DigitPairs.a[y1*2];
-    *(u16*)(&zOut[i+6]) = *(u16*)&sqlite3DigitPairs.a[y0*2];
-  }
-  x32 = v;
-  while( x32>=10 ){
-    kk  = x32 % 100;
-    x32 = x32 / 100;
-    assert( TWO_BYTE_ALIGNMENT(&sqlite3DigitPairs.a[kk*2]) );
-    assert( i>=2 );
-    i -= 2;
-    assert( TWO_BYTE_ALIGNMENT(&zOut[i]) );
-    *(u16*)(&zOut[i]) = *(u16*)&sqlite3DigitPairs.a[kk*2];
-  }
-  if( x32 ){
-    assert( i>0 );
-    zOut[--i] = x32 + '0';
-  }
-  return i;
-}
-#endif /* defined(SQLITE_AVOID_U64_DIVIDE) */
-
-/*
-** 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;
-  union {
-    char a[SQLITE_U64_DIGITS+1];
-    u16 forceAlignment;
-  } u;
-  if( v>0 ){
-    x = v;
-  }else if( v==0 ){
-    zOut[0] = '0';
-    zOut[1] = 0;
-    return 1;
-  }else{
-    x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v;
-  }
-#ifdef SQLITE_AVOID_U64_DIVIDE
-  i = sqlite3UInt64ToText(x, u.a);
-#else
-  i = sizeof(u.a)-1;
-  u.a[i] = 0;
-  while( x>=10 ){
-    int kk = (x%100)*2;
-    assert( TWO_BYTE_ALIGNMENT(&sqlite3DigitPairs.a[kk]) );
-    assert( TWO_BYTE_ALIGNMENT(&u.a[i-2]) );
-    *(u16*)(&u.a[i-2]) = *(u16*)&sqlite3DigitPairs.a[kk];
-    i -= 2;
-    x /= 100;
-  }
-  if( x ){
-    u.a[--i] = x + '0';
-  }
-#endif /* SQLITE_AVOID_U64_DIVIDE */
-  if( v<0 ) u.a[--i] = '-';
-  memcpy(zOut, &u.a[i], sizeof(u.a)-i);
-  return sizeof(u.a)-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, j;
-  unsigned 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<length && zNum[i]==0; i+=2){}
-    nonNum = i<length;
-    zEnd = &zNum[i^1];
-    zNum += (enc&1);
-  }
-  while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
-  if( zNum<zEnd ){
-    if( *zNum=='-' ){
-      neg = 1;
-      zNum+=incr;
-    }else if( *zNum=='+' ){
-      zNum+=incr;
-    }
-  }
-  zStart = zNum;
-  while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
-  for(i=0; &zNum[i]<zEnd && (c=(unsigned)zNum[i]-'0')<=9; i+=incr){
-    u = u*10 + c;
-  }
-  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 appease 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]<zEnd ){     /* Extra bytes at the end */
-    int jj = i;
-    do{
-      if( !sqlite3Isspace(zNum[jj]) ){
-        rc = 1;          /* Extra non-space text after the integer */
-        break;
-      }
-      jj += incr;
-    }while( &zNum[jj]<zEnd );
-  }
-  if( i<19*incr ){
-    /* Less than 19 digits, so we know that it fits in 64 bits */
-    assert( u<=LARGEST_INT64 );
-    return rc;
-  }else{
-    /* zNum is a 19-digit numbers.  Compare it against 9223372036854775808. */
-    j = i>19*incr ? 1 : compare2pow63(zNum, incr);
-    if( j<0 ){
-      /* zNum is less than 9223372036854775808 so it fits */
-      assert( u<=LARGEST_INT64 );
-      return rc;
-    }else{
-      *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
-      if( j>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 */
-  {
-    int n = (int)(0x3fffffff&strspn(z,"+- \n\t0123456789"));
-    if( z[n] ) n++;
-    return sqlite3Atoi64(z, pOut, n, 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;
-}
-
-/*
-** Decode a floating-point value into an approximate decimal
-** representation.
-**
-** If iRound<=0 then round to -iRound significant digits to the
-** the right of the decimal point, or to a maximum of mxRound total
-** significant digits.
-**
-** If iRound>0 round to min(iRound,mxRound) significant digits total.
-**
-** mxRound must be positive.
-**
-** The significant digits of the decimal representation are
-** stored in p->z[] which is a often (but not always) a pointer
-** into the middle of p->zBuf[].  There are p->n significant digits.
-** The p->z[] array is *not* zero-terminated.
-*/
-SQLITE_PRIVATE void sqlite3FpDecode(FpDecode *p, double r, int iRound, int mxRound){
-  int i;               /* Index into zBuf[] where to put next character */
-  int n;               /* Number of digits */
-  u64 v;               /* mantissa */
-  int e, exp = 0;      /* Base-2 and base-10 exponent */
-  char *zBuf;          /* Local alias for p->zBuf */
-  char *z;             /* Local alias for p->z */
-
-  p->isSpecial = 0;
-  assert( mxRound>0 );
-
-  /* Convert negative numbers to positive.  Deal with Infinity, 0.0, and
-  ** NaN. */
-  if( r<0.0 ){
-    p->sign = '-';
-    r = -r;
-  }else if( r==0.0 ){
-    p->sign = '+';
-    p->n = 1;
-    p->iDP = 1;
-    p->z = "0";
-    return;
-  }else{
-    p->sign = '+';
-  }
-  memcpy(&v,&r,8);
-  e = (v>>52)&0x7ff;
-  if( e==0x7ff ){
-    p->isSpecial = 1 + (v!=0x7ff0000000000000LL);
-    p->n = 0;
-    p->iDP = 0;
-    p->z = p->zBuf;
-    return;
-  }
-  v &= 0x000fffffffffffffULL;
-  if( e==0 ){
-    int nn = countLeadingZeros(v);
-    v <<= nn;
-    e = -1074 - nn;
-  }else{
-    v = (v<<11) | U64_BIT(63);
-    e -= 1086;
-  }
-  sqlite3Fp2Convert10(v, e, (iRound<=0||iRound>=18)?18:iRound+1, &v, &exp);
-
-  /* Extract significant digits, start at the right-most slot in p->zBuf
-  ** and working back to the right.  "i" keeps track of the next slot in
-  ** which to store a digit. */
-  assert( sizeof(p->zBuf)==SQLITE_U64_DIGITS+1 );
-  assert( v>0 );
-  zBuf = p->zBuf;
-#ifdef SQLITE_AVOID_U64_DIVIDE
-  i = sqlite3UInt64ToText(v, zBuf);
-#else
-  i = SQLITE_U64_DIGITS;
-  while( v>=10 ){
-    int kk = (v%100)*2;
-    assert( TWO_BYTE_ALIGNMENT(&sqlite3DigitPairs.a[kk]) );
-    assert( TWO_BYTE_ALIGNMENT(&zBuf[i]) );
-    assert( i-2>=0 );
-    *(u16*)(&zBuf[i-2]) = *(u16*)&sqlite3DigitPairs.a[kk];
-    i -= 2;
-    v /= 100;
-  }
-  if( v ){
-    assert( v<10 );
-    assert( i>0 );
-    zBuf[--i] = v + '0';
-  }
-#endif /* SQLITE_AVOID_U64_DIVIDE */
-  assert( i>=0 && i<SQLITE_U64_DIGITS );
-  n = SQLITE_U64_DIGITS - i;  /* Total number of digits extracted */
-  assert( n>0 );
-  assert( n<=SQLITE_U64_DIGITS );
-  p->iDP = n + exp;
-  if( iRound<=0 ){
-    iRound = p->iDP - iRound;
-    if( iRound==0 && zBuf[i]>='5' ){
-      iRound = 1;
-      zBuf[--i] = '0';
-      n++;
-      p->iDP++;
-    }
-  }
-  z = &zBuf[i];  /* z points to the first digit */
-  if( iRound>0 && (iRound<n || n>mxRound) ){
-    if( iRound>mxRound ) iRound = mxRound;
-    if( iRound==17 ){
-      /* If the precision is exactly 17, which only happens with the "!"
-      ** flag (ex: "%!.17g") then try to reduce the precision if that
-      ** yields text that will round-trip to the original floating-point.
-      ** value.  Thus, for exaple, 49.47 will render as 49.47, rather than
-      ** as 49.469999999999999. */
-      if( z[15]=='9' && z[14]=='9' ){
-        int jj, kk;
-        u64 v2;
-        for(jj=14; jj>0 && z[jj-1]=='9'; jj--){}
-        if( jj==0 ){
-          v2 = 1;
-        }else{
-          v2 = z[0] - '0';
-          for(kk=1; kk<jj; kk++) v2 = (v2*10) + z[kk] - '0';
-          v2++;
-        }
-        if( r==sqlite3Fp10Convert2(v2, exp + n - jj) ){
-          iRound = jj+1;
-        }
-      }else if( p->iDP>=n || (z[15]=='0' && z[14]=='0' && z[13]=='0') ){
-        int jj, kk;
-        u64 v2;
-        assert( z[0]!='0' );
-        for(jj=13; z[jj-1]=='0'; jj--){}
-        v2 = z[0] - '0';
-        for(kk=1; kk<jj; kk++) v2 = (v2*10) + z[kk] - '0';
-        if( r==sqlite3Fp10Convert2(v2, exp + n - jj) ){
-          iRound = jj+1;
-        }
-      }
-    }
-    n = iRound;
-    if( z[iRound]>='5' ){
-      int j = iRound-1;
-      while( 1 /*exit-by-break*/ ){
-        z[j]++;
-        if( z[j]<='9' ) break;
-        z[j] = '0';
-        if( j==0 ){
-          z--;
-          z[0] = '1';
-          n++;
-          p->iDP++;
-          break;
-        }else{
-          j--;
-        }
-      }
-    }
-  }
-  assert( n>0 );
-  while( z[n-1]=='0' ){
-    n--;
-    assert( n>0 );
-  }
-  p->n = n;
-  p->z = z;
-}
-
-/*
-** 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){
-  u64 v64;
-  u8 n;
-
-  /* Assume that the single-byte case has already been handled by
-  ** the getVarint32() macro */
-  assert( (p[0] & 0x80)!=0 );
-
-  if( (p[1] & 0x80)==0 ){
-    /* This is the two-byte case */
-    *v = ((p[0]&0x7f)<<7) | p[1];
-    return 2;
-  }
-  if( (p[2] & 0x80)==0 ){
-    /* This is the three-byte case */
-    *v = ((p[0]&0x7f)<<14) | ((p[1]&0x7f)<<7) | p[2];
-    return 3;
-  }
-  /* four or more bytes */
-  n = sqlite3GetVarint(p, &v64);
-  assert( n>3 && n<=9 );
-  if( (v64 & SQLITE_MAX_U32)!=v64 ){
-    *v = 0xffffffff;
-  }else{
-    *v = (u32)v64;
-  }
-  return n;
-}
-
-/*
-** 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);
-}
-
-#if !defined(SQLITE_OMIT_BLOB_LITERAL)
-/*
-** 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; i<n; i+=2){
-      zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
-    }
-    zBlob[i/2] = 0;
-  }
-  return zBlob;
-}
-#endif /* !SQLITE_OMIT_BLOB_LITERAL */
-
-/*
-** Log an error that is an API call on a connection pointer that should
-** not have been used.  The "type" of connection pointer is given as the
-** argument.  The zType is a word like "NULL" or "closed" or "invalid".
-*/
-static void logBadConnection(const char *zType){
-  sqlite3_log(SQLITE_MISUSE,
-     "API call with %s database connection pointer",
-     zType
-  );
-}
-
-/*
-** Check to make sure we have a valid db pointer.  This test is not
-** foolproof but it does provide some measure of protection against
-** misuse of the interface such as passing in db pointers that are
-** NULL or which have been previously closed.  If this routine returns
-** 1 it means that the db pointer is valid and 0 if it should not be
-** dereferenced for any reason.  The calling function should invoke
-** SQLITE_MISUSE immediately.
-**
-** sqlite3SafetyCheckOk() requires that the db pointer be valid for
-** use.  sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
-** open properly and is not fit for general use but which can be
-** used as an argument to sqlite3_errmsg() or sqlite3_close().
-*/
-SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3 *db){
-  u8 eOpenState;
-  if( db==0 ){
-    logBadConnection("NULL");
-    return 0;
-  }
-  eOpenState = db->eOpenState;
-  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, subtract, 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( iA<SMALLEST_INT64/iB ) return 1;
-  }else if( iB<0 ){
-    if( iA>0 ){
-      if( iB<SMALLEST_INT64/iA ) return 1;
-    }else if( iA<0 ){
-      if( iB==SMALLEST_INT64 ) return 1;
-      if( iA==SMALLEST_INT64 ) return 1;
-      if( -iA>LARGEST_INT64/-iB ) return 1;
-    }
-  }
-  *pA = iA*iB;
-  return 0;
-#endif
-}
-
-/*
-** Compute the absolute value of a 32-bit signed integer, if 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<mx );
-  return 0;
-}
-
-/*
-** Return the number of the variable named zName, if it is in VList.
-** or return 0 if there is no such variable.
-*/
-SQLITE_PRIVATE int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
-  int i, mx;
-  if( pIn==0 ) return 0;
-  mx = pIn[1];
-  i = 2;
-  do{
-    const char *z = (const char*)&pIn[i+2];
-    if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
-    i += pIn[i+1];
-  }while( i<mx );
-  return 0;
-}
-
-/************** End of util.c ************************************************/
-/************** Begin file 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.
-*/
-/* #include "sqliteInt.h" */
-/* #include <assert.h> */
-
-/* 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;
-  while( 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.
-    **
-    ** Only bits 0xdf for ASCII and bits 0xbf for EBCDIC each octet are
-    ** hashed since the omitted bits determine the upper/lower case difference.
-    */
-#ifdef SQLITE_EBCDIC
-    h += 0xbf & (unsigned char)*(z++);
-#else
-    h += 0xdf & (unsigned char)*(z++);
-#endif
-    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 contains "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){
-    next_elem = elem->next;
-    insertElement(pH, &new_ht[elem->h % new_size], 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, 0 };
-
-  h = strHash(pKey);
-  if( pH->ht ){   /*OPTIMIZATION-IF-TRUE*/
-    struct _ht *pEntry;
-    pEntry = &pH->ht[h % pH->htsize];
-    elem = pEntry->chain;
-    count = pEntry->count;
-  }else{
-    elem = pH->first;
-    count = pH->count;
-  }
-  if( pHash ) *pHash = h;
-  while( count ){
-    assert( elem!=0 );
-    if( h==elem->h && 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 removeElement(
-  Hash *pH,         /* The pH containing "elem" */
-  HashElem *elem    /* The element to be removed from the pH */
-){
-  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[elem->h % pH->htsize];
-    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 ){
-      removeElement(pH,elem);
-    }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->h = h;
-  new_elem->data = data;
-  pH->count++;
-  if( pH->count>=5 && pH->count > 2*pH->htsize ){
-    rehash(pH, pH->count*3);
-  }
-  insertElement(pH, pH->ht ? &pH->ht[new_elem->h % pH->htsize] : 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 */ "IfSizeBetween"    OpHelp(""),
-    /*  34 */ "SorterSort"       OpHelp(""),
-    /*  35 */ "Sort"             OpHelp(""),
-    /*  36 */ "Rewind"           OpHelp(""),
-    /*  37 */ "IfEmpty"          OpHelp("if( empty(P1) ) goto P2"),
-    /*  38 */ "SorterNext"       OpHelp(""),
-    /*  39 */ "Prev"             OpHelp(""),
-    /*  40 */ "Next"             OpHelp(""),
-    /*  41 */ "IdxLE"            OpHelp("key=r[P3@P4]"),
-    /*  42 */ "IdxGT"            OpHelp("key=r[P3@P4]"),
-    /*  43 */ "Or"               OpHelp("r[P3]=(r[P1] || r[P2])"),
-    /*  44 */ "And"              OpHelp("r[P3]=(r[P1] && r[P2])"),
-    /*  45 */ "IdxLT"            OpHelp("key=r[P3@P4]"),
-    /*  46 */ "IdxGE"            OpHelp("key=r[P3@P4]"),
-    /*  47 */ "IFindKey"         OpHelp(""),
-    /*  48 */ "RowSetRead"       OpHelp("r[P3]=rowset(P1)"),
-    /*  49 */ "RowSetTest"       OpHelp("if r[P3] in rowset(P1) goto P2"),
-    /*  50 */ "Program"          OpHelp(""),
-    /*  51 */ "IsNull"           OpHelp("if r[P1]==NULL goto P2"),
-    /*  52 */ "NotNull"          OpHelp("if r[P1]!=NULL goto P2"),
-    /*  53 */ "Ne"               OpHelp("IF r[P3]!=r[P1]"),
-    /*  54 */ "Eq"               OpHelp("IF r[P3]==r[P1]"),
-    /*  55 */ "Gt"               OpHelp("IF r[P3]>r[P1]"),
-    /*  56 */ "Le"               OpHelp("IF r[P3]<=r[P1]"),
-    /*  57 */ "Lt"               OpHelp("IF r[P3]<r[P1]"),
-    /*  58 */ "Ge"               OpHelp("IF r[P3]>=r[P1]"),
-    /*  59 */ "ElseEq"           OpHelp(""),
-    /*  60 */ "FkIfZero"         OpHelp("if fkctr[P1]==0 goto P2"),
-    /*  61 */ "IfPos"            OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
-    /*  62 */ "IfNotZero"        OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
-    /*  63 */ "DecrJumpZero"     OpHelp("if (--r[P1])==0 goto P2"),
-    /*  64 */ "IncrVacuum"       OpHelp(""),
-    /*  65 */ "VNext"            OpHelp(""),
-    /*  66 */ "Filter"           OpHelp("if key(P3@P4) not in filter(P1) goto P2"),
-    /*  67 */ "PureFunc"         OpHelp("r[P3]=func(r[P2@NP])"),
-    /*  68 */ "Function"         OpHelp("r[P3]=func(r[P2@NP])"),
-    /*  69 */ "Return"           OpHelp(""),
-    /*  70 */ "EndCoroutine"     OpHelp(""),
-    /*  71 */ "HaltIfNull"       OpHelp("if r[P3]=null halt"),
-    /*  72 */ "Halt"             OpHelp(""),
-    /*  73 */ "Integer"          OpHelp("r[P2]=P1"),
-    /*  74 */ "Int64"            OpHelp("r[P2]=P4"),
-    /*  75 */ "String"           OpHelp("r[P2]='P4' (len=P1)"),
-    /*  76 */ "BeginSubrtn"      OpHelp("r[P2]=NULL"),
-    /*  77 */ "Null"             OpHelp("r[P2..P3]=NULL"),
-    /*  78 */ "SoftNull"         OpHelp("r[P1]=NULL"),
-    /*  79 */ "Blob"             OpHelp("r[P2]=P4 (len=P1)"),
-    /*  80 */ "Variable"         OpHelp("r[P2]=parameter(P1)"),
-    /*  81 */ "Move"             OpHelp("r[P2@P3]=r[P1@P3]"),
-    /*  82 */ "Copy"             OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
-    /*  83 */ "SCopy"            OpHelp("r[P2]=r[P1]"),
-    /*  84 */ "IntCopy"          OpHelp("r[P2]=r[P1]"),
-    /*  85 */ "FkCheck"          OpHelp(""),
-    /*  86 */ "ResultRow"        OpHelp("output=r[P1@P2]"),
-    /*  87 */ "CollSeq"          OpHelp(""),
-    /*  88 */ "AddImm"           OpHelp("r[P1]=r[P1]+P2"),
-    /*  89 */ "RealAffinity"     OpHelp(""),
-    /*  90 */ "Cast"             OpHelp("affinity(r[P1])"),
-    /*  91 */ "Permutation"      OpHelp(""),
-    /*  92 */ "Compare"          OpHelp("r[P1@P3] <-> r[P2@P3]"),
-    /*  93 */ "IsTrue"           OpHelp("r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4"),
-    /*  94 */ "ZeroOrNull"       OpHelp("r[P2] = 0 OR NULL"),
-    /*  95 */ "Offset"           OpHelp("r[P3] = sqlite_offset(P1)"),
-    /*  96 */ "Column"           OpHelp("r[P3]=PX cursor P1 column P2"),
-    /*  97 */ "TypeCheck"        OpHelp("typecheck(r[P1@P2])"),
-    /*  98 */ "Affinity"         OpHelp("affinity(r[P1@P2])"),
-    /*  99 */ "MakeRecord"       OpHelp("r[P3]=mkrec(r[P1@P2])"),
-    /* 100 */ "Count"            OpHelp("r[P2]=count()"),
-    /* 101 */ "ReadCookie"       OpHelp(""),
-    /* 102 */ "SetCookie"        OpHelp(""),
-    /* 103 */ "BitAnd"           OpHelp("r[P3]=r[P1]&r[P2]"),
-    /* 104 */ "BitOr"            OpHelp("r[P3]=r[P1]|r[P2]"),
-    /* 105 */ "ShiftLeft"        OpHelp("r[P3]=r[P2]<<r[P1]"),
-    /* 106 */ "ShiftRight"       OpHelp("r[P3]=r[P2]>>r[P1]"),
-    /* 107 */ "Add"              OpHelp("r[P3]=r[P1]+r[P2]"),
-    /* 108 */ "Subtract"         OpHelp("r[P3]=r[P2]-r[P1]"),
-    /* 109 */ "Multiply"         OpHelp("r[P3]=r[P1]*r[P2]"),
-    /* 110 */ "Divide"           OpHelp("r[P3]=r[P2]/r[P1]"),
-    /* 111 */ "Remainder"        OpHelp("r[P3]=r[P2]%r[P1]"),
-    /* 112 */ "Concat"           OpHelp("r[P3]=r[P2]+r[P1]"),
-    /* 113 */ "ReopenIdx"        OpHelp("root=P2 iDb=P3"),
-    /* 114 */ "OpenRead"         OpHelp("root=P2 iDb=P3"),
-    /* 115 */ "BitNot"           OpHelp("r[P2]= ~r[P1]"),
-    /* 116 */ "OpenWrite"        OpHelp("root=P2 iDb=P3"),
-    /* 117 */ "OpenDup"          OpHelp(""),
-    /* 118 */ "String8"          OpHelp("r[P2]='P4'"),
-    /* 119 */ "OpenAutoindex"    OpHelp("nColumn=P2"),
-    /* 120 */ "OpenEphemeral"    OpHelp("nColumn=P2"),
-    /* 121 */ "SorterOpen"       OpHelp(""),
-    /* 122 */ "SequenceTest"     OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
-    /* 123 */ "OpenPseudo"       OpHelp("P3 columns in r[P2]"),
-    /* 124 */ "Close"            OpHelp(""),
-    /* 125 */ "ColumnsUsed"      OpHelp(""),
-    /* 126 */ "SeekScan"         OpHelp("Scan-ahead up to P1 rows"),
-    /* 127 */ "SeekHit"          OpHelp("set P2<=seekHit<=P3"),
-    /* 128 */ "Sequence"         OpHelp("r[P2]=cursor[P1].ctr++"),
-    /* 129 */ "NewRowid"         OpHelp("r[P2]=rowid"),
-    /* 130 */ "Insert"           OpHelp("intkey=r[P3] data=r[P2]"),
-    /* 131 */ "RowCell"          OpHelp(""),
-    /* 132 */ "Delete"           OpHelp(""),
-    /* 133 */ "ResetCount"       OpHelp(""),
-    /* 134 */ "SorterCompare"    OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
-    /* 135 */ "SorterData"       OpHelp("r[P2]=data"),
-    /* 136 */ "RowData"          OpHelp("r[P2]=data"),
-    /* 137 */ "Rowid"            OpHelp("r[P2]=PX rowid of P1"),
-    /* 138 */ "NullRow"          OpHelp(""),
-    /* 139 */ "SeekEnd"          OpHelp(""),
-    /* 140 */ "IdxInsert"        OpHelp("key=r[P2]"),
-    /* 141 */ "SorterInsert"     OpHelp("key=r[P2]"),
-    /* 142 */ "IdxDelete"        OpHelp("key=r[P2@P3]"),
-    /* 143 */ "DeferredSeek"     OpHelp("Move P3 to P1.rowid if needed"),
-    /* 144 */ "IdxRowid"         OpHelp("r[P2]=rowid"),
-    /* 145 */ "FinishSeek"       OpHelp(""),
-    /* 146 */ "Destroy"          OpHelp(""),
-    /* 147 */ "Clear"            OpHelp(""),
-    /* 148 */ "ResetSorter"      OpHelp(""),
-    /* 149 */ "CreateBtree"      OpHelp("r[P2]=root iDb=P1 flags=P3"),
-    /* 150 */ "SqlExec"          OpHelp(""),
-    /* 151 */ "ParseSchema"      OpHelp(""),
-    /* 152 */ "LoadAnalysis"     OpHelp(""),
-    /* 153 */ "DropTable"        OpHelp(""),
-    /* 154 */ "Real"             OpHelp("r[P2]=P4"),
-    /* 155 */ "DropIndex"        OpHelp(""),
-    /* 156 */ "DropTrigger"      OpHelp(""),
-    /* 157 */ "IntegrityCk"      OpHelp(""),
-    /* 158 */ "RowSetAdd"        OpHelp("rowset(P1)=r[P2]"),
-    /* 159 */ "Param"            OpHelp(""),
-    /* 160 */ "FkCounter"        OpHelp("fkctr[P1]+=P2"),
-    /* 161 */ "MemMax"           OpHelp("r[P1]=max(r[P1],r[P2])"),
-    /* 162 */ "OffsetLimit"      OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
-    /* 163 */ "AggInverse"       OpHelp("accum=r[P3] inverse(r[P2@P5])"),
-    /* 164 */ "AggStep"          OpHelp("accum=r[P3] step(r[P2@P5])"),
-    /* 165 */ "AggStep1"         OpHelp("accum=r[P3] step(r[P2@P5])"),
-    /* 166 */ "AggValue"         OpHelp("r[P3]=value N=P2"),
-    /* 167 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
-    /* 168 */ "Expire"           OpHelp(""),
-    /* 169 */ "CursorLock"       OpHelp(""),
-    /* 170 */ "CursorUnlock"     OpHelp(""),
-    /* 171 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
-    /* 172 */ "VBegin"           OpHelp(""),
-    /* 173 */ "VCreate"          OpHelp(""),
-    /* 174 */ "VDestroy"         OpHelp(""),
-    /* 175 */ "VOpen"            OpHelp(""),
-    /* 176 */ "VCheck"           OpHelp(""),
-    /* 177 */ "VInitIn"          OpHelp("r[P2]=ValueList(P1,P3)"),
-    /* 178 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
-    /* 179 */ "VRename"          OpHelp(""),
-    /* 180 */ "Pagecount"        OpHelp(""),
-    /* 181 */ "MaxPgcnt"         OpHelp(""),
-    /* 182 */ "ClrSubtype"       OpHelp("r[P1].subtype = 0"),
-    /* 183 */ "GetSubtype"       OpHelp("r[P2] = r[P1].subtype"),
-    /* 184 */ "SetSubtype"       OpHelp("r[P2].subtype = r[P1]"),
-    /* 185 */ "FilterAdd"        OpHelp("filter(P1) += key(P3@P4)"),
-    /* 186 */ "Trace"            OpHelp(""),
-    /* 187 */ "CursorHint"       OpHelp(""),
-    /* 188 */ "ReleaseReg"       OpHelp("release r[P1@P2] mask P3"),
-    /* 189 */ "Noop"             OpHelp(""),
-    /* 190 */ "Explain"          OpHelp(""),
-    /* 191 */ "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 <sqliteInt.h> */
-#if SQLITE_OS_KV || (SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL))
-
-/*****************************************************************************
-** Debugging logic
-*/
-
-/* SQLITE_KV_TRACE() is used for tracing calls to kvrecord 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.
-**
-** Maintenance reminder: if this struct changes in any way, the JSON
-** rendering of its structure must be updated in
-** sqlite3-wasm.c:sqlite3__wasm_enum_json(). There are no binary
-** compatibility concerns, so it does not need an iVersion member.
-*/
-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 = {
-  2,                              /* 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 <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-/* Forward declarations for the low-level storage engine
-*/
-#ifndef SQLITE_WASM
-/* In WASM builds these are implemented in JS. */
-static int kvrecordWrite(const char*, const char *zKey, const char *zData);
-static int kvrecordDelete(const char*, const char *zKey);
-static int kvrecordRead(const char*, const char *zKey, char *zBuf, int nBuf);
-#endif
-#ifndef KVRECORD_KEY_SZ
-#define KVRECORD_KEY_SZ 32
-#endif
-
-/* Expand the key name with an appropriate prefix and put the result
-** in zKeyOut[].  The zKeyOut[] buffer is assumed to hold at least
-** KVRECORD_KEY_SZ bytes.
-*/
-static void kvrecordMakeKey(
-  const char *zClass,
-  const char *zKeyIn,
-  char *zKeyOut
-){
-  assert( zKeyIn );
-  assert( zKeyOut );
-  assert( zClass );
-  sqlite3_snprintf(KVRECORD_KEY_SZ, zKeyOut, "kvvfs-%s-%s",
-                   zClass, zKeyIn);
-}
-
-#ifndef SQLITE_WASM
-/* In WASM builds do not define APIs which use fopen(), fwrite(),
-** and the like because those APIs are a portability issue for
-** WASM.
-*/
-/* 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 kvrecordWrite(
-  const char *zClass,
-  const char *zKey,
-  const char *zData
-){
-  FILE *fd;
-  char zXKey[KVRECORD_KEY_SZ];
-  kvrecordMakeKey(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 kvrecordDelete(const char *zClass, const char *zKey){
-  char zXKey[KVRECORD_KEY_SZ];
-  kvrecordMakeKey(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 or its key cannot be read.
-**
-** If nBuf<=0 then this routine simply returns the size of the data
-** without actually reading it.  Similarly, if nBuf==1 then it
-** zero-terminates zBuf at zBuf[0] and returns the size of the data
-** without reading it.
-*/
-static int kvrecordRead(
-  const char *zClass,
-  const char *zKey,
-  char *zBuf,
-  int nBuf
-){
-  FILE *fd;
-  struct stat buf;
-  char zXKey[KVRECORD_KEY_SZ];
-  kvrecordMakeKey(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;
-  }
-}
-#endif /* #ifndef SQLITE_WASM */
-
-
-/*
-** 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.c:sqlite3__wasm_enum_json(). There are no binary
-** compatibility concerns, so it does not need an iVersion member.
-*/
-typedef struct sqlite3_kvvfs_methods sqlite3_kvvfs_methods;
-struct sqlite3_kvvfs_methods {
-  int (*xRcrdRead)(const char*, const char *zKey, char *zBuf, int nBuf);
-  int (*xRcrdWrite)(const char*, const char *zKey, const char *zData);
-  int (*xRcrdDelete)(const char*, const char *zKey);
-  const int nKeySize;
-  const int nBufferSize;
-#ifndef SQLITE_WASM
-#  define MAYBE_CONST const
-#else
-#  define MAYBE_CONST
-#endif
-  MAYBE_CONST sqlite3_vfs * pVfs;
-  MAYBE_CONST sqlite3_io_methods *pIoDb;
-  MAYBE_CONST sqlite3_io_methods *pIoJrnl;
-#undef MAYBE_CONST
-};
-
-
-/*
-** 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.
-**
-** 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 = {
-#ifndef SQLITE_WASM
-  .xRcrdRead       = kvrecordRead,
-  .xRcrdWrite      = kvrecordWrite,
-  .xRcrdDelete     = kvrecordDelete,
-#else
-  .xRcrdRead       = 0,
-  .xRcrdWrite      = 0,
-  .xRcrdDelete     = 0,
-#endif
-  .nKeySize        = KVRECORD_KEY_SZ,
-  .nBufferSize     = SQLITE_KVOS_SZ,
-  .pVfs            = &sqlite3OsKvvfsObject,
-  .pIoDb           = &kvvfs_db_io_methods,
-  .pIoJrnl         = &kvvfs_jrnl_io_methods
-};
-
-/****** 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.
-*/
-#ifndef SQLITE_WASM
-static
-#endif
-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<nData; i++){
-    unsigned char c = a[i];
-    if( c!=0 ){
-      aOut[j++] = "0123456789ABCDEF"[c>>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+k<nData && a[i+k]==0; k++){}
-      i += k-1;
-      while( k>0 ){
-        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[], or
-** -1 for malformed inputs.
-*/
-#ifndef SQLITE_WASM
-static
-#endif
-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 ) return -1 /* hex bytes are always in pairs */;
-      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( n<pFile->nJrnl ){
-    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.xRcrdRead(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.xRcrdWrite(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);
-#ifdef SQLITE_WASM
-  memset(pFile, 0, sizeof(*pFile));
-#endif
-  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 rc;
-    int szTxt = sqlite3KvvfsMethods.xRcrdRead(pFile->zClass, "jrnl",
-                                              0, 0);
-    char *aTxt;
-    if( szTxt<=4 ){
-      return SQLITE_IOERR;
-    }
-    aTxt = sqlite3_malloc64( szTxt+1 );
-    if( aTxt==0 ) return SQLITE_NOMEM;
-    rc = sqlite3KvvfsMethods.xRcrdRead(pFile->zClass, "jrnl",
-                                       aTxt, szTxt+1);
-    if( rc>=0 ){
-      kvvfsDecodeJournal(pFile, aTxt, szTxt);
-    }
-    sqlite3_free(aTxt);
-    if( rc ) return rc;
-    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.xRcrdRead(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( n<iAmt ){
-    memset(zBuf+n, 0, iAmt-n);
-    return SQLITE_IOERR_SHORT_READ;
-  }
-  return SQLITE_OK;
-}
-
-
-/*
-** Write into the -journal file.
-*/
-static int kvvfsWriteJrnl(
-  sqlite3_file *pProtoFile,
-  const void *zBuf,
-  int iAmt,
-  sqlite_int64 iOfst
-){
-  KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
-  sqlite3_int64 iEnd = iOfst+iAmt;
-  SQLITE_KV_LOG(("xWrite('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
-  if( iEnd>=0x10000000 ) return SQLITE_FULL;
-  if( pFile->aJrnl==0 || pFile->nJrnl<iEnd ){
-    char *aNew = sqlite3_realloc(pFile->aJrnl, iEnd);
-    if( aNew==0 ){
-      return SQLITE_IOERR_NOMEM;
-    }
-    pFile->aJrnl = aNew;
-    if( pFile->nJrnl<iOfst ){
-      memset(pFile->aJrnl+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;
-  int rc;
-  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);
-  rc = sqlite3KvvfsMethods.xRcrdWrite(pFile->zClass, zKey, aData);
-  if( 0==rc ){
-    if( iOfst+iAmt > pFile->szDb ){
-      pFile->szDb = iOfst + iAmt;
-    }
-  }
-  return rc;
-}
-
-/*
-** 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.xRcrdDelete(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.xRcrdDelete(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.xRcrdWrite(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));
-  assert(!pFile->zClass);
-  assert(!pFile->aData);
-  assert(!pFile->aJrnl);
-  assert(!pFile->nJrnl);
-  assert(!pFile->base.pMethods);
-  pFile->szPage = -1;
-  pFile->szDb = -1;
-  if( 0==sqlite3_strglob("*-journal", zName) ){
-    pFile->isJournal = 1;
-    pFile->base.pMethods = &kvvfs_jrnl_io_methods;
-    if( 0==strcmp("session-journal",zName) ){
-      pFile->zClass = "session";
-    }else if( 0==strcmp("local-journal",zName) ){
-      pFile->zClass = "local";
-    }
-  }else{
-    pFile->isJournal = 0;
-    pFile->base.pMethods = &kvvfs_db_io_methods;
-  }
-  if( !pFile->zClass ){
-    pFile->zClass = zName;
-  }
-  pFile->aData = sqlite3_malloc64(SQLITE_KVOS_SZ);
-  if( pFile->aData==0 ){
-    return SQLITE_NOMEM;
-  }
-  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){
-  int rc /* The JS impl can fail with OOM in argument conversion */;
-  if( strcmp(zPath, "local-journal")==0 ){
-    rc = sqlite3KvvfsMethods.xRcrdDelete("local", "jrnl");
-  }else
-  if( strcmp(zPath, "session-journal")==0 ){
-    rc = sqlite3KvvfsMethods.xRcrdDelete("session", "jrnl");
-  }
-  else{
-    rc = 0;
-  }
-  return rc;
-}
-
-/*
-** 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 0 && defined(SQLITE_WASM)
-  /*
-  ** This is not having the desired effect in the JS bindings.
-  ** It's ostensibly the same logic as the #else block, but
-  ** it's not behaving that way.
-  **
-  ** In JS we map all zPaths to Storage objects, and -journal files
-  ** are mapped to the storage for the main db (which is is exactly
-  ** what the mapping of "local-journal" -> "local" is doing).
-  */
-  const char *zKey = (0==sqlite3_strglob("*-journal", zPath))
-    ? "jrnl" : "sz";
-  *pResOut =
-    sqlite3KvvfsMethods.xRcrdRead(zPath, zKey, 0, 0)>0;
-#else
-  if( strcmp(zPath, "local-journal")==0 ){
-    *pResOut =
-      sqlite3KvvfsMethods.xRcrdRead("local", "jrnl", 0, 0)>0;
-  }else
-  if( strcmp(zPath, "session-journal")==0 ){
-    *pResOut =
-      sqlite3KvvfsMethods.xRcrdRead("session", "jrnl", 0, 0)>0;
-  }else
-  if( strcmp(zPath, "local")==0 ){
-    *pResOut =
-      sqlite3KvvfsMethods.xRcrdRead("local", "sz", 0, 0)>0;
-  }else
-  if( strcmp(zPath, "session")==0 ){
-    *pResOut =
-      sqlite3KvvfsMethods.xRcrdRead("session", "sz", 0, 0)>0;
-  }else
-  {
-    *pResOut = 0;
-  }
-  /*all current JS tests avoid triggering: assert( *pResOut == 0 ); */
-#endif
-  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<nPath+1 ) nPath = nOut - 1;
-  memcpy(zOut, zPath, nPath);
-  zOut[nPath] = 0;
-  return SQLITE_OK;
-}
-
-/*
-** Open the dynamic library located at zPath and return a handle.
-*/
-static void *kvvfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
-  return 0;
-}
-
-/*
-** Populate the buffer pointed to by zBufOut with nByte bytes of
-** random data.
-*/
-static int kvvfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
-  memset(zBufOut, 0, nByte);
-  return nByte;
-}
-
-/*
-** Sleep for nMicro microseconds. Return the number of microseconds
-** actually slept.
-*/
-static int kvvfsSleep(sqlite3_vfs *pVfs, int nMicro){
-  return SQLITE_OK;
-}
-
-/*
-** Return the current time as a Julian Day number in *pTimeOut.
-*/
-static int kvvfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
-  sqlite3_int64 i = 0;
-  int rc;
-  rc = kvvfsCurrentTimeInt64(0, &i);
-  *pTimeOut = i/86400000.0;
-  return rc;
-}
-#include <sys/time.h>
-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 labelled.
-**
-** 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 <sys/types.h>   /* amalgamator: keep */
-#include <sys/stat.h>    /* amalgamator: keep */
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <unistd.h>      /* amalgamator: keep */
-/* #include <time.h> */
-#include <sys/time.h>    /* amalgamator: keep */
-#include <errno.h>
-#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \
-  && !defined(SQLITE_WASI)
-# include <sys/mman.h>
-#endif
-
-#if SQLITE_ENABLE_LOCKING_STYLE
-/* # include <sys/ioctl.h> */
-# include <sys/file.h>
-# include <sys/param.h>
-#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 <sys/ioctl.h> */
-# include <semaphore.h>
-# include <limits.h>
-#endif /* OS_VXWORKS */
-
-#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
-# include <sys/mount.h>
-#endif
-
-#ifdef HAVE_UTIME
-# include <utime.h>
-#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 <pthread.h> */
-#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 1
-# 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 */
-  int bBlockOnConnect;                /* True to block for SHARED 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 */
-#if !defined(SQLITE_DISABLE_DIRSYNC) && !defined(_AIX)
-# 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  },
-#define osFchmod    ((int(*)(int,mode_t))aSyscall[14].pCurrent)
-#else
-  { "fchmod",       (sqlite3_syscall_ptr)0,               0  },
-#define osFchmod(FID,MODE) 0
-#endif
-
-#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 */
-
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_FILESTAT)
-/*
-** Extract Posix Advisory Locking information about file description fd
-** from the /proc/PID/fdinfo/FD pseudo-file.  Fill the string buffer a[16]
-** with characters to indicate which SQLite-relevant locks are held.
-** a[16] will be a 15-character zero-terminated string with the following
-** schema:
-**
-**     AAA/B.DDD.DDDDD
-**
-** Each of character A-D will be "w" or "r" or "-" to indicate either a
-** write-lock, a read-lock, or no-lock, respectively.  The "." and "/"
-** characters are delimiters intended to make the string more easily
-** readable by humans.  Here are the meaning of the specific letters:
-**
-**     AAA   ->    The main database locks.  PENDING_BYTE, RESERVED_BYTE,
-**                 and SHARED_FIRST, respectively.
-**
-**     B     ->    The deadman switch lock.  Offset 128 of the -shm file.
-**
-**     CCC   ->    WAL locks:  WRITE, CKPT, RECOVER
-**
-**     DDDDD ->    WAL read-locks 0 through 5
-**
-** Note that elements before the "/" apply to the main database file and
-** elements after the "/" apply to the -shm file in WAL mode.
-**
-** Here is another way of thinking about the meaning of the result string:
-**
-**           AAA/B.CCC.DDDDD
-**           ||| | ||| \___/
-**  PENDING--'|| | |||   `----- READ 0-5
-**  RESERVED--'| | ||`---- RECOVER
-**  SHARED ----' | |`----- CKPT
-**     DMS ------' `------ WRITE
-**
-** Return SQLITE_OK on success and SQLITE_ERROR_UNABLE if the /proc
-** pseudo-filesystem is unavailable.
-*/
-static int unixPosixAdvisoryLocks(
-  int fd,        /* The file descriptor to analyze */
-  char a[16]     /* Write a text description of PALs here */
-){
-  int in;
-  ssize_t n;
-  char *p, *pNext, *x;
-  char z[2000];
-
-        /*             1     */
-        /*   012 4 678 01234 */
-  memcpy(a, "---/-.---.-----", 16);
-  sqlite3_snprintf(sizeof(z), z, "/proc/%d/fdinfo/%d", getpid(), fd);
-  in = osOpen(z, O_RDONLY, 0);
-  if( in<0 ){
-    return SQLITE_ERROR_UNABLE;
-  }
-  n = osRead(in, z, sizeof(z)-1);
-  osClose(in);
-  if( n<=0 ) return SQLITE_ERROR_UNABLE;
-  z[n] = 0;
-
-  /* We are looking for lines that begin with "lock:\t".  Examples:
-  **
-  ** lock: 1: POSIX  ADVISORY  READ 494716 08:02:5277597 1073741826 1073742335
-  ** lock: 1: POSIX  ADVISORY  WRITE 494716 08:02:5282282 120 120
-  ** lock: 2: POSIX  ADVISORY  READ 494716 08:02:5282282 123 123
-  ** lock: 3: POSIX  ADVISORY  READ 494716 08:02:5282282 128 128
-  */
-  pNext = strstr(z, "lock:\t");
-  while( pNext ){
-    char cType = 0;
-    sqlite3_int64 iFirst, iLast;
-    p = pNext+6;
-    pNext = strstr(p, "lock:\t");
-    if( pNext ) pNext[-1] = 0;
-    if( (x = strstr(p, " READ "))!=0 ){
-      cType = 'r';
-      x += 6;
-    }else if( (x = strstr(p, " WRITE "))!=0 ){
-      cType = 'w';
-      x += 7;
-    }else{
-      continue;
-    }
-    x = strrchr(x, ' ');
-    if( x==0 ) continue;
-    iLast = strtoll(x+1, 0, 10);
-    *x = 0;
-    x = strrchr(p, ' ');
-    if( x==0 ) continue;
-    iFirst = strtoll(x+1, 0, 10);
-    if( iLast>=PENDING_BYTE ){
-      if( iFirst<=PENDING_BYTE && iLast>=PENDING_BYTE )     a[0] = cType;
-      if( iFirst<=PENDING_BYTE+1 && iLast>=PENDING_BYTE+1 ) a[1] = cType;
-      if( iFirst<=PENDING_BYTE+2 && iLast>=PENDING_BYTE+510 ) a[2] = cType;
-    }else if( iLast<=128 ){
-      if( iFirst<=128 && iLast>=128 ) a[4] = cType;
-      if( iFirst<=120 && iLast>=120 ) a[6] = cType;
-      if( iFirst<=121 && iLast>=121 ) a[7] = cType;
-      if( iFirst<=122 && iLast>=122 ) a[8] = cType;
-      if( iFirst<=123 && iLast>=123 ) a[10] = cType;
-      if( iFirst<=124 && iLast>=124 ) a[11] = cType;
-      if( iFirst<=125 && iLast>=125 ) a[12] = cType;
-      if( iFirst<=126 && iLast>=126 ) a[13] = cType;
-      if( iFirst<=127 && iLast>=127 ) a[14] = cType;
-    }
-  }
-  return SQLITE_OK;
-}
-#else
-#  define unixPosixAdvisoryLocks(A,B) SQLITE_ERROR_UNABLE
-#endif /* SQLITE_DEBUG || SQLITE_ENABLE_FILESTAT */
-
-/*
-** 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 upon 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<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
-      if( aSyscall[i].pDefault ){
-        aSyscall[i].pCurrent = aSyscall[i].pDefault;
-      }
-    }
-  }else{
-    /* If zName is specified, operate on only the one system call
-    ** specified.
-    */
-    for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
-      if( strcmp(zName, aSyscall[i].zName)==0 ){
-        if( aSyscall[i].pDefault==0 ){
-          aSyscall[i].pDefault = aSyscall[i].pCurrent;
-        }
-        rc = SQLITE_OK;
-        if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
-        aSyscall[i].pCurrent = pNewFunc;
-        break;
-      }
-    }
-  }
-  return rc;
-}
-
-/*
-** Return the value of a system call.  Return NULL if zName is not a
-** recognized system call name.  NULL is also returned if the system call
-** is currently undefined.
-*/
-static sqlite3_syscall_ptr unixGetSystemCall(
-  sqlite3_vfs *pNotUsed,
-  const char *zName
-){
-  unsigned int i;
-
-  UNUSED_PARAMETER(pNotUsed);
-  for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
-    if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
-  }
-  return 0;
-}
-
-/*
-** Return the name of the first system call after zName.  If zName==NULL
-** then return the name of the first system call.  Return NULL if zName
-** is the last system call or if zName is not the name of a valid
-** system call.
-*/
-static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
-  int i = -1;
-
-  UNUSED_PARAMETER(p);
-  if( zName ){
-    for(i=0; i<ArraySize(aSyscall)-1; i++){
-      if( strcmp(zName, aSyscall[i].zName)==0 ) break;
-    }
-  }
-  for(i++; i<ArraySize(aSyscall); i++){
-    if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
-  }
-  return 0;
-}
-
-/*
-** Do not accept any file descriptor less than this value, in order to avoid
-** opening database file using file descriptors that are commonly used for
-** standard input, output, and error.
-*/
-#ifndef SQLITE_MINIMUM_FILE_DESCRIPTOR
-# define SQLITE_MINIMUM_FILE_DESCRIPTOR 3
-#endif
-
-/*
-** Invoke open().  Do so multiple times, until it either succeeds or
-** fails for some reason other than EINTR.
-**
-** If the file creation mode "m" is 0 then set it to the default for
-** SQLite.  The default is SQLITE_DEFAULT_FILE_PERMISSIONS (normally
-** 0644) as modified by the system umask.  If m is not 0, then
-** make the file creation mode be exactly m ignoring the umask.
-**
-** The m parameter will be non-zero only when creating -wal, -journal,
-** and -shm files.  We want those files to have *exactly* the same
-** permissions as their original database, unadulterated by the umask.
-** In that way, if a database file is -rw-rw-rw or -rw-rw-r-, and a
-** transaction crashes and leaves behind hot journals, then any
-** process that is able to write to the database will also be able to
-** recover the hot journals.
-*/
-static int robust_open(const char *z, int f, mode_t m){
-  int fd;
-  mode_t m2 = m ? m : SQLITE_DEFAULT_FILE_PERMISSIONS;
-  while(1){
-#if defined(O_CLOEXEC)
-    fd = osOpen(z,f|O_CLOEXEC,m2);
-#else
-    fd = osOpen(z,f,m2);
-#endif
-    if( fd<0 ){
-      if( errno==EINTR ) continue;
-      break;
-    }
-    if( fd>=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 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;
-static sqlite3_mutex *vxworksMutex = 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; i<n; i++){
-    if( z[i]=='/' ){
-      if( z[i+1]=='/' ) continue;
-      if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
-        i += 1;
-        continue;
-      }
-      if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
-        while( j>0 && 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.
-  */
-  sqlite3_mutex_enter(vxworksMutex);
-  for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
-    if( pCandidate->nName==n
-     && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
-    ){
-       sqlite3_free(pNew);
-       pCandidate->nRef++;
-       sqlite3_mutex_leave(vxworksMutex);
-       return pCandidate;
-    }
-  }
-
-  /* No match was found.  We will make a new file ID */
-  pNew->nRef = 1;
-  pNew->nName = n;
-  pNew->pNext = vxworksFileList;
-  vxworksFileList = pNew;
-  sqlite3_mutex_leave(vxworksMutex);
-  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){
-  sqlite3_mutex_enter(vxworksMutex);
-  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);
-  }
-  sqlite3_mutex_leave(vxworksMutex);
-}
-#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 the 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 application 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.
-  **
-  ** Forum post 3f13857fa4062301 reports that the Android SDK may use
-  ** int-type return, depending on its version.
-  */
-#if (defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)) \
-  && !defined(ANDROID) && !defined(__ANDROID__)
-  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 accumulated 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;
-    }
-    if( fsync(fd) ){
-      storeLastErrno(pFile, errno);
-      return SQLITE_IOERR_FSYNC;
-    }
-    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 rc = 0;
-
-  if( pFile->iBusyTimeout==0 ){
-    /* unixFile->iBusyTimeout is set to 0. In this case, attempt a
-    ** non-blocking lock. */
-    rc = osFcntl(h,F_SETLK,pLock);
-  }else{
-    /* unixFile->iBusyTimeout is set to greater than zero. In this case,
-    ** attempt a blocking-lock with a unixFile->iBusyTimeout ms timeout.
-    **
-    ** On systems that support some kind of blocking file lock operation,
-    ** this block should be replaced by code to attempt a blocking lock
-    ** with a timeout of unixFile->iBusyTimeout ms. The code below is
-    ** placeholder code. If SQLITE_TEST is defined, the placeholder code
-    ** retries the lock once every 1ms until it succeeds or the timeout
-    ** is reached. Or, if SQLITE_TEST is not defined, the placeholder
-    ** code attempts a non-blocking lock and sets unixFile->iBusyTimeout
-    ** to 0. This causes the caller to return SQLITE_BUSY, instead of
-    ** SQLITE_BUSY_TIMEOUT to SQLite - as required by a VFS that does not
-    ** support blocking locks.
-    */
-#ifdef SQLITE_TEST
-    int tm = pFile->iBusyTimeout;
-    while( tm>0 ){
-      rc = osFcntl(h,F_SETLK,pLock);
-      if( rc==0 ) break;
-      unixSleep(0,1000);
-      tm--;
-    }
-#else
-    rc = osFcntl(h,F_SETLK,pLock);
-    pFile->iBusyTimeout = 0;
-#endif
-    /* End of code to replace with real blocking-locks code. */
-  }
-
-  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 ); <-- Not true if unix-excl READONLY used */
-      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{
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    if( pFile->bBlockOnConnect && pLock->l_type==F_RDLCK
-     && pLock->l_start==SHARED_FIRST && pLock->l_len==SHARED_SIZE
-    ){
-      rc = osFcntl(pFile->h, F_SETLKW, pLock);
-    }else
-#endif
-    rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile);
-  }
-  return rc;
-}
-
-#if !defined(SQLITE_WASI) && !defined(SQLITE_OMIT_WAL)
-/* Forward reference */
-static int unixIsSharingShmNode(unixFile*);
-#else
-#define unixIsSharingShmNode(pFile) (0)
-#endif
-
-/*
-** 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 identify 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 Windows95 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 instead. 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 pending 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 if( unixIsSharingShmNode(pFile) ){
-    /* We are in WAL mode and attempting to delete the SHM and WAL
-    ** files due to closing the connection or changing out of WAL mode,
-    ** but another process still holds locks on the SHM file, thus
-    ** indicating that database locks have been broken, perhaps due
-    ** to a rogue close(open(dbFile)) or similar.
-    */
-    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 the caller holds a SHARED
-** or greater lock when it is called, then it is assumed that no other
-** client may hold RESERVED. Or, if the caller holds no lock, then it
-** is assumed another client holds RESERVED if the lock-file exists.
-*/
-static int dotlockCheckReservedLock(sqlite3_file *id, int *pResOut) {
-  unixFile *pFile = (unixFile*)id;
-  SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
-
-  if( pFile->eFileLock>=SHARED_LOCK ){
-    *pResOut = 0;
-  }else{
-    *pResOut = osAccess((const char*)pFile->lockingContext, 0)==0;
-  }
-  OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, 0, *pResOut));
-  return SQLITE_OK;
-}
-
-/*
-** 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){
-#ifdef SQLITE_DEBUG
-  unixFile *pFile = (unixFile*)id;
-#else
-  UNUSED_PARAMETER(id);
-#endif
-
-  SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
-
-  assert( pFile );
-  assert( pFile->eFileLock<=SHARED_LOCK );
-
-  /* The flock VFS only ever takes exclusive locks (see function flockLock).
-  ** Therefore, if this connection is holding any lock at all, no other
-  ** connection may be holding a RESERVED lock. So set *pResOut to 0
-  ** in this case.
-  **
-  ** Or, this connection may be holding no lock. In that case, set *pResOut to
-  ** 0 as well. The caller will then attempt to take an EXCLUSIVE lock on the
-  ** db in order to roll the hot journal back. If there is another connection
-  ** holding a lock, that attempt will fail and an SQLITE_BUSY returned to
-  ** the user. With other VFS, we try to avoid this, in order to allow a reader
-  ** to proceed while a writer is preparing its transaction. But that won't
-  ** work with the flock VFS - as it always takes EXCLUSIVE locks - so it is
-  ** not a problem in this case.  */
-  *pResOut = 0;
-
-  return SQLITE_OK;
-}
-
-/*
-** 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 pending 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->eFileLock<PENDING_LOCK)
-  ){
-    int failed;
-    failed = afpSetLock(context->dbPath, 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 attempt 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;
-
-  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 );
-
-#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 ){
-      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 transferring
-  ** data from the memory mapping using memcpy().  */
-  if( offset<pFile->mmapSize ){
-    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 transferring
-  ** data from the memory mapping using memcpy().  */
-  if( offset<pFile->mmapSize ){
-    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))<amt && wrote>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
-  ** coverage 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( nByte<pFile->mmapSize ){
-      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+nBlk-1; iWrite+=nBlk ){
-        if( 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);
-#if !defined(SQLITE_WASI) && !defined(SQLITE_OMIT_WAL)
- static int unixFcntlExternalReader(unixFile*, int*);
-#endif
-#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_FILESTAT)
- static void unixDescribeShm(sqlite3_str*,unixShm*);
-#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_NULL_IO: {
-      osClose(pFile->h);
-      pFile->h = -1;
-      return SQLITE_OK;
-    }
-    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;
-      int iNew = *(int*)pArg;
-#if SQLITE_ENABLE_SETLK_TIMEOUT==1
-      pFile->iBusyTimeout = iNew<0 ? 0x7FFFFFFF : (unsigned)iNew;
-#elif SQLITE_ENABLE_SETLK_TIMEOUT==2
-      pFile->iBusyTimeout = !!(*(int*)pArg);
-#else
-# error "SQLITE_ENABLE_SETLK_TIMEOUT must be set to 1 or 2"
-#endif
-      *(int*)pArg = iOld;
-      return SQLITE_OK;
-    }
-    case SQLITE_FCNTL_BLOCK_ON_CONNECT: {
-      int iNew = *(int*)pArg;
-      pFile->bBlockOnConnect = iNew;
-      return SQLITE_OK;
-    }
-#endif /* SQLITE_ENABLE_SETLK_TIMEOUT */
-#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: {
-#if !defined(SQLITE_WASI) && !defined(SQLITE_OMIT_WAL)
-      return unixFcntlExternalReader((unixFile*)id, (int*)pArg);
-#else
-      *(int*)pArg = 0;
-      return SQLITE_OK;
-#endif
-    }
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_FILESTAT)
-    case SQLITE_FCNTL_FILESTAT: {
-      sqlite3_str *pStr = (sqlite3_str*)pArg;
-      char aLck[16];
-      unixInodeInfo *pInode;
-      static const char *azLock[] = { "SHARED", "RESERVED",
-                                      "PENDING", "EXCLUSIVE" };
-      sqlite3_str_appendf(pStr, "{\"h\":%d", pFile->h);
-      sqlite3_str_appendf(pStr, ",\"vfs\":\"%s\"", pFile->pVfs->zName);
-      if( pFile->eFileLock ){
-        sqlite3_str_appendf(pStr, ",\"eFileLock\":\"%s\"",
-                                  azLock[pFile->eFileLock-1]);
-        if( unixPosixAdvisoryLocks(pFile->h, aLck)==SQLITE_OK ){
-          sqlite3_str_appendf(pStr, ",\"pal\":\"%s\"", aLck);
-        }
-      }
-      unixEnterMutex();
-      if( pFile->pShm ){
-        sqlite3_str_appendall(pStr, ",\"shm\":");
-        unixDescribeShm(pStr, pFile->pShm);
-      }
-#if SQLITE_MAX_MMAP_SIZE>0
-      if( pFile->mmapSize ){
-        sqlite3_str_appendf(pStr, ",\"mmapSize\":%lld", pFile->mmapSize);
-        sqlite3_str_appendf(pStr, ",\"nFetchOut\":%d", pFile->nFetchOut);
-      }
-#endif
-      if( (pInode = pFile->pInode)!=0 ){
-        sqlite3_str_appendf(pStr, ",\"inode\":{\"nRef\":%d",pInode->nRef);
-        sqlite3_mutex_enter(pInode->pLockMutex);
-        sqlite3_str_appendf(pStr, ",\"nShared\":%d", pInode->nShared);
-        if( pInode->eFileLock ){
-          sqlite3_str_appendf(pStr, ",\"eFileLock\":\"%s\"",
-                                  azLock[pInode->eFileLock-1]);
-        }
-        if( pInode->pUnused ){
-          char cSep = '[';
-          UnixUnusedFd *pUFd = pFile->pInode->pUnused;
-          sqlite3_str_appendall(pStr, ",\"unusedFd\":");
-          while( pUFd ){
-            sqlite3_str_appendf(pStr, "%c{\"fd\":%d,\"flags\":%d",
-                                cSep, pUFd->fd, pUFd->flags);
-            cSep = ',';
-            if( unixPosixAdvisoryLocks(pUFd->fd, aLck)==SQLITE_OK ){
-              sqlite3_str_appendf(pStr, ",\"pal\":\"%s\"", aLck);
-            }
-            sqlite3_str_append(pStr, "}", 1);
-            pUFd = pUFd->pNext;
-          }
-          sqlite3_str_append(pStr, "]", 1);
-        }
-        sqlite3_mutex_leave(pInode->pLockMutex);
-        sqlite3_str_append(pStr, "}", 1);
-      }
-      unixLeaveMutex();
-      sqlite3_str_append(pStr, "}", 1);
-      return SQLITE_OK;
-    }
-#endif /* SQLITE_DEBUG || SQLITE_ENABLE_FILESTAT */
-  }
-  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->deviceCharacteristics |= SQLITE_IOCAP_SUBPAGE_READ;
-
-    pFd->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
-  }
-}
-#else
-#include <sys/dcmd_blk.h>
-#include <sys/statvfs.h>
-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 */
-
-#if !defined(SQLITE_WASI) && !defined(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.
-**
-** aLock[SQLITE_SHM_NLOCK]:
-**   This array records the various locks held by clients on each of the
-**   SQLITE_SHM_NLOCK slots. If the aLock[] entry is set to 0, then no
-**   locks are held by the process on this slot. If it is set to -1, then
-**   some client holds an EXCLUSIVE lock on the locking slot. If the aLock[]
-**   value is set to a positive value, then it is the number of shared
-**   locks currently held on the slot.
-**
-** aMutex[SQLITE_SHM_NLOCK]:
-**   Normally, when SQLITE_ENABLE_SETLK_TIMEOUT is not defined, mutex
-**   pShmMutex is used to protect the aLock[] array and the right to
-**   call fcntl() on unixShmNode.hShm to obtain or release locks.
-**
-**   If SQLITE_ENABLE_SETLK_TIMEOUT is defined though, we use an array
-**   of mutexes - one for each locking slot. To read or write locking
-**   slot aLock[iSlot], the caller must hold the corresponding mutex
-**   aMutex[iSlot]. Similarly, to call fcntl() to obtain or release a
-**   lock corresponding to slot iSlot, mutex aMutex[iSlot] must be held.
-*/
-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 */
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  sqlite3_mutex *aMutex[SQLITE_SHM_NLOCK];
-#endif
-  int aLock[SQLITE_SHM_NLOCK];  /* # shared locks on slot, -1==excl lock */
-#ifdef SQLITE_DEBUG
-  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 */
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_FILESTAT)
-/*
-** Describe the pShm object using JSON.  Used for diagnostics only.
-*/
-static void unixDescribeShm(sqlite3_str *pStr, unixShm *pShm){
-  unixShmNode *pNode = pShm->pShmNode;
-  char aLck[16];
-  sqlite3_str_appendf(pStr, "{\"h\":%d", pNode->hShm);
-  assert( unixMutexHeld() );
-  sqlite3_str_appendf(pStr, ",\"nRef\":%d", pNode->nRef);
-  sqlite3_str_appendf(pStr, ",\"id\":%d", pShm->id);
-  sqlite3_str_appendf(pStr, ",\"sharedMask\":%d", pShm->sharedMask);
-  sqlite3_str_appendf(pStr, ",\"exclMask\":%d", pShm->exclMask);
-  if( unixPosixAdvisoryLocks(pNode->hShm, aLck)==SQLITE_OK ){
-    sqlite3_str_appendf(pStr, ",\"pal\":\"%s\"", aLck);
-  }
-  sqlite3_str_append(pStr, "}", 1);
-}
-#endif /* SQLITE_DEBUG || SQLITE_ENABLE_FILESTAT */
-
-/*
-** 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;
-}
-
-/*
-** If pFile has a -shm file open and it is sharing that file with some
-** other connection, either in the same process or in a separate process,
-** then return true.  Return false if either pFile does not have a -shm
-** file open or if it is the only connection to that -shm file across the
-** entire system.
-**
-** This routine is not required for correct operation.  It can always return
-** false and SQLite will continue to operate according to spec.  However,
-** when this routine does its job, it adds extra robustness in cases
-** where database file locks have been erroneously deleted in a WAL-mode
-** database by doing close(open(DATABASE_PATHNAME)) or similar.
-**
-** With false negatives, SQLite still operates to spec, though with less
-** robustness.  With false positives, the last database connection on a
-** WAL-mode database will fail to unlink the -wal and -shm files, which
-** is annoying but harmless.  False positives will also prevent a database
-** connection from running "PRAGMA journal_mode=DELETE" in order to take
-** the database out of WAL mode, which is perhaps more serious, but is
-** still not a disaster.
-*/
-static int unixIsSharingShmNode(unixFile *pFile){
-  unixShmNode *pShmNode;
-  struct flock lock;
-  if( pFile->pShm==0 ) return 0;
-  if( pFile->ctrlFlags & UNIXFILE_EXCL ) return 0;
-  pShmNode = pFile->pShm->pShmNode;
-#if SQLITE_ATOMIC_INTRINSICS
-  assert( AtomicLoad(&pShmNode->nRef)==1 );
-#endif
-  memset(&lock, 0, sizeof(lock));
-  lock.l_whence = SEEK_SET;
-  lock.l_start = UNIX_SHM_DMS;
-  lock.l_len = 1;
-  lock.l_type = F_WRLCK;
-  osFcntl(pShmNode->hShm, F_GETLK, &lock);
-  return (lock.l_type!=F_UNLCK);
-}
-
-/*
-** 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() */
-
-  pShmNode = pFile->pInode->pShmNode;
-
-  /* Assert that the parameters are within expected range and that the
-  ** correct mutex or mutexes are held. */
-  assert( pShmNode->nRef>=0 );
-  assert( (ofst==UNIX_SHM_DMS && n==1)
-       || (ofst>=UNIX_SHM_BASE && ofst+n<=(UNIX_SHM_BASE+SQLITE_SHM_NLOCK))
-  );
-  if( ofst==UNIX_SHM_DMS ){
-    assert( pShmNode->nRef>0 || unixMutexHeld() );
-    assert( pShmNode->nRef==0 || sqlite3_mutex_held(pShmNode->pShmMutex) );
-  }else{
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    int ii;
-    for(ii=ofst-UNIX_SHM_BASE; ii<ofst-UNIX_SHM_BASE+n; ii++){
-      assert( sqlite3_mutex_held(pShmNode->aMutex[ii]) );
-    }
-#else
-    assert( sqlite3_mutex_held(pShmNode->pShmMutex) );
-    assert( pShmNode->nRef>0 );
-#endif
-  }
-
-  /* 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 );
-  assert( ofst>=UNIX_SHM_BASE && ofst<=UNIX_SHM_DMS );
-  assert( ofst+n-1<=UNIX_SHM_DMS );
-
-  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 ){
-#if defined(SQLITE_ENABLE_SETLK_TIMEOUT) && SQLITE_ENABLE_SETLK_TIMEOUT==1
-      rc = (pFile->iBusyTimeout ? SQLITE_BUSY_TIMEOUT : SQLITE_BUSY);
-#else
-      rc = SQLITE_BUSY;
-#endif
-    }
-  }
-
-  /* Do debug tracing */
-#ifdef SQLITE_DEBUG
-  OSTRACE(("SHM-LOCK "));
-  if( rc==SQLITE_OK ){
-    if( lockType==F_UNLCK ){
-      OSTRACE(("unlock %d..%d ok\n", ofst, ofst+n-1));
-    }else if( lockType==F_RDLCK ){
-      OSTRACE(("read-lock %d..%d ok\n", ofst, ofst+n-1));
-    }else{
-      assert( lockType==F_WRLCK );
-      OSTRACE(("write-lock %d..%d ok\n", ofst, ofst+n-1));
-    }
-  }else{
-    if( lockType==F_UNLCK ){
-      OSTRACE(("unlock %d..%d failed\n", ofst, ofst+n-1));
-    }else if( lockType==F_RDLCK ){
-      OSTRACE(("read-lock %d..%d failed\n", ofst, ofst+n-1));
-    }else{
-      assert( lockType==F_WRLCK );
-      OSTRACE(("write-lock %d..%d failed\n", ofst, ofst+n-1));
-    }
-  }
-#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( pgsz<shmsz ) return 1;
-  return pgsz/shmsz;
-}
-
-/*
-** Purge the unixShmNodeList list of all entries with unixShmNode.nRef==0.
-**
-** This is not a VFS shared-memory method; it is a utility function called
-** by VFS shared-memory methods.
-*/
-static void unixShmPurge(unixFile *pFd){
-  unixShmNode *p = pFd->pInode->pShmNode;
-  assert( unixMutexHeld() );
-  if( p && ALWAYS(p->nRef==0) ){
-    int nShmPerMap = unixShmRegionPerMap();
-    int i;
-    assert( p->pInode==pFd->pInode );
-    sqlite3_mutex_free(p->pShmMutex);
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    for(i=0; i<SQLITE_SHM_NLOCK; i++){
-      sqlite3_mutex_free(p->aMutex[i]);
-    }
-#endif
-    for(i=0; i<p->nRegion; 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{
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-      /* Do not use a blocking lock here. If the lock cannot be obtained
-      ** immediately, it means some other connection is truncating the
-      ** *-shm file. And after it has done so, it will not release its
-      ** lock, but only downgrade it to a shared lock. So no point in
-      ** blocking here. The call below to obtain the shared DMS lock may
-      ** use a blocking lock. */
-      int iSaveTimeout = pDbFd->iBusyTimeout;
-      pDbFd->iBusyTimeout = 0;
-#endif
-      rc = unixShmSystemLock(pDbFd, F_WRLCK, UNIX_SHM_DMS, 1);
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-      pDbFd->iBusyTimeout = iSaveTimeout;
-#endif
-      /* 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;
-      }
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-      {
-        int ii;
-        for(ii=0; ii<SQLITE_SHM_NLOCK; ii++){
-          pShmNode->aMutex[ii] = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
-          if( pShmNode->aMutex[ii]==0 ){
-            rc = SQLITE_NOMEM_BKPT;
-            goto shm_open_err;
-          }
-        }
-      }
-#endif
-    }
-
-    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->nRegion<nReqRegion ){
-    char **apNew;                      /* New apRegion[] array */
-    int nByte = nReqRegion*szRegion;   /* Minimum required file size */
-    struct stat sStat;                 /* Used by fstat() */
-
-    pShmNode->szRegion = 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_size<nByte ){
-        /* The requested memory region does not exist. If bExtend is set to
-        ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
-        */
-        if( !bExtend ){
-          goto shmpage_out;
-        }
-
-        /* Alternatively, if bExtend is true, extend the file. Do this by
-        ** writing a single byte to the end of each (OS) page being
-        ** allocated or extended. Technically, we need only write to the
-        ** last page in order to extend the file. But writing to all new
-        ** pages forces the OS to allocate them immediately, which reduces
-        ** the chances of SIGBUS while accessing the mapped region later on.
-        */
-        else{
-          static const int pgsz = 4096;
-          int iPg;
-
-          /* Write to the last byte of each newly allocated or extended page */
-          assert( (nByte % pgsz)==0 );
-          for(iPg=(sStat.st_size/pgsz); iPg<(nByte/pgsz); iPg++){
-            int x = 0;
-            if( seekAndWriteFd(pShmNode->hShm, 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_realloc64(
-        pShmNode->apRegion, nReqRegion*sizeof(char *)
-    );
-    if( !apNew ){
-      rc = SQLITE_IOERR_NOMEM_BKPT;
-      goto shmpage_out;
-    }
-    pShmNode->apRegion = apNew;
-    while( pShmNode->nRegion<nReqRegion ){
-      int nMap = szRegion*nShmPerMap;
-      int i;
-      void *pMem;
-      if( pShmNode->hShm>=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; i<nShmPerMap; i++){
-        pShmNode->apRegion[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){
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  return 1;
-#else
-  unixShm *pX;
-  int aLock[SQLITE_SHM_NLOCK];
-
-  memset(aLock, 0, sizeof(aLock));
-  for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
-    int i;
-    for(i=0; i<SQLITE_SHM_NLOCK; i++){
-      if( pX->exclMask & (1<<i) ){
-        assert( aLock[i]==0 );
-        aLock[i] = -1;
-      }else if( pX->sharedMask & (1<<i) ){
-        assert( aLock[i]>=0 );
-        aLock[i]++;
-      }
-    }
-  }
-
-  assert( 0==memcmp(pShmNode->aLock, aLock, sizeof(aLock)) );
-  return (memcmp(pShmNode->aLock, aLock, sizeof(aLock))==0);
-#endif
-}
-#endif /* !defined(SQLITE_WASI) && !defined(SQLITE_OMIT_WAL) */
-
-/*
-** 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 = (1<<(ofst+n)) - (1<<ofst); /* 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. Recovery lock (ofst==2).
-  **   2. Checkpointer lock (ofst==1).
-  **   3. Write lock (ofst==0).
-  **   4. Read locks (ofst>=3 && ofst<SQLITE_SHM_NLOCK).
-  **
-  ** In other words, if this is a blocking lock, none of the locks that
-  ** occur later in the above list than the lock being obtained may be
-  ** held.
-  */
-#if defined(SQLITE_ENABLE_SETLK_TIMEOUT) && defined(SQLITE_DEBUG)
-  {
-    u16 lockMask = (p->exclMask|p->sharedMask);
-    assert( (flags & SQLITE_SHM_UNLOCK) || pDbFd->iBusyTimeout==0 || (
-          (ofst!=2 || lockMask==0)
-       && (ofst!=1 || lockMask==0 || lockMask==2)
-       && (ofst!=0 || lockMask<3)
-       && (ofst<3  || lockMask<(1<<ofst))
-    ));
-  }
-#endif
-
-  /* Check if there is any work to do. There are three cases:
-  **
-  **    a) An unlock operation where there are locks to unlock,
-  **    b) An shared lock where the requested lock is not already held
-  **    c) An exclusive lock where the requested lock is not already held
-  **
-  ** The SQLite core never requests an exclusive lock that it already holds.
-  ** This is assert()ed below.
-  */
-  assert( flags!=(SQLITE_SHM_EXCLUSIVE|SQLITE_SHM_LOCK)
-       || 0==(p->exclMask & mask)
-  );
-  if( ((flags & SQLITE_SHM_UNLOCK) && ((p->exclMask|p->sharedMask) & mask))
-   || (flags==(SQLITE_SHM_SHARED|SQLITE_SHM_LOCK) && 0==(p->sharedMask & mask))
-   || (flags==(SQLITE_SHM_EXCLUSIVE|SQLITE_SHM_LOCK))
-  ){
-
-    /* Take the required mutexes. In SETLK_TIMEOUT mode (blocking locks), if
-    ** this is an attempt on an exclusive lock use sqlite3_mutex_try(). If any
-    ** other thread is holding this mutex, then it is either holding or about
-    ** to hold a lock exclusive to the one being requested, and we may
-    ** therefore return SQLITE_BUSY to the caller.
-    **
-    ** Doing this prevents some deadlock scenarios. For example, thread 1 may
-    ** be a checkpointer blocked waiting on the WRITER lock. And thread 2
-    ** may be a normal SQL client upgrading to a write transaction. In this
-    ** case thread 2 does a non-blocking request for the WRITER lock. But -
-    ** if it were to use sqlite3_mutex_enter() then it would effectively
-    ** become a (doomed) blocking request, as thread 2 would block until thread
-    ** 1 obtained WRITER and released the mutex. Since thread 2 already holds
-    ** a lock on a read-locking slot at this point, this breaks the
-    ** anti-deadlock rules (see above).  */
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    int iMutex;
-    for(iMutex=ofst; iMutex<ofst+n; iMutex++){
-      if( flags==(SQLITE_SHM_LOCK|SQLITE_SHM_EXCLUSIVE) ){
-        rc = sqlite3_mutex_try(pShmNode->aMutex[iMutex]);
-        if( rc!=SQLITE_OK ) goto leave_shmnode_mutexes;
-      }else{
-        sqlite3_mutex_enter(pShmNode->aMutex[iMutex]);
-      }
-    }
-#else
-    sqlite3_mutex_enter(pShmNode->pShmMutex);
-#endif
-
-    if( ALWAYS(rc==SQLITE_OK) ){
-      if( flags & SQLITE_SHM_UNLOCK ){
-        /* Case (a) - unlock.  */
-        int bUnlock = 1;
-        assert( (p->exclMask & p->sharedMask)==0 );
-        assert( !(flags & SQLITE_SHM_EXCLUSIVE) || (p->exclMask & mask)==mask );
-        assert( !(flags & SQLITE_SHM_SHARED) || (p->sharedMask & mask)==mask );
-
-        /* If this is a SHARED lock being unlocked, it is possible that other
-        ** clients within this process are holding the same SHARED lock. In
-        ** this case, set bUnlock to 0 so that the posix lock is not removed
-        ** from the file-descriptor below.  */
-        if( flags & SQLITE_SHM_SHARED ){
-          assert( n==1 );
-          assert( aLock[ofst]>=1 );
-          if( aLock[ofst]>1 ){
-            bUnlock = 0;
-            aLock[ofst]--;
-            p->sharedMask &= ~mask;
-          }
-        }
-
-        if( bUnlock ){
-          rc = unixShmSystemLock(pDbFd, F_UNLCK, ofst+UNIX_SHM_BASE, n);
-          if( rc==SQLITE_OK ){
-            memset(&aLock[ofst], 0, sizeof(int)*n);
-            p->sharedMask &= ~mask;
-            p->exclMask &= ~mask;
-          }
-        }
-      }else if( flags & SQLITE_SHM_SHARED ){
-        /* Case (b) - a shared lock.  */
-
-        if( aLock[ofst]<0 ){
-          /* An exclusive lock is held by some other connection. BUSY. */
-          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{
-        /* Case (c) - an exclusive lock.  */
-        int ii;
-
-        assert( flags==(SQLITE_SHM_LOCK|SQLITE_SHM_EXCLUSIVE) );
-        assert( (p->sharedMask & mask)==0 );
-        assert( (p->exclMask & mask)==0 );
-
-        /* Make sure no sibling connections hold locks that will block this
-        ** lock.  If any do, return SQLITE_BUSY right away.  */
-        for(ii=ofst; ii<ofst+n; ii++){
-          if( aLock[ii] ){
-            rc = SQLITE_BUSY;
-            break;
-          }
-        }
-
-        /* Get the exclusive locks at the system level. Then if successful
-        ** also update the in-memory values. */
-        if( rc==SQLITE_OK ){
-          rc = unixShmSystemLock(pDbFd, F_WRLCK, ofst+UNIX_SHM_BASE, n);
-          if( rc==SQLITE_OK ){
-            p->exclMask |= mask;
-            for(ii=ofst; ii<ofst+n; ii++){
-              aLock[ii] = -1;
-            }
-          }
-        }
-      }
-      assert( assertLockingArrayOk(pShmNode) );
-    }
-
-    /* Drop the mutexes acquired above. */
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  leave_shmnode_mutexes:
-    for(iMutex--; iMutex>=ofst; iMutex--){
-      sqlite3_mutex_leave(pShmNode->aMutex[iMutex]);
-    }
-#else
-    sqlite3_mutex_leave(pShmNode->pShmMutex);
-#endif
-  }
-
-  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 ){
-    /* Ensure that there is always at least a 256 byte buffer of addressable
-    ** memory following the returned page. If the database is corrupt,
-    ** SQLite may overread the page slightly (in practice only a few bytes,
-    ** but 256 is safe, round, number).  */
-    const int nEofBuffer = 256;
-    if( pFd->pMapRegion==0 ){
-      int rc = unixMapfile(pFd, -1);
-      if( rc!=SQLITE_OK ) return rc;
-    }
-    if( pFd->mmapSize >= (iOff+nAmt+nEofBuffer) ){
-      *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;
-    }
-    if( pNew->ctrlFlags & UNIXFILE_DELETE ){
-      osUnlink(zFilename);
-    }
-    if( pNew->pId ){
-      vxworksReleaseFileId(pNew->pId);
-      pNew->pId = 0;
-    }
-  }
-#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
-#if OS_VXWORKS
-     && zDir[0]=='/'
-#endif
-     && 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:
-    **
-    **   "<path to db>-journal"
-    **   "<path to db>-wal"
-    **   "<path to db>-journalNN"
-    **   "<path to db>-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
-  );
-
-#if OS_VXWORKS
-  /* The file-ID mechanism used in Vxworks requires that all pathnames
-  ** provided to unixOpen must be absolute pathnames. */
-  if( zPath!=0 && zPath[0]!='/' ){ return SQLITE_CANTOPEN; }
-#endif
-
-  /* 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. */
-        UnixUnusedFd *pReadonly = 0;
-        flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
-        openFlags &= ~(O_RDWR|O_CREAT);
-        flags |= SQLITE_OPEN_READONLY;
-        openFlags |= O_RDONLY;
-        isReadonly = 1;
-        pReadonly = findReusableFd(zName, flags);
-        if( pReadonly ){
-          fd = pReadonly->fd;
-          sqlite3_free(pReadonly);
-        }else{
-          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
-       || eType==SQLITE_OPEN_TEMP_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 <dlfcn.h>
-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 !defined(HAVE_NANOSLEEP) || HAVE_NANOSLEEP+0
-  struct timespec sp;
-  sp.tv_sec = microseconds / 1000000;
-  sp.tv_nsec = (microseconds % 1000000) * 1000;
-
-  /* Almost all modern unix systems support nanosleep().  But if you are
-  ** compiling for one of the rare exceptions, you can use
-  ** -DHAVE_NANOSLEEP=0 (perhaps in conjunction with -DHAVE_USLEEP if
-  ** usleep() is available) in order to bypass the use of nanosleep() */
-  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,
-**                       <proxy_path> | ":auto:");
-**  sqlite3_file_control(db, dbname, SQLITE_FCNTL_GET_LOCKPROXYFILE,
-**                       &<proxy_path>);
-**
-**
-** SQL pragmas
-**
-**  PRAGMA [database.]lock_proxy_file=<proxy_path> | :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 "<tmpdir>/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 ".<databasename>-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<dbLen && (i+len+7)<(int)maxLen; i++){
-    char c = dbPath[i];
-    lPath[i+len] = (c=='/')?'_':c;
-  }
-  lPath[i+len]='\0';
-  strlcat(lPath, ":auto:", maxLen);
-  OSTRACE(("GETLOCKPATH  proxy lock path=%s pid=%d\n", lPath, osGetpid(0)));
-  return SQLITE_OK;
-}
-
-/*
- ** Creates the lock file and any missing directories in lockPath
- */
-static int proxyCreateLockPath(const char *lockPath){
-  int i, len;
-  char buf[MAXPATHLEN];
-  int start = 0;
-
-  assert(lockPath!=NULL);
-  /* try to create all the intermediate directories */
-  len = (int)strlen(lockPath);
-  buf[0] = lockPath[0];
-  for( i=1; i<len; i++ ){
-    if( lockPath[i] == '/' && (i - start > 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( readLen<PROXY_PATHINDEX ){
-    sqlite3_snprintf(sizeof(errmsg),errmsg,"read error (len %d)",(int)readLen);
-    goto end_breaklock;
-  }
-  /* write it out to the temporary break file */
-  fd = robust_open(tPath, (O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW), 0);
-  if( fd<0 ){
-    sqlite3_snprintf(sizeof(errmsg), errmsg, "create failed (%d)", errno);
-    goto end_breaklock;
-  }
-  if( osPwrite(fd, buf, readLen, 0) != (ssize_t)readLen ){
-    sqlite3_snprintf(sizeof(errmsg), errmsg, "write failed (%d)", errno);
-    goto end_breaklock;
-  }
-  if( rename(tPath, cPath) ){
-    sqlite3_snprintf(sizeof(errmsg), errmsg, "rename failed (%d)", errno);
-    goto end_breaklock;
-  }
-  rc = 0;
-  fprintf(stderr, "broke stale lock on %s\n", cPath);
-  robust_close(pFile, conchFile->h, __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 ( i<len ){
-    conchPath[i+1]=dbPath[i];
-    i++;
-  }
-
-  /* append the "-conch" suffix to the file */
-  memcpy(&conchPath[i+1], "-conch", 7);
-  assert( (int)strlen(conchPath) == len+7 );
-
-  return SQLITE_OK;
-}
-
-
-/* Takes a fully configured proxy locking-style unix file and switches
-** the local lock file path
-*/
-static int switchLockProxyPath(unixFile *pFile, const char *path) {
-  proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
-  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);
-#if OS_VXWORKS
-  vxworksMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS2);
-#endif
-
-#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;
-#if OS_VXWORKS
-  vxworksMutex = 0;
-#endif
-  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 && !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) && \
-    !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)
-
-#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);
-
-/*
-** 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
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  DWORD iBusyTimeout;        /* Wait this many millisec on locks */
-  int bBlockOnConnect;
-#endif
-};
-
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-# define winFileBusyTimeout(pDbFd) pDbFd->iBusyTimeout
-#else
-# define winFileBusyTimeout(pDbFd) 0
-#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
-#  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
-  { "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 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 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 || 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 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 && 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 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)
-
-  { "GetFileSize",             (SYSCALL)GetFileSize,             0 },
-
-#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 && 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)
-
-/*
-** For GetLastError(), MSDN says:
-**
-** Minimum supported client: Windows XP [desktop apps | UWP apps]
-** Minimum supported server: Windows Server 2003 [desktop apps | UWP apps]
-*/
-  { "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)
-
-  { "GetSystemInfo",           (SYSCALL)GetSystemInfo,           0 },
-#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 defined(SQLITE_WIN32_HAS_WIDE)
-  { "GetTempPathW",            (SYSCALL)GetTempPathW,            0 },
-#else
-  { "GetTempPathW",            (SYSCALL)0,                       0 },
-#endif
-
-#define osGetTempPathW ((DWORD(WINAPI*)(DWORD,LPWSTR))aSyscall[32].pCurrent)
-
-  { "GetTickCount",            (SYSCALL)GetTickCount,            0 },
-
-#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 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)
-
-  { "HeapCreate",              (SYSCALL)HeapCreate,              0 },
-
-#define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \
-        SIZE_T))aSyscall[37].pCurrent)
-
-  { "HeapDestroy",             (SYSCALL)HeapDestroy,             0 },
-
-#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)
-
-  { "HeapValidate",            (SYSCALL)HeapValidate,            0 },
-
-#define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \
-        LPCVOID))aSyscall[42].pCurrent)
-
-#if !SQLITE_OS_WINCE
-  { "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 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)
-
-  { "LocalFree",               (SYSCALL)LocalFree,               0 },
-
-#define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[46].pCurrent)
-
-#if !SQLITE_OS_WINCE
-  { "LockFile",                (SYSCALL)LockFile,                0 },
-#else
-  { "LockFile",                (SYSCALL)0,                       0 },
-#endif
-
-#if !defined(osLockFile) && defined(SQLITE_WIN32_HAS_ANSI)
-#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 || !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)
-
-  { "SetFilePointer",          (SYSCALL)SetFilePointer,          0 },
-
-#define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \
-        DWORD))aSyscall[54].pCurrent)
-
-  { "Sleep",                   (SYSCALL)Sleep,                   0 },
-
-#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
-  { "UnlockFile",              (SYSCALL)UnlockFile,              0 },
-#else
-  { "UnlockFile",              (SYSCALL)0,                       0 },
-#endif
-
-#if !defined(osUnlockFile) && defined(SQLITE_WIN32_HAS_ANSI)
-#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)
-
-/*
-** For WaitForSingleObject(), MSDN says:
-**
-** Minimum supported client: Windows XP [desktop apps | UWP apps]
-** Minimum supported server: Windows Server 2003 [desktop apps | UWP apps]
-*/
-  { "WaitForSingleObject",     (SYSCALL)WaitForSingleObject,     0 },
-
-#define osWaitForSingleObject ((DWORD(WINAPI*)(HANDLE, \
-        DWORD))aSyscall[62].pCurrent)
-
-#if !SQLITE_OS_WINCE
-  { "WaitForSingleObjectEx",   (SYSCALL)WaitForSingleObjectEx,   0 },
-#else
-  { "WaitForSingleObjectEx",   (SYSCALL)0,                       0 },
-#endif
-
-#define osWaitForSingleObjectEx ((DWORD(WINAPI*)(HANDLE,DWORD, \
-        BOOL))aSyscall[63].pCurrent)
-
-  { "GetNativeSystemInfo",     (SYSCALL)GetNativeSystemInfo,     0 },
-
-#define osGetNativeSystemInfo ((VOID(WINAPI*)( \
-        LPSYSTEM_INFO))aSyscall[64].pCurrent)
-
-#if defined(SQLITE_WIN32_HAS_ANSI)
-  { "OutputDebugStringA",      (SYSCALL)OutputDebugStringA,      0 },
-#else
-  { "OutputDebugStringA",      (SYSCALL)0,                       0 },
-#endif
-
-#define osOutputDebugStringA ((VOID(WINAPI*)(LPCSTR))aSyscall[65].pCurrent)
-
-#if defined(SQLITE_WIN32_HAS_WIDE)
-  { "OutputDebugStringW",      (SYSCALL)OutputDebugStringW,      0 },
-#else
-  { "OutputDebugStringW",      (SYSCALL)0,                       0 },
-#endif
-
-#define osOutputDebugStringW ((VOID(WINAPI*)(LPCWSTR))aSyscall[66].pCurrent)
-
-  { "GetProcessHeap",          (SYSCALL)GetProcessHeap,          0 },
-
-#define osGetProcessHeap ((HANDLE(WINAPI*)(VOID))aSyscall[67].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[68].pCurrent)
-#endif /* defined(InterlockedCompareExchange) */
-
-#if !SQLITE_OS_WINCE && SQLITE_WIN32_USE_UUID
-  { "UuidCreate",               (SYSCALL)UuidCreate,             0 },
-#else
-  { "UuidCreate",               (SYSCALL)0,                      0 },
-#endif
-
-#define osUuidCreate ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[69].pCurrent)
-
-#if !SQLITE_OS_WINCE && SQLITE_WIN32_USE_UUID
-  { "UuidCreateSequential",     (SYSCALL)UuidCreateSequential,   0 },
-#else
-  { "UuidCreateSequential",     (SYSCALL)0,                      0 },
-#endif
-
-#define osUuidCreateSequential \
-        ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[70].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[71].pCurrent)
-
-/*
-** If SQLITE_ENABLE_SETLK_TIMEOUT is defined, we require CreateEvent()
-** to implement blocking locks with timeouts. MSDN says:
-**
-** Minimum supported client: Windows XP [desktop apps | UWP apps]
-** Minimum supported server: Windows Server 2003 [desktop apps | UWP apps]
-*/
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  { "CreateEvent",              (SYSCALL)CreateEvent,            0 },
-#else
-  { "CreateEvent",              (SYSCALL)0,                      0 },
-#endif
-
-#define osCreateEvent ( \
-    (HANDLE(WINAPI*) (LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCSTR)) \
-    aSyscall[72].pCurrent \
-)
-
-/*
-** If SQLITE_ENABLE_SETLK_TIMEOUT is defined, we require CancelIo()
-** for the case where a timeout expires and a lock request must be
-** cancelled.
-**
-** Minimum supported client: Windows XP [desktop apps | UWP apps]
-** Minimum supported server: Windows Server 2003 [desktop apps | UWP apps]
-*/
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  { "CancelIo",                 (SYSCALL)CancelIo,               0 },
-#else
-  { "CancelIo",                 (SYSCALL)0,                      0 },
-#endif
-
-#define osCancelIo ((BOOL(WINAPI*)(HANDLE))aSyscall[73].pCurrent)
-
-#if defined(SQLITE_WIN32_HAS_WIDE) && defined(_WIN32)
-  { "GetModuleHandleW",         (SYSCALL)GetModuleHandleW,       0 },
-#else
-  { "GetModuleHandleW",         (SYSCALL)0,                      0 },
-#endif
-
-#define osGetModuleHandleW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[74].pCurrent)
-
-#ifndef _WIN32
-  { "getenv",                   (SYSCALL)getenv,                 0 },
-#else
-  { "getenv",                   (SYSCALL)0,                      0 },
-#endif
-
-#define osGetenv ((const char *(*)(const char *))aSyscall[75].pCurrent)
-
-#ifndef _WIN32
-  { "getcwd",                   (SYSCALL)getcwd,                 0 },
-#else
-  { "getcwd",                   (SYSCALL)0,                      0 },
-#endif
-
-#define osGetcwd ((char*(*)(char*,size_t))aSyscall[76].pCurrent)
-
-#ifndef _WIN32
-  { "readlink",                 (SYSCALL)readlink,               0 },
-#else
-  { "readlink",                 (SYSCALL)0,                      0 },
-#endif
-
-#define osReadlink ((ssize_t(*)(const char*,char*,size_t))aSyscall[77].pCurrent)
-
-#ifndef _WIN32
-  { "lstat",                    (SYSCALL)lstat,                  0 },
-#else
-  { "lstat",                    (SYSCALL)0,                      0 },
-#endif
-
-#define osLstat ((int(*)(const char*,struct stat*))aSyscall[78].pCurrent)
-
-#ifndef _WIN32
-  { "__errno",                  (SYSCALL)__errno,                0 },
-#else
-  { "__errno",                  (SYSCALL)0,                      0 },
-#endif
-
-#define osErrno (*((int*(*)(void))aSyscall[79].pCurrent)())
-
-#ifndef _WIN32
-  { "cygwin_conv_path",         (SYSCALL)cygwin_conv_path,       0 },
-#else
-  { "cygwin_conv_path",         (SYSCALL)0,                      0 },
-#endif
-
-#define osCygwin_conv_path ((size_t(*)(unsigned int, \
-    const void *, void *, size_t))aSyscall[80].pCurrent)
-
-}; /* End of the overrideable system calls */
-
-/*
-** This is the xSetSystemCall() method of sqlite3_vfs for all of the
-** "win32" VFSes.  Return SQLITE_OK upon 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; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
-      if( aSyscall[i].pDefault ){
-        aSyscall[i].pCurrent = aSyscall[i].pDefault;
-      }
-    }
-  }else{
-    /* If zName is specified, operate on only the one system call
-    ** specified.
-    */
-    for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
-      if( strcmp(zName, aSyscall[i].zName)==0 ){
-        if( aSyscall[i].pDefault==0 ){
-          aSyscall[i].pDefault = aSyscall[i].pCurrent;
-        }
-        rc = SQLITE_OK;
-        if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
-        aSyscall[i].pCurrent = pNewFunc;
-        break;
-      }
-    }
-  }
-  return rc;
-}
-
-/*
-** Return the value of a system call.  Return NULL if zName is not a
-** recognized system call name.  NULL is also returned if the system call
-** is currently undefined.
-*/
-static sqlite3_syscall_ptr winGetSystemCall(
-  sqlite3_vfs *pNotUsed,
-  const char *zName
-){
-  unsigned int i;
-
-  UNUSED_PARAMETER(pNotUsed);
-  for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
-    if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
-  }
-  return 0;
-}
-
-/*
-** Return the name of the first system call after zName.  If zName==NULL
-** then return the name of the first system call.  Return NULL if zName
-** is the last system call or if zName is not the name of a valid
-** system call.
-*/
-static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
-  int i = -1;
-
-  UNUSED_PARAMETER(p);
-  if( zName ){
-    for(i=0; i<ArraySize(aSyscall)-1; i++){
-      if( strcmp(zName, aSyscall[i].zName)==0 ) break;
-    }
-  }
-  for(i++; i<ArraySize(aSyscall); i++){
-    if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
-  }
-  return 0;
-}
-
-#ifdef SQLITE_WIN32_MALLOC
-/*
-** If a Win32 native heap has been configured, this function will attempt to
-** compact it.  Upon success, SQLITE_OK will be returned.  Upon failure, one
-** of SQLITE_NOMEM, SQLITE_ERROR, or SQLITE_NOTFOUND will be returned.  The
-** "pnLargest" argument, if non-zero, will be used to return the size of the
-** largest committed free block in the heap, in bytes.
-*/
-SQLITE_API int sqlite3_win32_compact_heap(LPUINT pnLargest){
-  int rc = SQLITE_OK;
-  UINT nLargest = 0;
-  HANDLE hHeap;
-
-  winMemAssertMagic();
-  hHeap = winMemGetHeap();
-  assert( hHeap!=0 );
-  assert( hHeap!=INVALID_HANDLE_VALUE );
-#if defined(SQLITE_WIN32_MALLOC_VALIDATE)
-  assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
-#endif
-#if !SQLITE_OS_WINCE
-  if( (nLargest=osHeapCompact(hHeap, SQLITE_WIN32_HEAP_FLAGS))==0 ){
-    DWORD lastErrno = osGetLastError();
-    if( lastErrno==NO_ERROR ){
-      sqlite3_log(SQLITE_NOMEM, "failed to HeapCompact (no space), heap=%p",
-                  (void*)hHeap);
-      rc = SQLITE_NOMEM_BKPT;
-    }else{
-      sqlite3_log(SQLITE_ERROR, "failed to HeapCompact (%lu), heap=%p",
-                  osGetLastError(), (void*)hHeap);
-      rc = SQLITE_ERROR;
-    }
-  }
-#else
-  sqlite3_log(SQLITE_NOTFOUND, "failed to HeapCompact, heap=%p",
-              (void*)hHeap);
-  rc = SQLITE_NOTFOUND;
-#endif
-  if( pnLargest ) *pnLargest = nLargest;
-  return rc;
-}
-
-/*
-** If a Win32 native heap has been configured, this function will attempt to
-** destroy and recreate it.  If the Win32 native heap is not isolated and/or
-** the sqlite3_memory_used() function does not return zero, SQLITE_BUSY will
-** be returned and no changes will be made to the Win32 native heap.
-*/
-SQLITE_API int sqlite3_win32_reset_heap(){
-  int rc;
-  MUTEX_LOGIC( sqlite3_mutex *pMainMtx; ) /* The main static mutex */
-  MUTEX_LOGIC( sqlite3_mutex *pMem; )    /* The memsys static mutex */
-  MUTEX_LOGIC( pMainMtx = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
-  MUTEX_LOGIC( pMem = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); )
-  sqlite3_mutex_enter(pMainMtx);
-  sqlite3_mutex_enter(pMem);
-  winMemAssertMagic();
-  if( winMemGetHeap()!=NULL && winMemGetOwned() && sqlite3_memory_used()==0 ){
-    /*
-    ** At this point, there should be no outstanding memory allocations on
-    ** the heap.  Also, since both the main and memsys locks are currently
-    ** being held by us, no other function (i.e. from another thread) should
-    ** be able to even access the heap.  Attempt to destroy and recreate our
-    ** isolated Win32 native heap now.
-    */
-    assert( winMemGetHeap()!=NULL );
-    assert( winMemGetOwned() );
-    assert( sqlite3_memory_used()==0 );
-    winMemShutdown(winMemGetDataPtr());
-    assert( winMemGetHeap()==NULL );
-    assert( !winMemGetOwned() );
-    assert( sqlite3_memory_used()==0 );
-    rc = winMemInit(winMemGetDataPtr());
-    assert( rc!=SQLITE_OK || winMemGetHeap()!=NULL );
-    assert( rc!=SQLITE_OK || winMemGetOwned() );
-    assert( rc!=SQLITE_OK || sqlite3_memory_used()==0 );
-  }else{
-    /*
-    ** The Win32 native heap cannot be modified because it may be in use.
-    */
-    rc = SQLITE_BUSY;
-  }
-  sqlite3_mutex_leave(pMem);
-  sqlite3_mutex_leave(pMainMtx);
-  return rc;
-}
-#endif /* SQLITE_WIN32_MALLOC */
-
-#ifdef _WIN32
-/*
-** This function outputs the specified (ANSI) string to the Win32 debugger
-** (if available).
-*/
-
-SQLITE_API void sqlite3_win32_write_debug(const char *zBuf, int nBuf){
-  char zDbgBuf[SQLITE_WIN32_DBG_BUF_SIZE];
-  int nMin = MIN(nBuf, (SQLITE_WIN32_DBG_BUF_SIZE - 1)); /* may be negative. */
-  if( nMin<-1 ) nMin = -1; /* all negative values become -1. */
-  assert( nMin==-1 || nMin==0 || nMin<SQLITE_WIN32_DBG_BUF_SIZE );
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !zBuf ){
-    (void)SQLITE_MISUSE_BKPT;
-    return;
-  }
-#endif
-#if defined(SQLITE_WIN32_HAS_ANSI)
-  if( nMin>0 ){
-    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
-}
-#endif /* _WIN32 */
-
-SQLITE_API void sqlite3_win32_sleep(DWORD milliseconds){
-  osSleep(milliseconds);
-}
-
-#if SQLITE_MAX_WORKER_THREADS>0 && !SQLITE_OS_WINCE && \
-        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 || !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_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
-      || osInterlockedCompareExchange(&sqlite3_os_type, 0, 0)==0
-  ;
-#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 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 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 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 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_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 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 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 */
-
-#ifdef _WIN32
-/*
-** 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;
-}
-#endif /* _WIN32 */
-
-/*
-** 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 nWideChar;
-  LPWSTR zMbcsText;
-  int codepage = useAnsi ? CP_ACP : CP_OEMCP;
-
-  nWideChar = osMultiByteToWideChar(codepage, 0, zText, -1, NULL,
-                                0);
-  if( nWideChar==0 ){
-    return 0;
-  }
-  zMbcsText = sqlite3MallocZero( nWideChar*sizeof(WCHAR) );
-  if( zMbcsText==0 ){
-    return 0;
-  }
-  nWideChar = osMultiByteToWideChar(codepage, 0, zText, -1, zMbcsText,
-                                nWideChar);
-  if( nWideChar==0 ){
-    sqlite3_free(zMbcsText);
-    zMbcsText = 0;
-  }
-  return zMbcsText;
-}
-
-#ifdef _WIN32
-/*
-** 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;
-}
-#endif /* _WIN32 */
-
-/*
-** 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;
-}
-
-#ifdef _WIN32
-/*
-** 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);
-}
-#endif /* _WIN32 */
-
-/*
-** 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());
-}
-
-#ifdef _WIN32
-/*
-** 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);
-}
-#endif /* _WIN32 */
-
-/*
-** 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() ){
-    LPWSTR zTempWide = NULL;
-    dwLen = osFormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                             FORMAT_MESSAGE_FROM_SYSTEM |
-                             FORMAT_MESSAGE_IGNORE_INSERTS,
-                             NULL,
-                             lastErrno,
-                             0,
-                             (LPWSTR) &zTempWide,
-                             0,
-                             0);
-    if( dwLen > 0 ){
-      /* allocate a buffer and convert to UTF8 */
-      sqlite3BeginBenignMalloc();
-      zOut = winUnicodeToUtf8(zTempWide);
-      sqlite3EndBenignMalloc();
-      /* free the system buffer allocated by FormatMessage */
-      osLocalFree(zTempWide);
-    }
-  }
-#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 <time.h> */
-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);
-#ifdef SQLITE_WIN32_HAS_ANSI
-  }else{
-    return osLockFile(*phFile, offsetLow, offsetHigh, numBytesLow,
-                      numBytesHigh);
-#endif
-  }
-#endif
-}
-
-#ifndef SQLITE_OMIT_WAL
-/*
-** Lock a region of nByte bytes starting at offset offset of file hFile.
-** Take an EXCLUSIVE lock if parameter bExclusive is true, or a SHARED lock
-** otherwise. If nMs is greater than zero and the lock cannot be obtained
-** immediately, block for that many ms before giving up.
-**
-** This function returns SQLITE_OK if the lock is obtained successfully. If
-** some other process holds the lock, SQLITE_BUSY is returned if nMs==0, or
-** SQLITE_BUSY_TIMEOUT otherwise. Or, if an error occurs, SQLITE_IOERR.
-*/
-static int winHandleLockTimeout(
-  HANDLE hFile,
-  DWORD offset,
-  DWORD nByte,
-  int bExcl,
-  DWORD nMs
-){
-  DWORD flags = LOCKFILE_FAIL_IMMEDIATELY | (bExcl?LOCKFILE_EXCLUSIVE_LOCK:0);
-  int rc = SQLITE_OK;
-  BOOL ret;
-
-  if( !osIsNT() ){
-    ret = winLockFile(&hFile, flags, offset, 0, nByte, 0);
-  }else{
-    OVERLAPPED ovlp;
-    memset(&ovlp, 0, sizeof(OVERLAPPED));
-    ovlp.Offset = offset;
-
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    if( nMs!=0 ){
-      flags &= ~LOCKFILE_FAIL_IMMEDIATELY;
-    }
-    ovlp.hEvent = osCreateEvent(NULL, TRUE, FALSE, NULL);
-    if( ovlp.hEvent==NULL ){
-      return SQLITE_IOERR_LOCK;
-    }
-#endif
-
-    ret = osLockFileEx(hFile, flags, 0, nByte, 0, &ovlp);
-
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    /* If SQLITE_ENABLE_SETLK_TIMEOUT is defined, then the file-handle was
-    ** opened with FILE_FLAG_OVERHEAD specified. In this case, the call to
-    ** LockFileEx() may fail because the request is still pending. This can
-    ** happen even if LOCKFILE_FAIL_IMMEDIATELY was specified.
-    **
-    ** If nMs is 0, then LOCKFILE_FAIL_IMMEDIATELY was set in the flags
-    ** passed to LockFileEx(). In this case, if the operation is pending,
-    ** block indefinitely until it is finished.
-    **
-    ** Otherwise, wait for up to nMs ms for the operation to finish. nMs
-    ** may be set to INFINITE.
-    */
-    if( !ret && GetLastError()==ERROR_IO_PENDING ){
-      DWORD nDelay = (nMs==0 ? INFINITE : nMs);
-      DWORD res = osWaitForSingleObject(ovlp.hEvent, nDelay);
-      if( res==WAIT_OBJECT_0 ){
-        ret = TRUE;
-      }else if( res==WAIT_TIMEOUT ){
-#if SQLITE_ENABLE_SETLK_TIMEOUT==1
-        rc = SQLITE_BUSY_TIMEOUT;
-#else
-        rc = SQLITE_BUSY;
-#endif
-      }else{
-        /* Some other error has occurred */
-        rc = SQLITE_IOERR_LOCK;
-      }
-
-      /* If it is still pending, cancel the LockFileEx() call. */
-      osCancelIo(hFile);
-    }
-
-    osCloseHandle(ovlp.hEvent);
-#endif
-  }
-
-  if( rc==SQLITE_OK && !ret ){
-    rc = SQLITE_BUSY;
-  }
-  return rc;
-}
-#endif /* #ifndef SQLITE_OMIT_WAL */
-
-/*
-** 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);
-#ifdef SQLITE_WIN32_HAS_ANSI
-  }else{
-    return osUnlockFile(*phFile, offsetLow, offsetHigh, numBytesLow,
-                        numBytesHigh);
-#endif
-  }
-#endif
-}
-
-#ifndef SQLITE_OMIT_WAL
-/*
-** Remove an nByte lock starting at offset iOff from HANDLE h.
-*/
-static int winHandleUnlock(HANDLE h, int iOff, int nByte){
-  BOOL ret = winUnlockFile(&h, iOff, 0, nByte, 0);
-  return (ret ? SQLITE_OK : SQLITE_IOERR_UNLOCK);
-}
-#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
-
-/*
-** Seek the file handle h to offset nByte of the file.
-**
-** If successful, return SQLITE_OK. Or, if an error occurs, return an SQLite
-** error code.
-*/
-static int winHandleSeek(HANDLE h, sqlite3_int64 iOffset){
-  int rc = SQLITE_OK;             /* Return value */
-
-  LONG upperBits;                 /* Most sig. 32 bits of new offset */
-  LONG lowerBits;                 /* Least sig. 32 bits of new offset */
-  DWORD dwRet;                    /* Value returned by SetFilePointer() */
-
-  upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
-  lowerBits = (LONG)(iOffset & 0xffffffff);
-
-  dwRet = osSetFilePointer(h, lowerBits, &upperBits, FILE_BEGIN);
-
-  /* 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().  */
-  if( dwRet==INVALID_SET_FILE_POINTER ){
-    DWORD lastErrno = osGetLastError();
-    if( lastErrno!=NO_ERROR ){
-      rc = SQLITE_IOERR_SEEK;
-    }
-  }
-  OSTRACE(("SEEK file=%p, offset=%lld rc=%s\n", h, iOffset,sqlite3ErrName(rc)));
-  return rc;
-}
-
-/*
-** 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){
-  int rc;
-
-  rc = winHandleSeek(pFile->h, iOffset);
-  if( rc!=SQLITE_OK ){
-    pFile->lastErrno = osGetLastError();
-    winLogError(rc, pFile->lastErrno, "winSeekFile", pFile->zPath);
-  }
-  return rc;
-}
-
-
-#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 transferring
-  ** data from the memory mapping using memcpy().  */
-  if( offset<pFile->mmapSize ){
-    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 transferring
-  ** data from the memory mapping using memcpy().  */
-  if( offset<pFile->mmapSize ){
-    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;
-}
-
-#ifndef SQLITE_OMIT_WAL
-/*
-** Truncate the file opened by handle h to nByte bytes in size.
-*/
-static int winHandleTruncate(HANDLE h, sqlite3_int64 nByte){
-  int rc = SQLITE_OK;             /* Return code */
-  rc = winHandleSeek(h, nByte);
-  if( rc==SQLITE_OK ){
-    if( 0==osSetEndOfFile(h) ){
-      rc = SQLITE_IOERR_TRUNCATE;
-    }
-  }
-  return rc;
-}
-
-/*
-** Determine the size in bytes of the file opened by the handle passed as
-** the first argument.
-*/
-static int winHandleSize(HANDLE h, sqlite3_int64 *pnByte){
-  int rc = SQLITE_OK;
-  DWORD upperBits = 0;
-  DWORD lowerBits = 0;
-
-  assert( pnByte );
-  lowerBits = osGetFileSize(h, &upperBits);
-  *pnByte = (((sqlite3_int64)upperBits)<<32) + lowerBits;
-  if( lowerBits==INVALID_FILE_SIZE && osGetLastError()!=NO_ERROR ){
-    rc = SQLITE_IOERR_FSTAT;
-  }
-  return rc;
-}
-
-/*
-** Close the handle passed as the only argument.
-*/
-static void winHandleClose(HANDLE h){
-  if( h!=INVALID_HANDLE_VALUE ){
-    osCloseHandle(h);
-  }
-}
-#endif /* #ifndef SQLITE_OMIT_WAL */
-
-/*
-** 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 transactions 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 occurring 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));
-  {
-    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);
-    }
-  }
-  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 bBlock){
-  int res;
-  DWORD mask = ~(bBlock ? LOCKFILE_FAIL_IMMEDIATELY : 0);
-  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&mask, 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&mask,
-                      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 an EXCLUSIVE 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( locktype==SHARED_LOCK
-   || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
-  ){
-    int cnt = 3;
-
-    /* Flags for the LockFileEx() call. This should be an exclusive lock if
-    ** this call is to obtain EXCLUSIVE, or a shared lock if this call is to
-    ** obtain SHARED.  */
-    int flags = LOCKFILE_FAIL_IMMEDIATELY;
-    if( locktype==EXCLUSIVE_LOCK ){
-      flags |= LOCKFILE_EXCLUSIVE_LOCK;
-    }
-    while( cnt>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.  */
-      res = winLockFile(&pFile->h, flags, PENDING_BYTE, 0, 1, 0);
-      if( res ) break;
-
-      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;
-      }
-
-      cnt--;
-      if( cnt>0 ) sqlite3_win32_sleep(1);
-    }
-    gotPendingLock = res;
-  }
-
-  /* Acquire a shared lock
-  */
-  if( locktype==SHARED_LOCK && res ){
-    assert( pFile->locktype==NO_LOCK );
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    res = winGetReadLock(pFile, pFile->bBlockOnConnect);
-#else
-    res = winGetReadLock(pFile, 0);
-#endif
-    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 );
-    (void)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, 0);
-    }
-  }
-
-  /* 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, 0) ){
-      /* 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_NULL_IO: {
-      (void)osCloseHandle(pFile->h);
-      pFile->h = NULL;
-      return SQLITE_OK;
-    }
-    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
-
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    case SQLITE_FCNTL_LOCK_TIMEOUT: {
-      int iOld = pFile->iBusyTimeout;
-      int iNew = *(int*)pArg;
-#if SQLITE_ENABLE_SETLK_TIMEOUT==1
-      pFile->iBusyTimeout = (iNew < 0) ? INFINITE : (DWORD)iNew;
-#elif SQLITE_ENABLE_SETLK_TIMEOUT==2
-      pFile->iBusyTimeout = (DWORD)(!!iNew);
-#else
-# error "SQLITE_ENABLE_SETLK_TIMEOUT must be set to 1 or 2"
-#endif
-      *(int*)pArg = iOld;
-      return SQLITE_OK;
-    }
-    case SQLITE_FCNTL_BLOCK_ON_CONNECT: {
-      int iNew = *(int*)pArg;
-      pFile->bBlockOnConnect = iNew;
-      return SQLITE_OK;
-    }
-#endif /* SQLITE_ENABLE_SETLK_TIMEOUT */
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_FILESTAT)
-    case SQLITE_FCNTL_FILESTAT: {
-      sqlite3_str *pStr = (sqlite3_str*)pArg;
-      sqlite3_str_appendf(pStr, "{\"h\":%llu", (sqlite3_uint64)pFile->h);
-      sqlite3_str_appendf(pStr, ",\"vfs\":\"%s\"", pFile->pVfs->zName);
-      if( pFile->locktype ){
-        static const char *azLock[] = { "SHARED", "RESERVED",
-                                      "PENDING", "EXCLUSIVE" };
-        sqlite3_str_appendf(pStr, ",\"locktype\":\"%s\"",
-                                  azLock[pFile->locktype-1]);
-      }
-#if SQLITE_MAX_MMAP_SIZE>0
-      if( pFile->mmapSize ){
-        sqlite3_str_appendf(pStr, ",\"mmapSize\":%lld", pFile->mmapSize);
-        sqlite3_str_appendf(pStr, ",\"nFetchOut\":%d", pFile->nFetchOut);
-      }
-#endif
-      sqlite3_str_append(pStr, "}", 1);
-      return SQLITE_OK;
-    }
-#endif /* SQLITE_DEBUG || SQLITE_ENABLE_FILESTAT */
-
-  }
-  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 | SQLITE_IOCAP_SUBPAGE_READ |
-         ((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;
-
-/*
-** 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
-**
-** On Cygwin, 3 possible input forms are accepted:
-** - If the filename starts with "<drive>:/" or "<drive>:\",
-**   it is converted to UTF-16 as-is.
-** - If the filename contains '/', it is assumed to be a
-**   Cygwin absolute path, it is converted to a win32
-**   absolute path in UTF-16.
-** - Otherwise it must be a filename only, the win32 filename
-**   is returned in UTF-16.
-** Note: If the function cygwin_conv_path() fails, only
-**   UTF-8 -> UTF-16 conversion will be done. This can only
-**   happen when the file path >32k, in which case winUtf8ToUnicode()
-**   will fail too.
-*/
-static void *winConvertFromUtf8Filename(const char *zFilename){
-  void *zConverted = 0;
-  if( osIsNT() ){
-#ifdef __CYGWIN__
-    int nChar;
-    LPWSTR zWideFilename;
-
-    if( osCygwin_conv_path && !(winIsDriveLetterAndColon(zFilename)
-        && winIsDirSep(zFilename[2])) ){
-      i64 nByte;
-      int convertflag = CCP_POSIX_TO_WIN_W;
-      if( !strchr(zFilename, '/') ) convertflag |= CCP_RELATIVE;
-      nByte = (i64)osCygwin_conv_path(convertflag,
-          zFilename, 0, 0);
-      if( nByte>0 ){
-        zConverted = sqlite3MallocZero(12+(u64)nByte);
-        if ( zConverted==0 ){
-          return zConverted;
-        }
-        zWideFilename = zConverted;
-        /* Filenames should be prefixed, except when converted
-         * full path already starts with "\\?\". */
-        if( osCygwin_conv_path(convertflag, zFilename,
-                             zWideFilename+4, nByte)==0 ){
-          if( (convertflag&CCP_RELATIVE) ){
-            memmove(zWideFilename, zWideFilename+4, nByte);
-          }else if( memcmp(zWideFilename+4, L"\\\\", 4) ){
-            memcpy(zWideFilename, L"\\\\?\\", 8);
-          }else if( zWideFilename[6]!='?' ){
-            memmove(zWideFilename+6, zWideFilename+4, nByte);
-            memcpy(zWideFilename, L"\\\\?\\UNC", 14);
-          }else{
-            memmove(zWideFilename, zWideFilename+4, nByte);
-          }
-          return zConverted;
-        }
-        sqlite3_free(zConverted);
-      }
-    }
-    nChar = osMultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
-    if( nChar==0 ){
-      return 0;
-    }
-    zWideFilename = sqlite3MallocZero( nChar*sizeof(WCHAR)+12 );
-    if( zWideFilename==0 ){
-      return 0;
-    }
-    nChar = osMultiByteToWideChar(CP_UTF8, 0, zFilename, -1,
-                                  zWideFilename, nChar);
-    if( nChar==0 ){
-      sqlite3_free(zWideFilename);
-      zWideFilename = 0;
-    }else if( nChar>MAX_PATH
-        && winIsDriveLetterAndColon(zFilename)
-        && winIsDirSep(zFilename[2]) ){
-      memmove(zWideFilename+4, zWideFilename, nChar*sizeof(WCHAR));
-      zWideFilename[2] = '\\';
-      memcpy(zWideFilename, L"\\\\?\\", 8);
-    }else if( nChar>MAX_PATH
-        && winIsDirSep(zFilename[0]) && winIsDirSep(zFilename[1])
-        && zFilename[2] != '?' ){
-      memmove(zWideFilename+6, zWideFilename, nChar*sizeof(WCHAR));
-      memcpy(zWideFilename, L"\\\\?\\UNC", 14);
-    }
-    zConverted = zWideFilename;
-#else
-    zConverted = winUtf8ToUnicode(zFilename);
-#endif /* __CYGWIN__ */
-  }
-#if defined(SQLITE_WIN32_HAS_ANSI) && defined(_WIN32)
-  else{
-    zConverted = winUtf8ToMbcs(zFilename, osAreFileApisANSI());
-  }
-#endif
-  /* caller will handle out of memory */
-  return zConverted;
-}
-
-#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 editing the global linked list that starts
-** at winShmNodeList.
-**
-** When reading or writing the linked list starting at winShmNode.pWinShmList,
-** pShmNode->mutex must be held.
-**
-** The following fields are constant after the object is created:
-**
-**      zFilename
-**      hSharedShm
-**      mutex
-**      bUseSharedLockHandle
-**
-** Either winShmNode.mutex must be held or winShmNode.pWinShmList==0 and
-** winShmMutexHeld() is true when reading or writing any other field
-** in this structure.
-**
-** File-handle hSharedShm is always used to (a) take the DMS lock, (b)
-** truncate the *-shm file if the DMS-locking protocol demands it, and
-** (c) map regions of the *-shm file into memory using MapViewOfFile()
-** or similar. If bUseSharedLockHandle is true, then other locks are also
-** taken on hSharedShm. Or, if bUseSharedLockHandle is false, then other
-** locks are taken using each connection's winShm.hShm handles.
-*/
-struct winShmNode {
-  sqlite3_mutex *mutex;      /* Mutex to access this object */
-  char *zFilename;           /* Name of the file */
-  HANDLE hSharedShm;         /* File handle open on zFilename */
-  int bUseSharedLockHandle;  /* True to use hSharedShm for everything */
-
-  int isUnlocked;            /* DMS lock has not yet been obtained */
-  int isReadonly;            /* True if read-only */
-  int szRegion;              /* Size of shared-memory regions */
-  int nRegion;               /* Size of array apRegion */
-
-  struct ShmRegion {
-    HANDLE hMap;             /* File handle from CreateFileMapping */
-    void *pMap;
-  } *aRegion;
-  DWORD lastErrno;           /* The Windows errno from the last I/O error */
-
-  winShm *pWinShmList;       /* List of winShm objects with ptrs 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. There is one such structure for each
-** winFile open on a wal mode database.
-*/
-struct winShm {
-  winShmNode *pShmNode;      /* The underlying winShmNode object */
-  u16 sharedMask;            /* Mask of shared locks held */
-  u16 exclMask;              /* Mask of exclusive locks held */
-  HANDLE hShm;               /* File-handle on *-shm file. For locking. */
-  int bReadonly;             /* True if hShm is opened read-only */
-#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
-  u8 id;                     /* Id of this connection with its winShmNode */
-#endif
-  winShm *pWinShmNext;       /* Next winShm object on same winShmNode */
-};
-
-/*
-** 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 */
-
-/* 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.pWinShmList==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->pWinShmList==0 ){
-      int i;
-      if( p->mutex ){ sqlite3_mutex_free(p->mutex); }
-      for(i=0; i<p->nRegion; 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);
-      }
-      winHandleClose(p->hSharedShm);
-      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 the shm file associated with
-** pShmNode. Take the lock. Truncate the *-shm file if required.
-** Return SQLITE_OK if successful, or an SQLite error code otherwise.
-*/
-static int winLockSharedMemory(winShmNode *pShmNode, DWORD nMs){
-  HANDLE h = pShmNode->hSharedShm;
-  int rc = SQLITE_OK;
-
-  assert( sqlite3_mutex_held(pShmNode->mutex) );
-  rc = winHandleLockTimeout(h, WIN_SHM_DMS, 1, 1, 0);
-  if( rc==SQLITE_OK ){
-    /* We have an EXCLUSIVE lock on the DMS byte. This means that this
-    ** is the first process to open the file. Truncate it to zero bytes
-    ** in this case.  */
-    if( pShmNode->isReadonly ){
-      rc = SQLITE_READONLY_CANTINIT;
-    }else{
-      rc = winHandleTruncate(h, 0);
-    }
-
-    /* Release the EXCLUSIVE lock acquired above. */
-    winUnlockFile(&h, WIN_SHM_DMS, 0, 1, 0);
-  }else if( (rc & 0xFF)==SQLITE_BUSY ){
-    rc = SQLITE_OK;
-  }
-
-  if( rc==SQLITE_OK ){
-    /* Take a SHARED lock on the DMS byte. */
-    rc = winHandleLockTimeout(h, WIN_SHM_DMS, 1, 0, nMs);
-    if( rc==SQLITE_OK ){
-      pShmNode->isUnlocked = 0;
-    }
-  }
-
-  return rc;
-}
-
-
-/*
-** This function is used to open a handle on a *-shm file.
-**
-** If SQLITE_ENABLE_SETLK_TIMEOUT is defined at build time, then the file
-** is opened with FILE_FLAG_OVERLAPPED specified. If not, it is not.
-*/
-static int winHandleOpen(
-  const char *zUtf8,              /* File to open */
-  int *pbReadonly,                /* IN/OUT: True for readonly handle */
-  HANDLE *ph                      /* OUT: New HANDLE for file */
-){
-  int rc = SQLITE_OK;
-  void *zConverted = 0;
-  int bReadonly = *pbReadonly;
-  HANDLE h = INVALID_HANDLE_VALUE;
-
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  const DWORD flag_overlapped = FILE_FLAG_OVERLAPPED;
-#else
-  const DWORD flag_overlapped = 0;
-#endif
-
-  /* Convert the filename to the system encoding. */
-  zConverted = winConvertFromUtf8Filename(zUtf8);
-  if( zConverted==0 ){
-    OSTRACE(("OPEN name=%s, rc=SQLITE_IOERR_NOMEM", zUtf8));
-    rc = SQLITE_IOERR_NOMEM_BKPT;
-    goto winopenfile_out;
-  }
-
-  /* Ensure the file we are trying to open is not actually a directory. */
-  if( winIsDir(zConverted) ){
-    OSTRACE(("OPEN name=%s, rc=SQLITE_CANTOPEN_ISDIR", zUtf8));
-    rc = SQLITE_CANTOPEN_ISDIR;
-    goto winopenfile_out;
-  }
-
-  /* TODO: platforms.
-  ** TODO: retry-on-ioerr.
-  */
-  if( osIsNT() ){
-    h = osCreateFileW((LPCWSTR)zConverted,         /* lpFileName */
-        (GENERIC_READ | (bReadonly ? 0 : GENERIC_WRITE)),  /* dwDesiredAccess */
-        FILE_SHARE_READ | FILE_SHARE_WRITE,        /* dwShareMode */
-        NULL,                                      /* lpSecurityAttributes */
-        OPEN_ALWAYS,                               /* dwCreationDisposition */
-        FILE_ATTRIBUTE_NORMAL|flag_overlapped,
-        NULL
-    );
-  }else{
-    /* Due to pre-processor directives earlier in this file,
-    ** SQLITE_WIN32_HAS_ANSI is always defined if osIsNT() is false. */
-#ifdef SQLITE_WIN32_HAS_ANSI
-    h = osCreateFileA((LPCSTR)zConverted,
-        (GENERIC_READ | (bReadonly ? 0 : GENERIC_WRITE)),  /* dwDesiredAccess */
-        FILE_SHARE_READ | FILE_SHARE_WRITE,        /* dwShareMode */
-        NULL,                                      /* lpSecurityAttributes */
-        OPEN_ALWAYS,                               /* dwCreationDisposition */
-        FILE_ATTRIBUTE_NORMAL|flag_overlapped,
-        NULL
-    );
-#endif
-  }
-
-  if( h==INVALID_HANDLE_VALUE ){
-    if( bReadonly==0 ){
-      bReadonly = 1;
-      rc = winHandleOpen(zUtf8, &bReadonly, &h);
-    }else{
-      rc = SQLITE_CANTOPEN_BKPT;
-    }
-  }
-
- winopenfile_out:
-  sqlite3_free(zConverted);
-  *pbReadonly = bReadonly;
-  *ph = h;
-  return rc;
-}
-
-/*
-** Close pDbFd's connection to shared-memory.  Delete the underlying
-** *-shm file if deleteFlag is true.
-*/
-static int winCloseSharedMemory(winFile *pDbFd, int deleteFlag){
-  winShm *p;            /* The connection to be closed */
-  winShm **pp;          /* Iterator for pShmNode->pWinShmList */
-  winShmNode *pShmNode; /* The underlying shared-memory file */
-
-  p = pDbFd->pShm;
-  if( p==0 ) return SQLITE_OK;
-  if( p->hShm!=INVALID_HANDLE_VALUE ){
-    osCloseHandle(p->hShm);
-  }
-
-  winShmEnterMutex();
-  pShmNode = p->pShmNode;
-
-  /* Remove this connection from the winShmNode.pWinShmList list */
-  sqlite3_mutex_enter(pShmNode->mutex);
-  for(pp=&pShmNode->pWinShmList; *pp!=p; pp=&(*pp)->pWinShmNext){}
-  *pp = p->pWinShmNext;
-  sqlite3_mutex_leave(pShmNode->mutex);
-
-  winShmPurge(pDbFd->pVfs, deleteFlag);
-  winShmLeaveMutex();
-
-  /* Free the connection p */
-  sqlite3_free(p);
-  pDbFd->pShm = 0;
-  return SQLITE_OK;
-}
-
-/*
-** testfixture builds may set this global variable to true via a
-** Tcl interface. This forces the VFS to use the locking normally
-** only used for UNC paths for all files.
-*/
-#ifdef SQLITE_TEST
-SQLITE_API int sqlite3_win_test_unc_locking = 0;
-#else
-# define sqlite3_win_test_unc_locking 0
-#endif
-
-/*
-** Return true if the string passed as the only argument is likely
-** to be a UNC path. In other words, if it starts with "\\".
-*/
-static int winIsUNCPath(const char *zFile){
-  if( zFile[0]=='\\' && zFile[1]=='\\' ){
-    return 1;
-  }
-  return sqlite3_win_test_unc_locking;
-}
-
-/*
-** Open the shared-memory area associated with database file pDbFd.
-*/
-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) + (i64)nName + 17 );
-  if( pNew==0 ){
-    sqlite3_free(p);
-    return SQLITE_IOERR_NOMEM_BKPT;
-  }
-  pNew->zFilename = (char*)&pNew[1];
-  pNew->hSharedShm = INVALID_HANDLE_VALUE;
-  pNew->isUnlocked = 1;
-  pNew->bUseSharedLockHandle = winIsUNCPath(pDbFd->zPath);
-  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, then 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==0 ){
-    pShmNode = pNew;
-
-    /* Allocate a mutex for this winShmNode object, if one is required. */
-    if( sqlite3GlobalConfig.bCoreMutex ){
-      pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
-      if( pShmNode->mutex==0 ) rc = SQLITE_IOERR_NOMEM_BKPT;
-    }
-
-    /* Open a file-handle to use for mappings, and for the DMS lock. */
-    if( rc==SQLITE_OK ){
-      HANDLE h = INVALID_HANDLE_VALUE;
-      pShmNode->isReadonly = sqlite3_uri_boolean(pDbFd->zPath,"readonly_shm",0);
-      rc = winHandleOpen(pNew->zFilename, &pShmNode->isReadonly, &h);
-      pShmNode->hSharedShm = h;
-    }
-
-    /* If successful, link the new winShmNode into the global list. If an
-    ** error occurred, free the object. */
-    if( rc==SQLITE_OK ){
-      pShmNode->pNext = winShmNodeList;
-      winShmNodeList = pShmNode;
-      pNew = 0;
-    }else{
-      sqlite3_mutex_free(pShmNode->mutex);
-      if( pShmNode->hSharedShm!=INVALID_HANDLE_VALUE ){
-        osCloseHandle(pShmNode->hSharedShm);
-      }
-    }
-  }
-
-  /* If no error has occurred, link the winShm object to the winShmNode and
-  ** the winShm to pDbFd.  */
-  if( rc==SQLITE_OK ){
-    sqlite3_mutex_enter(pShmNode->mutex);
-    p->pShmNode = pShmNode;
-    p->pWinShmNext = pShmNode->pWinShmList;
-    pShmNode->pWinShmList = p;
-#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
-    p->id = pShmNode->nextShmId++;
-#endif
-    pDbFd->pShm = p;
-    sqlite3_mutex_leave(pShmNode->mutex);
-  }else if( p ){
-    sqlite3_free(p);
-  }
-
-  assert( rc!=SQLITE_OK || pShmNode->isUnlocked==0 || pShmNode->nRegion==0 );
-  winShmLeaveMutex();
-  sqlite3_free(pNew);
-
-  /* Open a file-handle on the *-shm file for this connection. This file-handle
-  ** is only used for locking. The mapping of the *-shm file is created using
-  ** the shared file handle in winShmNode.hSharedShm.  */
-  if( rc==SQLITE_OK && pShmNode->bUseSharedLockHandle==0 ){
-    p->bReadonly = sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0);
-    rc = winHandleOpen(pShmNode->zFilename, &p->bReadonly, &p->hShm);
-    if( rc!=SQLITE_OK ){
-      assert( p->hShm==INVALID_HANDLE_VALUE );
-      winCloseSharedMemory(pDbFd, 0);
-    }
-  }
-
-  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 */
-){
-  return winCloseSharedMemory((winFile*)fd, deleteFlag);
-}
-
-/*
-** 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 */
-  winShmNode *pShmNode;
-  int rc = SQLITE_OK;                   /* Result code */
-  u16 mask = (u16)((1U<<(ofst+n)) - (1U<<ofst)); /* Mask of locks to [un]take */
-
-  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 );
-
-  /* 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. Recovery lock (ofst==2).
-  **   2. Checkpointer lock (ofst==1).
-  **   3. Write lock (ofst==0).
-  **   4. Read locks (ofst>=3 && ofst<SQLITE_SHM_NLOCK).
-  **
-  ** In other words, if this is a blocking lock, none of the locks that
-  ** occur later in the above list than the lock being obtained may be
-  ** held.
-  */
-#if defined(SQLITE_ENABLE_SETLK_TIMEOUT) && defined(SQLITE_DEBUG)
-  {
-    u16 lockMask = (p->exclMask|p->sharedMask);
-    assert( (flags & SQLITE_SHM_UNLOCK) || pDbFd->iBusyTimeout==0 || (
-          (ofst!=2 || lockMask==0)
-       && (ofst!=1 || lockMask==0 || lockMask==2)
-       && (ofst!=0 || lockMask<3)
-       && (ofst<3  || lockMask<(1<<ofst))
-    ));
-  }
-#endif
-
-  /* Check if there is any work to do. There are three cases:
-  **
-  **    a) An unlock operation where there are locks to unlock,
-  **    b) An shared lock where the requested lock is not already held
-  **    c) An exclusive lock where the requested lock is not already held
-  **
-  ** The SQLite core never requests an exclusive lock that it already holds.
-  ** This is assert()ed immediately below.  */
-  assert( flags!=(SQLITE_SHM_EXCLUSIVE|SQLITE_SHM_LOCK)
-       || 0==(p->exclMask & mask)
-  );
-  if( ((flags & SQLITE_SHM_UNLOCK) && ((p->exclMask|p->sharedMask) & mask))
-   || (flags==(SQLITE_SHM_SHARED|SQLITE_SHM_LOCK) && 0==(p->sharedMask & mask))
-   || (flags==(SQLITE_SHM_EXCLUSIVE|SQLITE_SHM_LOCK))
-  ){
-    HANDLE h = p->hShm;
-
-    if( flags & SQLITE_SHM_UNLOCK ){
-      /* Case (a) - unlock.  */
-
-      assert( (p->exclMask & p->sharedMask)==0 );
-      assert( !(flags & SQLITE_SHM_EXCLUSIVE) || (p->exclMask & mask)==mask );
-      assert( !(flags & SQLITE_SHM_SHARED) || (p->sharedMask & mask)==mask );
-
-      assert( !(flags & SQLITE_SHM_SHARED) || n==1 );
-      if( pShmNode->bUseSharedLockHandle ){
-        h = pShmNode->hSharedShm;
-        if( flags & SQLITE_SHM_SHARED ){
-          winShm *pShm;
-          sqlite3_mutex_enter(pShmNode->mutex);
-          for(pShm=pShmNode->pWinShmList; pShm; pShm=pShm->pWinShmNext){
-            if( pShm!=p && (pShm->sharedMask & mask) ){
-              /* Another connection within this process is also holding this
-              ** SHARED lock. So do not actually release the OS lock.  */
-              h = INVALID_HANDLE_VALUE;
-              break;
-            }
-          }
-          sqlite3_mutex_leave(pShmNode->mutex);
-        }
-      }
-
-      if( h!=INVALID_HANDLE_VALUE ){
-        rc = winHandleUnlock(h, ofst+WIN_SHM_BASE, n);
-      }
-
-      /* If successful, also clear the bits in sharedMask/exclMask */
-      if( rc==SQLITE_OK ){
-        p->exclMask = (p->exclMask & ~mask);
-        p->sharedMask = (p->sharedMask & ~mask);
-      }
-    }else{
-      int bExcl = ((flags & SQLITE_SHM_EXCLUSIVE) ? 1 : 0);
-      DWORD nMs = winFileBusyTimeout(pDbFd);
-
-      if( pShmNode->bUseSharedLockHandle ){
-        winShm *pShm;
-        h = pShmNode->hSharedShm;
-        sqlite3_mutex_enter(pShmNode->mutex);
-        for(pShm=pShmNode->pWinShmList; pShm; pShm=pShm->pWinShmNext){
-          if( bExcl ){
-            if( (pShm->sharedMask|pShm->exclMask) & mask ){
-              rc = SQLITE_BUSY;
-              h = INVALID_HANDLE_VALUE;
-            }
-          }else{
-            if( pShm->sharedMask & mask ){
-              h = INVALID_HANDLE_VALUE;
-            }else if( pShm->exclMask & mask ){
-              rc = SQLITE_BUSY;
-              h = INVALID_HANDLE_VALUE;
-            }
-          }
-        }
-        sqlite3_mutex_leave(pShmNode->mutex);
-      }
-
-      if( h!=INVALID_HANDLE_VALUE ){
-        rc = winHandleLockTimeout(h, ofst+WIN_SHM_BASE, n, bExcl, nMs);
-      }
-      if( rc==SQLITE_OK ){
-        if( bExcl ){
-          p->exclMask = (p->exclMask | mask);
-        }else{
-          p->sharedMask = (p->sharedMask | mask);
-        }
-      }
-    }
-  }
-
-  OSTRACE((
-      "SHM-LOCK(%d,%d,%d) pid=%lu, id=%d, sharedMask=%03x, exclMask=%03x,"
-      " rc=%s\n",
-      ofst, n, flags,
-      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 ){
-    /* Take the DMS lock. */
-    assert( pShmNode->nRegion==0 );
-    rc = winLockSharedMemory(pShmNode, winFileBusyTimeout(pDbFd));
-    if( rc!=SQLITE_OK ) goto shmpage_out;
-  }
-
-  assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
-  if( pShmNode->nRegion<=iRegion ){
-    HANDLE hShared = pShmNode->hSharedShm;
-    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 = winHandleSize(hShared, &sz);
-    if( rc!=SQLITE_OK ){
-      rc = winLogError(rc, osGetLastError(), "winShmMap1", pDbFd->zPath);
-      goto shmpage_out;
-    }
-
-    if( sz<nByte ){
-      /* The requested memory region does not exist. If isWrite is set to
-      ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
-      **
-      ** Alternatively, if isWrite is non-zero, use ftruncate() to allocate
-      ** the requested memory region.  */
-      if( !isWrite ) goto shmpage_out;
-      rc = winHandleTruncate(hShared, nByte);
-      if( rc!=SQLITE_OK ){
-        rc = winLogError(rc, 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 defined(SQLITE_WIN32_HAS_WIDE)
-      hMap = osCreateFileMappingW(hShared, NULL, protect, 0, nByte, NULL);
-#elif defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_CREATEFILEMAPPINGA
-      hMap = osCreateFileMappingA(hShared, 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;
-        pMap = osMapViewOfFile(hMap, flags,
-            0, iOffset - iOffsetShift, szRegion + iOffsetShift
-        );
-        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 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 );
-    pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap);
-    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 ){
-    /* Ensure that there is always at least a 256 byte buffer of addressable
-    ** memory following the returned page. If the database is corrupt,
-    ** SQLite may overread the page slightly (in practice only a few bytes,
-    ** but 256 is safe, round, number).  */
-    const int nEofBuffer = 256;
-    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+nEofBuffer) ){
-      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.
-*/
-
-/*
-** 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+1<nBuf ){
-        if( !osGetenv ){
-          zBuf[nLen] = winGetDirSep();
-        }else if( winIsDriveLetterAndColon(zBuf) && winIsDirSep(zBuf[2]) ){
-          zBuf[nLen] = '\\';
-          zBuf[2]='\\';
-        }else{
-          zBuf[nLen] = '/';
-        }
-        zBuf[nLen+1] = '\0';
-        return 1;
-      }
-    }
-  }
-  return 0;
-}
-
-/*
-** If sqlite3_temp_directory is defined, take the mutex and return true.
-**
-** If sqlite3_temp_directory is NULL (undefined), omit the mutex and
-** return false.
-*/
-static int winTempDirDefined(void){
-  sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
-  if( sqlite3_temp_directory!=0 ) return 1;
-  sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
-  return 0;
-}
-
-/*
-** Create a temporary file name and store the resulting pointer into pzBuf.
-** The pointer returned in pzBuf must be freed via sqlite3_free().
-*/
-static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){
-  static const char zChars[] =
-    "abcdefghijklmnopqrstuvwxyz"
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    "0123456789";
-  size_t i, j;
-  DWORD pid;
-  int nPre = sqlite3Strlen30(SQLITE_TEMP_FILE_PREFIX);
-  i64 nMax, nBuf, nDir, nLen;
-  char *zBuf;
-
-  /* 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.
-  */
-  SimulateIOError( return SQLITE_IOERR );
-
-  /* Allocate a temporary buffer to store the fully qualified file
-  ** name for the temporary file.  If this fails, we cannot continue.
-  */
-  nMax = pVfs->mxPathname;
-  nBuf = 2 + (i64)nMax;
-  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 if( osGetenv!=NULL ){
-    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] = osGetenv("SQLITE_TMPDIR");
-    if( !azDirs[1] ) azDirs[1] = osGetenv("TMPDIR");
-    if( !azDirs[2] ) azDirs[2] = osGetenv("TMP");
-    if( !azDirs[3] ) azDirs[3] = osGetenv("TEMP");
-    if( !azDirs[4] ) azDirs[4] = osGetenv("USERPROFILE");
-    for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); zDir=azDirs[i++]){
-      void *zConverted;
-      if( zDir==0 ) continue;
-      /* If the path starts with a drive letter followed by the colon
-      ** character, assume it is already a native Win32 path; otherwise,
-      ** it must be converted to a native Win32 path via the Cygwin API
-      ** prior to using it.
-      */
-      {
-        zConverted = winConvertFromUtf8Filename(zDir);
-        if( !zConverted ){
-          sqlite3_free(zBuf);
-          OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
-          return SQLITE_IOERR_NOMEM_BKPT;
-        }
-        if( winIsDir(zConverted) ){
-          sqlite3_snprintf(nMax, zBuf, "%s", zDir);
-          sqlite3_free(zConverted);
-          break;
-        }
-        sqlite3_free(zConverted);
-      }
-    }
-  }
-#endif
-
-  else if( osIsNT() ){
-    char *zMulti;
-    LPWSTR zWidePath = sqlite3MallocZero( nMax*sizeof(WCHAR) );
-    if( !zWidePath ){
-      sqlite3_free(zBuf);
-      OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
-      return SQLITE_IOERR_NOMEM_BKPT;
-    }
-    if( osGetTempPathW(nMax, zWidePath)==0 ){
-      sqlite3_free(zWidePath);
-      sqlite3_free(zBuf);
-      OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_GETTEMPPATH\n"));
-      return winLogError(SQLITE_IOERR_GETTEMPPATH, osGetLastError(),
-                         "winGetTempname2", 0);
-    }
-    zMulti = winUnicodeToUtf8(zWidePath);
-    if( zMulti ){
-      sqlite3_snprintf(nMax, zBuf, "%s", zMulti);
-      sqlite3_free(zMulti);
-      sqlite3_free(zWidePath);
-    }else{
-      sqlite3_free(zWidePath);
-      sqlite3_free(zBuf);
-      OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
-      return SQLITE_IOERR_NOMEM_BKPT;
-    }
-  }
-#ifdef SQLITE_WIN32_HAS_ANSI
-  else{
-    char *zUtf8;
-    char *zMbcsPath = sqlite3MallocZero( nMax );
-    if( !zMbcsPath ){
-      sqlite3_free(zBuf);
-      OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
-      return SQLITE_IOERR_NOMEM_BKPT;
-    }
-    if( osGetTempPathA(nMax, zMbcsPath)==0 ){
-      sqlite3_free(zBuf);
-      OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_GETTEMPPATH\n"));
-      return winLogError(SQLITE_IOERR_GETTEMPPATH, osGetLastError(),
-                         "winGetTempname3", 0);
-    }
-    zUtf8 = winMbcsToUtf8(zMbcsPath, osAreFileApisANSI());
-    if( zUtf8 ){
-      sqlite3_snprintf(nMax, zBuf, "%s", zUtf8);
-      sqlite3_free(zUtf8);
-    }else{
-      sqlite3_free(zBuf);
-      OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
-      return SQLITE_IOERR_NOMEM_BKPT;
-    }
-  }
-#endif /* SQLITE_WIN32_HAS_ANSI */
-
-  /*
-  ** Check to make sure the temporary directory ends with an appropriate
-  ** separator.  If it does not and there is not enough space left to add
-  ** one, fail.
-  */
-  if( !winMakeEndInDirSep(nDir+1, zBuf) ){
-    sqlite3_free(zBuf);
-    OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n"));
-    return winLogError(SQLITE_ERROR, 0, "winGetTempname4", 0);
-  }
-
-  /*
-  ** Check that the output buffer is large enough for the temporary file
-  ** name in the following format:
-  **
-  **   "<temporary_directory>/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]);
-  pid = osGetCurrentProcessId();
-  for(i=0; i<15; i++, j++){
-    zBuf[j] += pid & 0xff;
-    pid >>= 8;
-    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 && defined(SQLITE_WIN32_HAS_ANSI)
-  }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 */
-);
-
-/*
-** The Windows version of xAccess() accepts an extra bit in the flags
-** parameter that prevents an anti-virus retry loop.
-*/
-#define NORETRY 0x4000
-
-/*
-** 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;
-  int isRO = 0;              /* file is known to be accessible readonly */
-
-  /* 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&0x0FFF00;  /* 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 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() ){
-    do{
-      h = osCreateFileW((LPCWSTR)zConverted,
-                        dwDesiredAccess,
-                        dwShareMode, NULL,
-                        dwCreationDisposition,
-                        dwFlagsAndAttributes,
-                        NULL);
-      if( h!=INVALID_HANDLE_VALUE ) break;
-      if( isReadWrite ){
-        int rc2;
-        sqlite3BeginBenignMalloc();
-        rc2 = winAccess(pVfs, zUtf8Name, SQLITE_ACCESS_READ|NORETRY, &isRO);
-        sqlite3EndBenignMalloc();
-        if( rc2==SQLITE_OK && isRO ) break;
-      }
-    }while( winRetryIoerr(&cnt, &lastErrno) );
-  }
-#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;
-        sqlite3BeginBenignMalloc();
-        rc2 = winAccess(pVfs, zUtf8Name, SQLITE_ACCESS_READ|NORETRY, &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 && isRO && !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 {
-      attr = osGetFileAttributesW(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 ( 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;
-  int noRetry = 0;           /* Do not use winRetryIoerr() */
-  UNUSED_PARAMETER(pVfs);
-
-  if( (flags & NORETRY)!=0 ){
-    noRetry = 1;
-    flags &= ~NORETRY;
-  }
-
-  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))
-       && !noRetry
-       && winRetryIoerr(&cnt, &lastErrno)
-    ){ /* Loop until true */}
-    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{
-      if( noRetry ) lastErrno = osGetLastError();
-      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]==':' );
-}
-
-#ifdef _WIN32
-/*
-** 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;
-}
-#endif /* _WIN32 */
-
-#ifdef __CYGWIN__
-/*
-** Simplify a filename into its canonical form
-** by making the following changes:
-**
-**  * convert any '/' to '\' (win32) or reverse (Cygwin)
-**  * removing any trailing and duplicate / (except for UNC paths)
-**  * convert /./ into just /
-**
-** Changes are made in-place.  Return the new name length.
-**
-** The original filename is in z[0..]. If the path is shortened,
-** no-longer used bytes will be written by '\0'.
-*/
-static void winSimplifyName(char *z){
-  int i, j;
-  for(i=j=0; z[i]; ++i){
-    if( winIsDirSep(z[i]) ){
-#if !defined(SQLITE_TEST)
-      /* Some test-cases assume that "./foo" and "foo" are different */
-      if( z[i+1]=='.' && winIsDirSep(z[i+2]) ){
-        ++i;
-        continue;
-      }
-#endif
-      if( !z[i+1] || (winIsDirSep(z[i+1]) && (i!=0)) ){
-        continue;
-      }
-      z[j++] = osGetenv?'/':'\\';
-    }else{
-      z[j++] = z[i];
-    }
-  }
-  while(j<i) z[j++] = '\0';
-}
-
-#define SQLITE_MAX_SYMLINKS 100
-
-static int mkFullPathname(
-  const char *zPath,              /* Input path */
-  char *zOut,                     /* Output buffer */
-  int nOut                        /* Allocated size of buffer zOut */
-){
-  int nPath = sqlite3Strlen30(zPath);
-  int iOff = 0;
-  if( zPath[0]!='/' ){
-    if( osGetcwd(zOut, nOut-2)==0 ){
-      return winLogError(SQLITE_CANTOPEN_BKPT, (DWORD)osErrno, "getcwd", zPath);
-    }
-    iOff = sqlite3Strlen30(zOut);
-    zOut[iOff++] = '/';
-  }
-  if( (iOff+nPath+1)>nOut ){
-    /* SQLite assumes that xFullPathname() nul-terminates the output buffer
-    ** even if it returns an error.  */
-    zOut[iOff] = '\0';
-    return SQLITE_CANTOPEN_BKPT;
-  }
-  sqlite3_snprintf(nOut-iOff, &zOut[iOff], "%s", zPath);
-  return SQLITE_OK;
-}
-#endif /* __CYGWIN__ */
-
-/*
-** 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
-  int 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++;
-  }
-
-  SimulateIOError( return SQLITE_ERROR );
-
-#ifdef __CYGWIN__
-  if( osGetcwd ){
-    zFull[nFull-1] = '\0';
-    if( !winIsDriveLetterAndColon(zRelative) || !winIsDirSep(zRelative[2]) ){
-      int rc = SQLITE_OK;
-      int nLink = 1;                /* Number of symbolic links followed so far */
-      const char *zIn = zRelative;      /* Input path for each iteration of loop */
-      char *zDel = 0;
-      struct stat buf;
-
-      UNUSED_PARAMETER(pVfs);
-
-      do {
-        /* Call lstat() on path zIn. Set bLink to true if the path is a symbolic
-        ** link, or false otherwise.  */
-        int bLink = 0;
-        if( osLstat && osReadlink ) {
-          if( osLstat(zIn, &buf)!=0 ){
-            int myErrno = osErrno;
-            if( myErrno!=ENOENT ){
-              rc = winLogError(SQLITE_CANTOPEN_BKPT, (DWORD)myErrno, "lstat", zIn);
-            }
-          }else{
-            bLink = ((buf.st_mode & 0170000) == 0120000);
-          }
-
-          if( bLink ){
-            if( zDel==0 ){
-              zDel = sqlite3MallocZero(nFull);
-              if( zDel==0 ) rc = SQLITE_NOMEM;
-            }else if( ++nLink>SQLITE_MAX_SYMLINKS ){
-              rc = SQLITE_CANTOPEN_BKPT;
-            }
-
-            if( rc==SQLITE_OK ){
-              nByte = osReadlink(zIn, zDel, nFull-1);
-              if( nByte ==(DWORD)-1 ){
-                rc = winLogError(SQLITE_CANTOPEN_BKPT, (DWORD)osErrno, "readlink", zIn);
-              }else{
-                if( zDel[0]!='/' ){
-                  int n;
-                  for(n = sqlite3Strlen30(zIn); n>0 && zIn[n-1]!='/'; n--);
-                  if( nByte+n+1>nFull ){
-                    rc = SQLITE_CANTOPEN_BKPT;
-                  }else{
-                    memmove(&zDel[n], zDel, nByte+1);
-                    memcpy(zDel, zIn, n);
-                    nByte += n;
-                  }
-                }
-                zDel[nByte] = '\0';
-              }
-            }
-
-            zIn = zDel;
-          }
-        }
-
-        assert( rc!=SQLITE_OK || zIn!=zFull || zIn[0]=='/' );
-        if( rc==SQLITE_OK && zIn!=zFull ){
-          rc = mkFullPathname(zIn, zFull, nFull);
-        }
-        if( bLink==0 ) break;
-        zIn = zFull;
-      }while( rc==SQLITE_OK );
-
-      sqlite3_free(zDel);
-      winSimplifyName(zFull);
-      return rc;
-    }
-  }
-#endif /* __CYGWIN__ */
-
-#if SQLITE_OS_WINCE && defined(_WIN32)
-  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
-#if defined(_WIN32)
-  /* 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;
-  }
-#endif
-  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);
-    }
-    zTemp = sqlite3MallocZero( nByte*sizeof(zTemp[0]) + 3*sizeof(zTemp[0]) );
-    if( zTemp==0 ){
-      sqlite3_free(zConverted);
-      return SQLITE_IOERR_NOMEM_BKPT;
-    }
-    nByte = osGetFullPathNameA((char*)zConverted, nByte+3, 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 ){
-#ifdef __CYGWIN__
-    if( memcmp(zOut, "\\\\?\\", 4) ){
-      sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut);
-    }else if( memcmp(zOut+4, "UNC\\", 4) ){
-      sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut+4);
-    }else{
-      char *p = zOut+6;
-      *p = '\\';
-      if( osGetcwd ){
-        /* On Cygwin, UNC paths use forward slashes */
-        while( *p ){
-          if( *p=='\\' ) *p = '/';
-          ++p;
-        }
-      }
-      sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut+6);
-    }
-#else
-    sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut);
-#endif /* __CYGWIN__ */
-    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;
-  void *zConverted = winConvertFromUtf8Filename(zFilename);
-  UNUSED_PARAMETER(pVfs);
-  if( zConverted==0 ){
-    OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0));
-    return 0;
-  }
-  if( osIsNT() ){
-    h = osLoadLibraryW((LPCWSTR)zConverted);
-  }
-#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; j<sz; j++){
-    p->a[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));
-  }
-  {
-    DWORD cnt = osGetTickCount();
-    xorMemory(&e, (unsigned char*)&cnt, sizeof(DWORD));
-  }
-  {
-    LARGE_INTEGER i;
-    osQueryPerformanceCounter(&i);
-    xorMemory(&e, (unsigned char*)&i, sizeof(LARGE_INTEGER));
-  }
-#if !SQLITE_OS_WINCE && 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_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)==81 );
-  assert( strcmp(aSyscall[0].zName,"AreFileApisANSI")==0 );
-  assert( strcmp(aSyscall[20].zName,"GetFileAttributesA")==0 );
-  assert( strcmp(aSyscall[40].zName,"HeapReAlloc")==0 );
-  assert( strcmp(aSyscall[60].zName,"WideCharToMultiByte")==0 );
-  assert( strcmp(aSyscall[80].zName,"cygwin_conv_path")==0 );
-
-  /* get memory map allocation granularity */
-  memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));
-  osGetSystemInfo(&winSysInfo);
-  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){
-#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(i<memdb_g.nMemStore); i++){
-      if( memdb_g.apMemStore[i]==p ){
-        memdbEnter(p);
-        if( p->nRef==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( iOfst<p->sz ) 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( iLimit<p->sz ){
-      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; i<memdb_g.nMemStore; i++){
-      if( strcmp(memdb_g.apMemStore[i]->zFName,zName)==0 ){
-        p = memdb_g.apMemStore[i];
-        break;
-      }
-    }
-    if( p==0 ){
-      MemStore **apNew;
-      p = sqlite3Malloc( sizeof(*p) + (i64)szName + 3 );
-      if( p==0 ){
-        sqlite3_mutex_leave(pVfsMutex);
-        return SQLITE_NOMEM;
-      }
-      apNew = sqlite3Realloc(memdb_g.apMemStore,
-                             sizeof(apNew[0])*(1+(i64)memdb_g.nMemStore) );
-      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( sz==0 ){
-      sqlite3_reset(pStmt);
-      sqlite3_exec(db, "BEGIN IMMEDIATE; COMMIT;", 0, 0, 0);
-      rc = sqlite3_step(pStmt);
-      if( rc==SQLITE_ROW ){
-        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;
-  sqlite3_step(pStmt);
-  db->init.reopenMemdb = 0;
-  rc = sqlite3_finalize(pStmt);
-  if( rc!=SQLITE_OK ){
-    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->szMax<sqlite3GlobalConfig.mxMemdbSize ){
-      pStore->szMax = sqlite3GlobalConfig.mxMemdbSize;
-    }
-    pStore->mFlags = mFlags;
-    rc = SQLITE_OK;
-  }
-
-end_deserialize:
-  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( sz<sizeof(MemFile) ) sz = sizeof(MemFile); /*NO_TEST*/
-  memdb_vfs.szOsFile = sz;
-  return sqlite3_vfs_register(&memdb_vfs, 0);
-}
-#endif /* SQLITE_OMIT_DESERIALIZE */
-
-/************** End of memdb.c ***********************************************/
-/************** Begin file bitvec.c ******************************************/
-/*
-** 2008 February 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 implements an object that represents a fixed-length
-** bitmap.  Bits are numbered starting with 1.
-**
-** A bitmap is used to record which pages of a database file have been
-** journalled during a transaction, or which pages have the "dont-write"
-** property.  Usually only a few pages are meet either condition.
-** So the bitmap is usually sparse and has low cardinality.
-** But sometimes (for example when during a DROP of a large table) most
-** or all of the pages in a database can get journalled.  In those cases,
-** the bitmap becomes dense with high cardinality.  The algorithm needs
-** to handle both cases well.
-**
-** The size of the bitmap is fixed when the object is created.
-**
-** All bits are clear when the bitmap is created.  Individual bits
-** may be set or cleared one at a time.
-**
-** Test operations are about 100 times more common that set operations.
-** Clear operations are exceedingly rare.  There are usually between
-** 5 and 500 set operations per Bitvec object, though the number of sets can
-** sometimes grow into tens of thousands or larger.  The size of the
-** Bitvec object is the number of pages in the database file at the
-** start of a transaction, and is thus usually less than a few thousand,
-** but can be as large as 2 billion for a really big database.
-*/
-/* #include "sqliteInt.h" */
-
-/* Size of the Bitvec structure in bytes. */
-#define BITVEC_SZ        512
-
-/* Round the union size down to the nearest pointer boundary, since that's how
-** it will be aligned within the Bitvec struct. */
-#define BITVEC_USIZE \
-    (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))
-
-/* Type of the array "element" for the bitmap representation.
-** Should be a power of 2, and ideally, evenly divide into BITVEC_USIZE.
-** Setting this to the "natural word" size of your CPU may improve
-** performance. */
-#define BITVEC_TELEM     u8
-/* Size, in bits, of the bitmap element. */
-#define BITVEC_SZELEM    8
-/* Number of elements in a bitmap array. */
-#define BITVEC_NELEM     (BITVEC_USIZE/sizeof(BITVEC_TELEM))
-/* Number of bits in the bitmap array. */
-#define BITVEC_NBIT      (BITVEC_NELEM*BITVEC_SZELEM)
-
-/* Number of u32 values in hash table. */
-#define BITVEC_NINT      (BITVEC_USIZE/sizeof(u32))
-/* Maximum number of entries in hash table before
-** sub-dividing and re-hashing. */
-#define BITVEC_MXHASH    (BITVEC_NINT/2)
-/* Hashing function for the aHash representation.
-** Empirical testing showed that the *37 multiplier
-** (an arbitrary prime)in the hash function provided
-** no fewer collisions than the no-op *1. */
-#define BITVEC_HASH(X)   (((X)*1)%BITVEC_NINT)
-
-#define BITVEC_NPTR      ((u32)(BITVEC_USIZE/sizeof(Bitvec *)))
-
-
-/*
-** A bitmap is an instance of the following structure.
-**
-** This bitmap records the existence of zero or more bits
-** with values between 1 and iSize, inclusive.
-**
-** There are three possible representations of the bitmap.
-** If iSize<=BITVEC_NBIT, then Bitvec.u.aBitmap[] is a straight
-** bitmap.  The least significant bit is bit 1.
-**
-** If iSize>BITVEC_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 */
-  /* worrying 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;
-      if( (p->iSize%BITVEC_NPTR)!=0 ) p->iDivisor++;
-      if( p->iDivisor<BITVEC_NBIT ) p->iDivisor = BITVEC_NBIT;
-      rc = sqlite3BitvecSet(p, i);
-      for(j=0; j<BITVEC_NINT; j++){
-        if( aiValues[j] ) rc |= sqlite3BitvecSet(p, aiValues[j]);
-      }
-      sqlite3StackFree(0, aiValues);
-      return rc;
-    }
-  }
-bitvec_set_end:
-  p->nSet++;
-  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] &= ~(BITVEC_TELEM)(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; j<BITVEC_NINT; j++){
-      if( aiValues[j] && aiValues[j]!=(i+1) ){
-        u32 h = BITVEC_HASH(aiValues[j]-1);
-        p->nSet++;
-        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; i<BITVEC_NPTR; i++){
-      sqlite3BitvecDestroy(p->u.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;
-}
-
-#ifdef SQLITE_DEBUG
-/*
-** Show the content of a Bitvec option and its children.  Indent
-** everything by n spaces.  Add x to each bitvec value.
-**
-** From a debugger such as gdb, one can type:
-**
-**    call sqlite3ShowBitvec(p)
-**
-** For some Bitvec p and see a recursive view of the Bitvec's content.
-*/
-static void showBitvec(Bitvec *p, int n, unsigned x){
-  int i;
-  if( p==0 ){
-    printf("NULL\n");
-    return;
-  }
-  printf("Bitvec 0x%p iSize=%u", p, p->iSize);
-  if( p->iSize<=BITVEC_NBIT ){
-    printf(" bitmap\n");
-    printf("%*s   bits:", n, "");
-    for(i=1; i<=BITVEC_NBIT; i++){
-      if( sqlite3BitvecTest(p,i) ) printf(" %u", x+(unsigned)i);
-    }
-    printf("\n");
-  }else if( p->iDivisor==0 ){
-    printf(" hash with %u entries\n", p->nSet);
-    printf("%*s   bits:", n, "");
-    for(i=0; i<BITVEC_NINT; i++){
-      if( p->u.aHash[i] ) printf(" %u", x+(unsigned)p->u.aHash[i]);
-    }
-    printf("\n");
-  }else{
-    printf(" sub-bitvec with iDivisor=%u\n", p->iDivisor);
-    for(i=0; i<BITVEC_NPTR; i++){
-      if( p->u.apSub[i]==0 ) continue;
-      printf("%*s   apSub[%d]=", n, "", i);
-      showBitvec(p->u.apSub[i], n+4, i*p->iDivisor);
-    }
-  }
-}
-SQLITE_PRIVATE void sqlite3ShowBitvec(Bitvec *p){
-  showBitvec(p, 0, 0);
-}
-#endif
-
-#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<N.
-** Then the following macros can be used to set, clear, or test
-** individual bits within V.
-*/
-#define SETBIT(V,I)      V[I>>3] |= (1<<(I&7))
-#define CLEARBIT(V,I)    V[I>>3] &= ~(BITVEC_TELEM)(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 opcodes numbered starting with 0.  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
-**    6          Invoice sqlite3ShowBitvec() on the Bitvec object so far
-**    7 X        Show compile-time parameters and the hash of X
-**
-** 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.  Opcodes 6 and greater are
-** state output opcodes.  Opcodes 6 and greater are no-ops unless
-** SQLite has been compiled with SQLITE_DEBUG.
-**
-** 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.
-**
-** sz is the size of the Bitvec.  Or if sz is negative, make the size
-** 2*(unsigned)(-sz) and disabled the linear vector check.
-*/
-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 */
-  if( sz<=0 ){
-    pBitvec = sqlite3BitvecCreate( 2*(unsigned)(-sz) );
-    pV = 0;
-  }else{
-    pBitvec = sqlite3BitvecCreate( sz );
-    pV = sqlite3MallocZero( (7+(i64)sz)/8 + 1 );
-  }
-  pTmpSpace = sqlite3_malloc64(BITVEC_SZ);
-  if( pBitvec==0 || pTmpSpace==0 || (pV==0 && sz>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 ){
-    if( op>=6 ){
-#ifdef SQLITE_DEBUG
-      if( op==6 ){
-        sqlite3ShowBitvec(pBitvec);
-      }else if( op==7 ){
-        printf("BITVEC_SZ     = %d (%d by sizeof)\n",
-               BITVEC_SZ, (int)sizeof(Bitvec));
-        printf("BITVEC_USIZE  = %d\n", (int)BITVEC_USIZE);
-        printf("BITVEC_NELEM  = %d\n", (int)BITVEC_NELEM);
-        printf("BITVEC_NBIT   = %d\n", (int)BITVEC_NBIT);
-        printf("BITVEC_NINT   = %d\n", (int)BITVEC_NINT);
-        printf("BITVEC_MXHASH = %d\n", (int)BITVEC_MXHASH);
-        printf("BITVEC_NPTR   = %d\n", (int)BITVEC_NPTR);
-      }
-#endif
-      pc++;
-      continue;
-    }
-    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 ){
-      if( pV ) SETBIT(pV, (i+1));
-      if( op!=5 ){
-        if( sqlite3BitvecSet(pBitvec, i+1) ) goto bitvec_end;
-      }
-    }else{
-      if( pV ) 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.
-  */
-  if( pV ){
-    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;
-      }
-    }
-  }else{
-    rc = 0;
-  }
-
-  /* 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.
-*/
-#if defined(SQLITE_ENABLE_EXPENSIVE_ASSERT)
-static int pageOnDirtyList(PCache *pCache, PgHdr *pPg){
-  PgHdr *p;
-  for(p=pCache->pDirty; p; p=p->pDirtyNext){
-    if( p==pPg ) return 1;
-  }
-  return 0;
-}
-static int pageNotOnDirtyList(PCache *pCache, PgHdr *pPg){
-  PgHdr *p;
-  for(p=pCache->pDirty; p; p=p->pDirtyNext){
-    if( p==pPg ) return 0;
-  }
-  return 1;
-}
-#else
-# define pageOnDirtyList(A,B)    1
-# define pageNotOnDirtyList(A,B) 1
-#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( pageNotOnDirtyList(pCache, pPg) );/* CLEAN pages not on dirtylist */
-  }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;
-    /* IMPLEMENTATION-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);
-  assert( EIGHT_BYTE_ALIGNMENT( pPgHdr->pExtra ) );
-  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->pgno<pB->pgno ){
-      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 ascending 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(i<N_SORT_BUCKET-1); i++){
-      if( a[i]==0 ){
-        a[i] = p;
-        break;
-      }else{
-        p = pcacheMergeDirtyList(a[i], p);
-        a[i] = 0;
-      }
-    }
-    if( NEVER(i==N_SORT_BUCKET-1) ){
-      /* To get here, there need to be 2^(N_SORT_BUCKET) elements in
-      ** the input list.  But that is impossible.
-      */
-      a[i] = pcacheMergeDirtyList(a[i], p);
-    }
-  }
-  p = a[0];
-  for(i=1; i<N_SORT_BUCKET; i++){
-    if( a[i]==0 ) continue;
-    p = p ? pcacheMergeDirtyList(p, a[i]) : a[i];
-  }
-  return p;
-}
-
-/*
-** Return a list of all dirty pages in the cache, sorted by page number.
-*/
-SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache *pCache){
-  PgHdr *p;
-  for(p=pCache->pDirty; 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( res<p->szSpill ) 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 accommodated.
-**
-** 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 uninitialized 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 */
-  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;
-    AtomicStore(&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 = (u8*)pX + ROUND8(sizeof(*pX));
-      assert( EIGHT_BYTE_ALIGNMENT( pX->page.pExtra ) );
-      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--;
-      AtomicStore(&pcache1.bUnderPressure,pcache1.nFreeSlot<pcache1.nReserve);
-      assert( 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++;
-    AtomicStore(&pcache1.bUnderPressure,pcache1.nFreeSlot<pcache1.nReserve);
-    assert( pcache1.nFreeSlot<=pcache1.nSlot );
-    sqlite3_mutex_leave(pcache1.mutex);
-  }else{
-    assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
-    sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
-#ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
-    {
-      int nFreed = 0;
-      nFreed = sqlite3MallocSize(p);
-      sqlite3_mutex_enter(pcache1.mutex);
-      sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_OVERFLOW, nFreed);
-      sqlite3_mutex_leave(pcache1.mutex);
-    }
-#endif
-    sqlite3_free(p);
-  }
-}
-
-#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
-/*
-** Return the size of a pcache allocation
-*/
-static int pcache1MemSize(void *p){
-  if( p>=pcache1.pStart && p<pcache1.pEnd ){
-    return pcache1.szSlot;
-  }else{
-    int iSize;
-    assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
-    sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
-    iSize = sqlite3MallocSize(p);
-    sqlite3MemdebugSetType(p, MEMTYPE_PCACHE);
-    return iSize;
-  }
-}
-#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
-
-/*
-** Allocate a new page object initially associated with cache pCache.
-*/
-static PgHdr1 *pcache1AllocPage(PCache1 *pCache, int benignMalloc){
-  PgHdr1 *p = 0;
-  void *pPg;
-
-  assert( sqlite3_mutex_held(pCache->pGroup->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 = (u8*)p + ROUND8(sizeof(*p));
-    assert( EIGHT_BYTE_ALIGNMENT( p->page.pExtra ) );
-    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 AtomicLoad(&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;
-  u64 nNew;
-  u32 i;
-
-  assert( sqlite3_mutex_held(p->pGroup->mutex) );
-
-  nNew = 2*(u64)p->nHash;
-  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; i<p->nHash; 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( h<pCache->nHash );
-    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 */
-  i64 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->nRecyclable<nPinned)
-  )){
-    return 0;
-  }
-
-  if( pCache->nPage>=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 || nFree<nReq)
-       &&  (p=pcache1.grp.lru.pLruPrev)!=0
-       &&  p->isAnchor==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 number, 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->v<pB->v ) 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; i<sizeof(aBucket)/sizeof(aBucket[0]); i++){
-    if( aBucket[i]==0 ) continue;
-    pIn = pIn ? rowSetEntryMerge(pIn, aBucket[i]) : aBucket[i];
-  }
-  return pIn;
-}
-
-
-/*
-** The input, pIn, is a binary tree (or subtree) of RowSetEntry objects.
-** Convert this tree into a linked list connected by the pRight pointers
-** and return pointers to the first and last elements of the new list.
-*/
-static void rowSetTreeToList(
-  struct RowSetEntry *pIn,         /* Root of the input tree */
-  struct RowSetEntry **ppFirst,    /* Write head of the output list here */
-  struct RowSetEntry **ppLast      /* Write tail of the output list here */
-){
-  assert( pIn!=0 );
-  if( pIn->pLeft ){
-    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->v<iRowid ){
-        p = p->pRight;
-      }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
-# undef SQLITE_USE_SEH
-#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
-
-#ifdef SQLITE_USE_SEH
-SQLITE_PRIVATE int sqlite3WalSystemErrno(Wal*);
-#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 performed)
-**    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)
-
-/*
-** 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 */
-  u32 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 */
-  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
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  sqlite3 *dbWal;
-#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
-
-#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:
-**
-**   (1)  the database file is open
-**   (2)  the VFS for the database is able to do unaligned sub-page reads
-**   (3)  there are no dirty pages in the cache, and
-**   (4)  the desired page is not currently in the wal file.
-*/
-SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){
-  assert( pPager!=0 );
-  assert( pPager->fd!=0 );
-  if( pPager->fd->pMethods==0 ) return 0;  /* Case (1) */
-  if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0; /* Failed (3) */
-#ifndef SQLITE_OMIT_WAL
-  if( pPager->pWal ){
-    u32 iRead = 0;
-    (void)sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
-    if( iRead ) return 0;  /* Case (4) */
-  }
-#else
-  UNUSED_PARAMETER(pgno);
-#endif
-  assert( pPager->fd->pMethods->xDeviceCharacteristics!=0 );
-  if( (pPager->fd->pMethods->xDeviceCharacteristics(pPager->fd)
-        & SQLITE_IOCAP_SUBPAGE_READ)==0 ){
-    return 0; /* Case (2) */
-  }
-  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) ){
-    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; i<pPager->nSavepoint; i++){
-    p = &pPager->aSavepoint[i];
-    if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){
-      for(i=i+1; i<pPager->nSavepoint; 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->eLock<eLock || pPager->eLock==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 64-bit hash of the page data for pPage.
-*/
-static u64 pager_datahash(int nByte, unsigned char *pData){
-  u64 hash = 0;
-  int i;
-  for(i=0; i<nByte; i++){
-    hash = (hash*1039) + pData[i];
-  }
-  return hash;
-}
-static u64 pager_pagehash(PgHdr *pPage){
-  return pager_datahash(pPage->pPager->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, u64 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; u<len; u++){
-    cksum -= zSuper[u];
-  }
-  if( cksum ){
-    /* If the checksum doesn't add up, then one or more of the disk sectors
-    ** containing the super-journal filename is corrupted. This means
-    ** definitely roll back, so just return SQLITE_OK and report a (nul)
-    ** super-journal filename.
-    */
-    len = 0;
-  }
-  zSuper[len] = '\0';
-  zSuper[len+1] = '\0';
-
-  return SQLITE_OK;
-}
-
-/*
-** Return the offset of the sector boundary at or immediately
-** following the value in pPager->journalOff, 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)<JOURNAL_HDR_SZ(pPager) );
-  return offset;
-}
-
-/*
-** The journal file must be open when this function is called.
-**
-** This function is a no-op if the journal file has not been written to
-** within the current transaction (i.e. if Pager.journalOff==0).
-**
-** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
-** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
-** zero the 28-byte header at the start of the journal file. In either case,
-** if the pager is not in no-sync mode, sync the journal file immediately
-** after writing or truncating it.
-**
-** If Pager.journalSizeLimit is set to a positive, non-zero value, and
-** following the truncation or zeroing described above the size of the
-** journal file in bytes is larger than this value, then truncate the
-** journal file to Pager.journalSizeLimit bytes. The journal file does
-** not need to be synced following this operation.
-**
-** If an IO error occurs, abandon processing and return the IO error code.
-** Otherwise, return SQLITE_OK.
-*/
-static int zeroJournalHdr(Pager *pPager, int doTruncate){
-  int rc = SQLITE_OK;                               /* Return code */
-  assert( isOpen(pPager->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; ii<pPager->nSavepoint; 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 */
-  if( pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
-    sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
-  }
-#ifdef SQLITE_DEBUG
-  else{
-    /* The Pager.cksumInit variable is usually randomized above to protect
-    ** against there being existing records in the journal file. This is
-    ** dangerous, as following a crash they may be mistaken for records
-    ** written by the current transaction and rolled back into the database
-    ** file, causing corruption. The following assert statements verify
-    ** that this is not required in "journal_mode=memory" mode, as in that
-    ** case the journal file is always 0 bytes in size at this point.
-    ** It is advantageous to avoid the sqlite3_randomness() call if possible
-    ** as it takes the global PRNG mutex.  */
-    i64 sz = 0;
-    sqlite3OsFileSize(pPager->jfd, &sz);
-    assert( sz==0 );
-    assert( pPager->journalOff==journalHdrOffset(pPager) );
-    assert( sqlite3JournalIsInMemory(pPager->jfd) );
-  }
-#endif
-  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&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
-    IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, 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 the super-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 persistent-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; ii<pPager->nSavepoint; 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; ii<pPager->nSavepoint; 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) );
-    if( pPager->eState==PAGER_ERROR ){
-      /* If an IO error occurs in wal.c while attempting to wrap the wal file,
-      ** then the Wal object may be holding a write-lock but no read-lock.
-      ** This call ensures that the write-lock is dropped as well. We cannot
-      ** have sqlite3WalEndReadTransaction() drop the write-lock, as it once
-      ** did, because this would break "BEGIN EXCLUSIVE" handling for
-      ** SQLITE_ENABLE_SETLK_TIMEOUT builds.  */
-      (void)sqlite3WalEndWriteTransaction(pPager->pWal);
-    }
-    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 have 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->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
-    return SQLITE_OK;
-  }
-
-  releaseAllSavepoints(pPager);
-  assert( isOpen(pPager->jfd) || 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);
-}
-
-/* Forward reference */
-static int pager_playback(Pager *pPager, int isHot);
-
-/*
-** 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);
-    }
-  }else if( pPager->eState==PAGER_ERROR
-         && pPager->journalMode==PAGER_JOURNALMODE_MEMORY
-         && isOpen(pPager->jfd)
-  ){
-    /* Special case for a ROLLBACK due to I/O error with an in-memory
-    ** journal:  We have to rollback immediately, before the journal is
-    ** closed, because once it is closed, all content is forgotten. */
-    int errCode = pPager->errCode;
-    u8 eLock = pPager->eLock;
-    pPager->eState = PAGER_OPEN;
-    pPager->errCode = SQLITE_OK;
-    pPager->eLock = EXCLUSIVE_LOCK;
-    pager_playback(pPager, 1);
-    pPager->errCode = errCode;
-    pPager->eLock = eLock;
-  }
-  pager_unlock(pPager);
-}
-
-/*
-** Parameter aData must point to a buffer of pPager->pageSize bytes
-** of data. Compute and return a checksum based on 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;
-}
-
-/*
-** 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 */
-
-  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];
-  }
-
-  /* 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.  */
-    rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
-
-    if( pgno>pPager->dbFileSize ){
-      pPager->dbFileSize = pgno;
-    }
-    if( pPager->pBackup ){
-      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));
-    }
-    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 */
-  i64 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(2 * (i64)pVfs->szOsFile);
-  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 = 1 + (i64)pVfs->mxPathname;
-  assert( nSuperJournal>=0 && nSuperPtr>0 );
-  zFree = sqlite3Malloc(4 + nSuperJournal + nSuperPtr + 2);
-  if( !zFree ){
-    rc = SQLITE_NOMEM_BKPT;
-    goto delsuper_out;
-  }else{
-    assert( nSuperJournal<=0x7fffffff );
-  }
-  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)<nSuperJournal ){
-    int exists;
-    rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
-    if( rc!=SQLITE_OK ){
-      goto delsuper_out;
-    }
-    if( exists ){
-      /* One of the journals pointed to by the super-journal exists.
-      ** Open it and check if it points at the super-journal. If
-      ** so, return without deleting the super-journal file.
-      ** NB:  zJournal is really a MAIN_JOURNAL.  But call it a
-      ** SUPER_JOURNAL here so that the VFS will not send the zJournal
-      ** name into sqlite3_database_file_object().
-      */
-      int c;
-      int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_SUPER_JOURNAL);
-      rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
-      if( rc!=SQLITE_OK ){
-        goto delsuper_out;
-      }
-
-      rc = readSuperJournal(pJournal, zSuperPtr, nSuperPtr);
-      sqlite3OsClose(pJournal);
-      if( rc!=SQLITE_OK ){
-        goto delsuper_out;
-      }
-
-      c = zSuperPtr[0]!=0 && strcmp(zSuperPtr, zSuper)==0;
-      if( c ){
-        /* We have a match. Do not delete the super-journal file. */
-        goto delsuper_out;
-      }
-    }
-    zJournal += (sqlite3Strlen30(zJournal)+1);
-  }
-
-  sqlite3OsClose(pSuper);
-  rc = sqlite3OsDelete(pVfs, zSuper, 0);
-
-delsuper_out:
-  sqlite3_free(zFree);
-  if( pSuper ){
-    sqlite3OsClose(pSuper);
-    assert( !isOpen(pJournal) );
-    sqlite3_free(pSuper);
-  }
-  return rc;
-}
-
-
-/*
-** This function is used to change the actual size of the database
-** file in the file-system. This only happens when committing a transaction,
-** or rolling back a transaction (including rolling back a hot-journal).
-**
-** If the main database file is not open, or the pager is not in either
-** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
-** of the file is changed to nPage pages (nPage*pPager->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, &currentSize);
-    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, 1+(i64)pPager->pVfs->mxPathname);
-  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->mxPgno<mxPg ){
-        pPager->mxPgno = mxPg;
-      }
-    }
-
-    /* Copy original pages out of the journal and back into the
-    ** database file and/or page cache.
-    */
-    for(u=0; u<nRec; u++){
-      if( needPagerReset ){
-        pager_reset(pPager);
-        needPagerReset = 0;
-      }
-      rc = pager_playback_one_page(pPager,&pPager->journalOff,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, 1+(i64)pPager->pVfs->mxPathname);
-    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));
-    }
-  }
-  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 ascending 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 empty, 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->journalOff<iHdrOff ){
-      rc = pager_playback_one_page(pPager, &pPager->journalOff, 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->journalOff<szJ ){
-    u32 ii;            /* Loop counter */
-    u32 nJRec = 0;     /* Number of Journal Records */
-    u32 dummy;
-    rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
-    assert( rc!=SQLITE_DONE );
-
-    /*
-    ** The "pPager->journalHdr+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 && ii<nJRec && pPager->journalOff<szJ; ii++){
-      rc = pager_playback_one_page(pPager, &pPager->journalOff, 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 && ii<pPager->nSubRec; 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 || level==PAGER_SYNCHRONOUS_OFF ){
-    pPager->noSync = 1;
-    pPager->fullSync = 0;
-    pPager->extraSync = 0;
-  }else{
-    pPager->noSync =  0;
-    pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0;
-
-    /* Set Pager.extraSync if "PRAGMA synchronous=EXTRA" is requested, or
-    ** if the file-system supports F2FS style atomic writes. If this flag
-    ** is set, SQLite syncs the directory to disk immediately after deleting
-    ** a journal file in "PRAGMA journal_mode=DELETE" mode.  */
-    if( level==PAGER_SYNCHRONOUS_EXTRA
-#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
-     || (sqlite3OsDeviceCharacteristics(pPager->fd) & SQLITE_IOCAP_BATCH_ATOMIC)
-#endif
-    ){
-      pPager->extraSync = 1;
-    }else{
-      pPager->extraSync = 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;
-    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 <page-size> 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; i<pPg->pPager->nSavepoint; i++){
-      PagerSavepoint *p = &pPager->aSavepoint[i];
-      assert( p->nOrig<pgno || sqlite3BitvecTestNotNull(p->pInSavepoint,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];
-    assert( EIGHT_BYTE_ALIGNMENT( p->pExtra ) );
-    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;
-  }
-#else
-  UNUSED_PARAMETER(db);
-#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);
-  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 <in-memory journal> ){
-**     if( NOT SAFE_APPEND ){
-**       if( <full-sync mode> ) xSync(<journal file>);
-**       <update nRec field>
-**     }
-**     if( NOT SEQUENTIAL ) xSync(<journal file>);
-**   }
-**
-** 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->dbHintSize<pPager->dbSize
-   && (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);
-
-      pData = pList->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;
-      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 */
-  int memJM = 0;           /* Memory journal mode */
-  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, 2*(i64)nPathname);
-    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.
-  */
-  assert( SQLITE_PTRSIZE==sizeof(Pager*) );
-  pPtr = (u8 *)sqlite3MallocZero(
-    ROUND8(sizeof(*pPager)) +            /* Pager structure */
-    ROUND8(pcacheSize) +                 /* PCache object */
-    ROUND8(pVfs->szOsFile) +             /* The main db file */
-    (u64)journalFileSize * 2 +           /* The two journal files */
-    SQLITE_PTRSIZE +                     /* Space to hold a pointer */
-    4 +                                  /* Database prefix */
-    (u64)nPathname + 1 +                 /* database filename */
-    (u64)nUriByte +                      /* query parameters */
-    (u64)nPathname + 8 + 1 +             /* Journal filename */
-#ifndef SQLITE_OMIT_WAL
-    (u64)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, SQLITE_PTRSIZE);  pPtr += SQLITE_PTRSIZE;
-
-  /* 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 );
-    pPager->memVfs = memJM = (fout&SQLITE_OPEN_MEMORY)!=0;
-    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( szPageDflt<pPager->sectorSize ){
-          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 corresponding WAL or Journal name as passed into
-** xOpen.
-*/
-SQLITE_API sqlite3_file *sqlite3_database_file_object(const char *zName){
-  Pager *pPager;
-  const char *p;
-  while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
-    zName--;
-  }
-  p = zName - 4 - sizeof(Pager*);
-  assert( EIGHT_BYTE_ALIGNMENT(p) );
-  pPager = *(Pager**)p;
-  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->dbSize<pgno || noContent ){
-      if( pgno>pPager->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) );
-
-  /* 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 */
-){
-#if 0   /* Trace page fetch by setting to 1 */
-  int rc;
-  printf("PAGE %u\n", pgno);
-  fflush(stdout);
-  rc = pPager->xGet(pPager, pgno, ppPage, flags);
-  if( rc ){
-    printf("PAGE %u failed with 0x%02x\n", pgno, rc);
-    fflush(stdout);
-  }
-  return rc;
-#else
-  /* Normal, high-speed version of sqlite3PagerGet() */
-  return pPager->xGet(pPager, pgno, ppPage, flags);
-#endif
-}
-
-/*
-** 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->eState<PAGER_ERROR );
-  pPager->subjInMemory = (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 );
-  pData2 = pPg->pData;
-  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->dbSize<pPg->pgno ){
-    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; ii<nPage && rc==SQLITE_OK; ii++){
-    Pgno pg = pg1+ii;
-    PgHdr *pPage;
-    if( pg==pPg->pgno || !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; ii<nPage; ii++){
-      PgHdr *pPage = sqlite3PagerLookup(pPager, pg1+ii);
-      if( pPage ){
-        pPage->flags |= 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 );
-        zBuf = pPgHdr->pData;
-        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->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
-
-  assert( MEMDB==0 || pPager->tempFile );
-  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 && pPager->dbSize>pPager->dbFileSize ){
-            char *pTmp = pPager->pTmpSpace;
-            int szPage = (int)pPager->pageSize;
-            memset(pTmp, 0, szPage);
-            rc = sqlite3OsWrite(pPager->fd, pTmp, szPage,
-                      ((i64)pPager->dbSize*pPager->pageSize)-szPage);
-          }
-          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] = (int)pPager->aStat[PAGER_STAT_HIT] & 0x7fffffff;
-  a[7] = (int)pPager->aStat[PAGER_STAT_MISS] & 0x7fffffff;
-  a[8] = 0;  /* Used to be pPager->nOvfl */
-  a[9] = pPager->nRead;
-  a[10] = (int)pPager->aStat[PAGER_STAT_WRITE] & 0x7fffffff;
-  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, u64 *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; ii<nSavepoint; ii++){
-    aNew[ii].nOrig = pPager->dbSize;
-    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 && iSavepoint<pPager->nSavepoint ){
-    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; ii<pPager->nSavepoint; 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){
-#ifdef 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;
-}
-
-#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;
-  **     <journal page X, then modify it in memory>
-  **     SAVEPOINT one;
-  **       <Move page X to location Y>
-  **     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 transitioning 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 || eMode==PAGER_JOURNALMODE_MEMORY ){
-      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
-    );
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    if( rc==SQLITE_OK ){
-      sqlite3WalDb(pPager->pWal, pPager->dbWal);
-    }
-#endif
-  }
-  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){
-  pPager->dbWal = 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
-
-#if defined(SQLITE_USE_SEH) && !defined(SQLITE_OMIT_WAL)
-SQLITE_PRIVATE int sqlite3PagerWalSystemErrno(Pager *pPager){
-  return sqlite3WalSystemErrno(pPager->pWal);
-}
-#endif
-
-#endif /* SQLITE_OMIT_DISKIO */
-
-/************** 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 <page-size> 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 implementation 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[] indexes 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.
-**
-** writeLock:
-**   This is usually set to 1 whenever the WRITER lock is held. However,
-**   if it is set to 2, then the WRITER lock is held but must be released
-**   by walHandleException() if a SEH exception is thrown.
-*/
-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_USE_SEH
-  u32 lockMask;              /* Mask of locks held */
-  void *pFree;               /* Pointer to sqlite3_free() if exception thrown */
-  u32 *pWiValue;             /* Value to write into apWiData[iWiPg] */
-  int iWiPg;                 /* Write pWiValue into apWiData[iWiPg] */
-  int iSysErrno;             /* System error code following exception */
-#endif
-#ifdef SQLITE_DEBUG
-  int nSehTry;               /* Number of nested SEH_TRY{} blocks */
-  u8 lockError;              /* True if a locking error has occurred */
-#endif
-#ifdef SQLITE_ENABLE_SNAPSHOT
-  WalIndexHdr *pSnapshot;    /* Start transaction here if not NULL */
-  int bGetSnapshot;          /* Transaction opened for sqlite3_get_snapshot() */
-#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[FLEXARRAY];          /* One for every 32KB page in the wal-index */
-};
-
-/* Size (in bytes) of a WalIterator object suitable for N or fewer segments */
-#define SZ_WALITERATOR(N)  \
-     (offsetof(WalIterator,aSegment)+(N)*sizeof(struct WalSegment))
-
-/*
-** 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) \
-)
-
-/*
-** Structured Exception Handling (SEH) is a Windows-specific technique
-** for catching exceptions raised while accessing memory-mapped files.
-**
-** The -DSQLITE_USE_SEH compile-time option means to use SEH to catch and
-** deal with system-level errors that arise during WAL -shm file processing.
-** Without this compile-time option, any system-level faults that appear
-** while accessing the memory-mapped -shm file will cause a process-wide
-** signal to be deliver, which will more than likely cause the entire
-** process to exit.
-*/
-#ifdef SQLITE_USE_SEH
-#include <Windows.h>
-
-/* Beginning of a block of code in which an exception might occur */
-# define SEH_TRY    __try { \
-   assert( walAssertLockmask(pWal) && pWal->nSehTry==0 ); \
-   VVA_ONLY(pWal->nSehTry++);
-
-/* The end of a block of code in which an exception might occur */
-# define SEH_EXCEPT(X) \
-   VVA_ONLY(pWal->nSehTry--); \
-   assert( pWal->nSehTry==0 ); \
-   } __except( sehExceptionFilter(pWal, GetExceptionCode(), GetExceptionInformation() ) ){ X }
-
-/* Simulate a memory-mapping fault in the -shm file for testing purposes */
-# define SEH_INJECT_FAULT sehInjectFault(pWal)
-
-/*
-** The second argument is the return value of GetExceptionCode() for the
-** current exception. Return EXCEPTION_EXECUTE_HANDLER if the exception code
-** indicates that the exception may have been caused by accessing the *-shm
-** file mapping. Or EXCEPTION_CONTINUE_SEARCH otherwise.
-*/
-static int sehExceptionFilter(Wal *pWal, int eCode, EXCEPTION_POINTERS *p){
-  VVA_ONLY(pWal->nSehTry--);
-  if( eCode==EXCEPTION_IN_PAGE_ERROR ){
-    if( p && p->ExceptionRecord && p->ExceptionRecord->NumberParameters>=3 ){
-      /* From MSDN: For this type of exception, the first element of the
-      ** ExceptionInformation[] array is a read-write flag - 0 if the exception
-      ** was thrown while reading, 1 if while writing. The second element is
-      ** the virtual address being accessed. The "third array element specifies
-      ** the underlying NTSTATUS code that resulted in the exception". */
-      pWal->iSysErrno = (int)p->ExceptionRecord->ExceptionInformation[2];
-    }
-    return EXCEPTION_EXECUTE_HANDLER;
-  }
-  return EXCEPTION_CONTINUE_SEARCH;
-}
-
-/*
-** If one is configured, invoke the xTestCallback callback with 650 as
-** the argument. If it returns true, throw the same exception that is
-** thrown by the system if the *-shm file mapping is accessed after it
-** has been invalidated.
-*/
-static void sehInjectFault(Wal *pWal){
-  int res;
-  assert( pWal->nSehTry>0 );
-
-  res = sqlite3FaultSim(650);
-  if( res!=0 ){
-    ULONG_PTR aArg[3];
-    aArg[0] = 0;
-    aArg[1] = 0;
-    aArg[2] = (ULONG_PTR)res;
-    RaiseException(EXCEPTION_IN_PAGE_ERROR, 0, 3, (const ULONG_PTR*)aArg);
-  }
-}
-
-/*
-** There are two ways to use this macro. To set a pointer to be freed
-** if an exception is thrown:
-**
-**   SEH_FREE_ON_ERROR(0, pPtr);
-**
-** and to cancel the same:
-**
-**   SEH_FREE_ON_ERROR(pPtr, 0);
-**
-** In the first case, there must not already be a pointer registered to
-** be freed. In the second case, pPtr must be the registered pointer.
-*/
-#define SEH_FREE_ON_ERROR(X,Y) \
-  assert( (X==0 || Y==0) && pWal->pFree==X ); pWal->pFree = Y
-
-/*
-** There are two ways to use this macro. To arrange for pWal->apWiData[iPg]
-** to be set to pValue if an exception is thrown:
-**
-**   SEH_SET_ON_ERROR(iPg, pValue);
-**
-** and to cancel the same:
-**
-**   SEH_SET_ON_ERROR(0, 0);
-*/
-#define SEH_SET_ON_ERROR(X,Y)  pWal->iWiPg = X; pWal->pWiValue = Y
-
-#else
-# define SEH_TRY          VVA_ONLY(pWal->nSehTry++);
-# define SEH_EXCEPT(X)    VVA_ONLY(pWal->nSehTry--); assert( pWal->nSehTry==0 );
-# define SEH_INJECT_FAULT assert( pWal->nSehTry>0 );
-# define SEH_FREE_ON_ERROR(X,Y)
-# define SEH_SET_ON_ERROR(X,Y)
-#endif /* ifdef SQLITE_USE_SEH */
-
-
-/*
-** 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*)*(1+(i64)iPage);
-    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 */
-){
-  SEH_INJECT_FAULT;
-  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] );
-  SEH_INJECT_FAULT;
-  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] );
-  SEH_INJECT_FAULT;
-  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;
-  }
-
-  /* nByte is a multiple of 8 between 8 and 65536 */
-  assert( nByte>=8 && (nByte&7)==0 && nByte<=65536 );
-
-  if( !nativeCksum ){
-    do {
-      s1 += BYTESWAP32(aData[0]) + s2;
-      s2 += BYTESWAP32(aData[1]) + s1;
-      aData += 2;
-    }while( aData<aEnd );
-  }else if( nByte%64==0 ){
-    do {
-      s1 += *aData++ + s2;
-      s2 += *aData++ + s1;
-      s1 += *aData++ + s2;
-      s2 += *aData++ + s1;
-      s1 += *aData++ + s2;
-      s2 += *aData++ + s1;
-      s1 += *aData++ + s2;
-      s2 += *aData++ + s1;
-      s1 += *aData++ + s2;
-      s2 += *aData++ + s1;
-      s1 += *aData++ + s2;
-      s2 += *aData++ + s1;
-      s1 += *aData++ + s2;
-      s2 += *aData++ + s1;
-      s1 += *aData++ + s2;
-      s2 += *aData++ + s1;
-    }while( aData<aEnd );
-  }else{
-    do {
-      s1 += *aData++ + s2;
-      s2 += *aData++ + s1;
-    }while( aData<aEnd );
-  }
-  assert( aData==aEnd );
-
-  aOut[0] = s1;
-  aOut[1] = s2;
-}
-
-/*
-** If there is the possibility of concurrent access to the SHM file
-** from multiple threads and/or processes, then do a memory barrier.
-*/
-static void walShmBarrier(Wal *pWal){
-  if( pWal->exclusiveMode!=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 greater 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 frames, 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); )
-#ifdef SQLITE_USE_SEH
-  if( rc==SQLITE_OK ) pWal->lockMask |= (1 << lockIdx);
-#endif
-  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);
-#ifdef SQLITE_USE_SEH
-  pWal->lockMask &= ~(1 << lockIdx);
-#endif
-  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); )
-#ifdef SQLITE_USE_SEH
-  if( rc==SQLITE_OK ){
-    pWal->lockMask |= (((1<<n)-1) << (SQLITE_SHM_NLOCK+lockIdx));
-  }
-#endif
-  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);
-#ifdef SQLITE_USE_SEH
-  pWal->lockMask &= ~(((1<<n)-1) << (SQLITE_SHM_NLOCK+lockIdx));
-#endif
-  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 walNextHash() 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);
-  SEH_INJECT_FAULT;
-  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; i<HASHTABLE_NSLOT; i++){
-    if( sLoc.aHash[i]>iLimit ){
-      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<iLimit; j++){
-      for(iKey=walHash(sLoc.aPgno[j]);sLoc.aHash[iKey];iKey=walNextHash(iKey)){
-        if( sLoc.aHash[iKey]==j+1 ) break;
-      }
-      assert( sLoc.aHash[iKey]==j+1 );
-    }
-  }
-#endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
-}
-
-
-/*
-** Set an entry in the wal-index that will map database page number
-** pPage into WAL frame iFrame.
-*/
-static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
-  int rc;                         /* Return code */
-  WalHashLoc sLoc;                /* Wal-index hash table location */
-
-  rc = walHashGet(pWal, walFramePage(iFrame), &sLoc);
-
-  /* Assuming the wal-index file was successfully mapped, populate the
-  ** page number array and hash table entry.
-  */
-  if( rc==SQLITE_OK ){
-    int iKey;                     /* Hash table key */
-    int idx;                      /* Value to write to hash-table slot */
-    int nCollide;                 /* Number of hash collisions */
-
-    idx = iFrame - sLoc.iZero;
-    assert( idx <= HASHTABLE_NSLOT/2 + 1 );
-
-    /* If this is the first entry to be added to this hash-table, zero the
-    ** entire hash table and aPgno[] array before proceeding.
-    */
-    if( idx==1 ){
-      int nByte = (int)((u8*)&sLoc.aHash[HASHTABLE_NSLOT] - (u8*)sLoc.aPgno);
-      assert( nByte>=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)&(HASHTABLE_NPAGE-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; i<HASHTABLE_NSLOT; i++){ if( sLoc.aHash[i] ) nEntry++; }
-      assert( nEntry==idx );
-    }
-
-    /* Verify that the every entry in the mapping region is reachable
-    ** via the hash table.  This turns out to be a really, really expensive
-    ** thing to check, so only do this occasionally - not on every
-    ** iteration.
-    */
-    if( (idx&0x3ff)==0 ){
-      int i;           /* Loop counter */
-      for(i=0; i<idx; i++){
-        for(iKey=walHash(sLoc.aPgno[i]);
-            sLoc.aHash[iKey];
-            iKey=walNextHash(iKey)){
-          if( sLoc.aHash[iKey]==i+1 ) break;
-        }
-        assert( sLoc.aHash[iKey]==i+1 );
-      }
-    }
-#endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
-  }
-
-  return rc;
-}
-
-
-/*
-** Recover the wal-index by reading the write-ahead log file.
-**
-** This routine first tries to establish an exclusive lock on the
-** wal-index to prevent other threads/processes from doing anything
-** with the WAL or wal-index while recovery is running.  The
-** WAL_RECOVER_LOCK is also held so that other threads will know
-** that this thread is running recovery.  If unable to establish
-** the necessary locks, this routine returns SQLITE_BUSY.
-*/
-static int walIndexRecover(Wal *pWal){
-  int rc;                         /* Return Code */
-  i64 nSize;                      /* Size of log file */
-  u32 aFrameCksum[2] = {0, 0};
-  int iLock;                      /* Lock offset to lock for checkpoint */
-
-  /* Obtain an exclusive lock on all byte in the locking range not already
-  ** locked by the caller. The caller is guaranteed to have locked the
-  ** WAL_WRITE_LOCK byte, and may have also locked the WAL_CKPT_LOCK byte.
-  ** If successful, the same bytes that are locked here are unlocked before
-  ** this function returns.
-  */
-  assert( pWal->ckptLock==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);
-    SEH_FREE_ON_ERROR(0, aFrame);
-    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;
-      SEH_SET_ON_ERROR(iPg, aShare);
-      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;
-      SEH_SET_ON_ERROR(0,0);
-      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; i<WALINDEX_PGSZ/sizeof(u32); i++){
-          if( aShare[i]!=aPrivate[i] ){
-            /* Atomic memory operations are not required here because if
-            ** the value needs to be changed, that means it is not being
-            ** accessed concurrently. */
-            aShare[i] = aPrivate[i];
-          }
-        }
-      }
-#endif
-      SEH_INJECT_FAULT;
-      if( iFrame<=iLast ) break;
-    }
-
-    SEH_FREE_ON_ERROR(aFrame, 0);
-    sqlite3_free(aFrame);
-  }
-
-finished:
-  if( rc==SQLITE_OK ){
-    volatile WalCkptInfo *pInfo;
-    int i;
-    pWal->hdr.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; i<WAL_NREADER; i++){
-      rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
-      if( rc==SQLITE_OK ){
-        if( i==1 && pWal->hdr.mxFrame ){
-          pInfo->aReadMark[i] = pWal->hdr.mxFrame;
-        }else{
-          pInfo->aReadMark[i] = READMARK_NOT_USED;
-        }
-        SEH_INJECT_FAULT;
-        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; i<pWal->nWiData; 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 truncated 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->iNext<pSegment->nEntry ){
-      u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];
-      if( iPg>iMin ){
-        if( iPg<iRet ){
-          iRet = iPg;
-          *piFrame = pSegment->iZero + 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 J<K:
-**
-**        aContent[aLeft[J]] < aContent[aLeft[K]]
-**        aContent[aRight[J]] < aContent[aRight[K]]
-**
-** This routine overwrites aRight[] with a new (probably longer) sequence
-** of indices such that the aRight[] contains every index that appears in
-** either aLeft[] or the old aRight[] and such that the second condition
-** above is still met.
-**
-** The aContent[aLeft[X]] values will be unique for all X.  And the
-** aContent[aRight[X]] values will be unique too.  But there might be
-** one or more combinations of X and Y such that
-**
-**      aLeft[X]!=aRight[Y]  &&  aContent[aLeft[X]] == aContent[aRight[Y]]
-**
-** When that happens, omit the aLeft[X] and use the aRight[Y] index.
-*/
-static void walMerge(
-  const u32 *aContent,            /* Pages in wal - keys for the sort */
-  ht_slot *aLeft,                 /* IN: Left hand input list */
-  int nLeft,                      /* IN: Elements in array *paLeft */
-  ht_slot **paRight,              /* IN/OUT: Right hand input list */
-  int *pnRight,                   /* IN/OUT: Elements in *paRight */
-  ht_slot *aTmp                   /* Temporary buffer */
-){
-  int iLeft = 0;                  /* Current index in aLeft */
-  int iRight = 0;                 /* Current index in aRight */
-  int iOut = 0;                   /* Current index in output buffer */
-  int nRight = *pnRight;
-  ht_slot *aRight = *paRight;
-
-  assert( nLeft>0 && nRight>0 );
-  while( iRight<nRight || iLeft<nLeft ){
-    ht_slot logpage;
-    Pgno dbpage;
-
-    if( (iLeft<nLeft)
-     && (iRight>=nRight || aContent[aLeft[iLeft]]<aContent[aRight[iRight]])
-    ){
-      logpage = aLeft[iLeft++];
-    }else{
-      logpage = aRight[iRight++];
-    }
-    dbpage = aContent[logpage];
-
-    aTmp[iOut++] = logpage;
-    if( iLeft<nLeft && aContent[aLeft[iLeft]]==dbpage ) iLeft++;
-
-    assert( 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 J<K:
-**
-**      aContent[aList[J]] < aContent[aList[K]]
-**
-** For any X and Y such that
-**
-**      aContent[aList[X]] == aContent[aList[Y]]
-**
-** Keep the larger of the two values aList[X] and aList[Y] and discard
-** the smaller.
-*/
-static void walMergesort(
-  const u32 *aContent,            /* Pages in wal */
-  ht_slot *aBuffer,               /* Buffer of at least *pnList items to use */
-  ht_slot *aList,                 /* IN/OUT: List to sort */
-  int *pnList                     /* IN/OUT: Number of elements in aList[] */
-){
-  struct Sublist {
-    int nList;                    /* Number of elements in aList */
-    ht_slot *aList;               /* Pointer to sub-list content */
-  };
-
-  const int nList = *pnList;      /* Size of input list */
-  int nMerge = 0;                 /* Number of elements in list aMerge */
-  ht_slot *aMerge = 0;            /* List to be merged */
-  int iList;                      /* Index into input list */
-  u32 iSub = 0;                   /* Index into aSub array */
-  struct Sublist aSub[13];        /* Array of sub-lists */
-
-  memset(aSub, 0, sizeof(aSub));
-  assert( nList<=HASHTABLE_NPAGE && nList>0 );
-  assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );
-
-  for(iList=0; iList<nList; iList++){
-    nMerge = 1;
-    aMerge = &aList[iList];
-    for(iSub=0; iList & (1<<iSub); iSub++){
-      struct Sublist *p;
-      assert( iSub<ArraySize(aSub) );
-      p = &aSub[iSub];
-      assert( p->aList && p->nList<=(1<<iSub) );
-      assert( p->aList==&aList[iList&~((2<<iSub)-1)] );
-      walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
-    }
-    aSub[iSub].aList = aMerge;
-    aSub[iSub].nList = nMerge;
-  }
-
-  for(iSub++; iSub<ArraySize(aSub); iSub++){
-    if( nList & (1<<iSub) ){
-      struct Sublist *p;
-      assert( iSub<ArraySize(aSub) );
-      p = &aSub[iSub];
-      assert( p->nList<=(1<<iSub) );
-      assert( p->aList==&aList[nList&~((2<<iSub)-1)] );
-      walMerge(aContent, p->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 = SZ_WALITERATOR(nSegment)
-        + iLast*sizeof(ht_slot);
-  p = (WalIterator *)sqlite3_malloc64(nByte
-      + sizeof(ht_slot) * (iLast>HASHTABLE_NPAGE?HASHTABLE_NPAGE:iLast)
-  );
-  if( !p ){
-    return SQLITE_NOMEM_BKPT;
-  }
-  memset(p, 0, nByte);
-  p->nSegment = nSegment;
-  aTmp = (ht_slot*)&(((u8*)p)[nByte]);
-  SEH_FREE_ON_ERROR(0, p);
-  for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && i<nSegment; i++){
-    WalHashLoc sLoc;
-
-    rc = walHashGet(pWal, i, &sLoc);
-    if( rc==SQLITE_OK ){
-      int j;                      /* Counter variable */
-      int nEntry;                 /* Number of entries in this segment */
-      ht_slot *aIndex;            /* Sorted index for this segment */
-
-      if( (i+1)==nSegment ){
-        nEntry = (int)(iLast - sLoc.iZero);
-      }else{
-        nEntry = (int)((u32*)sLoc.aHash - (u32*)sLoc.aPgno);
-      }
-      aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[sLoc.iZero];
-      sLoc.iZero++;
-
-      for(j=0; j<nEntry; j++){
-        aIndex[j] = (ht_slot)j;
-      }
-      walMergesort((u32 *)sLoc.aPgno, aTmp, aIndex, &nEntry);
-      p->aSegment[i].iZero = sLoc.iZero;
-      p->aSegment[i].nEntry = nEntry;
-      p->aSegment[i].aIndex = aIndex;
-      p->aSegment[i].aPgno = (u32 *)sLoc.aPgno;
-    }
-  }
-  if( rc!=SQLITE_OK ){
-    SEH_FREE_ON_ERROR(p, 0);
-    walIteratorFree(p);
-    p = 0;
-  }
-  *pp = p;
-  return rc;
-}
-
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-
-
-/*
-** Attempt to enable blocking locks that block for nMs ms. Return 1 if
-** blocking locks are successfully enabled, or 0 otherwise.
-*/
-static int walEnableBlockingMs(Wal *pWal, int nMs){
-  int rc = sqlite3OsFileControl(
-      pWal->pDbFd, SQLITE_FCNTL_LOCK_TIMEOUT, (void*)&nMs
-  );
-  return (rc==SQLITE_OK);
-}
-
-/*
-** 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->setlkTimeout;
-    if( tmout ){
-      res = walEnableBlockingMs(pWal, tmout);
-    }
-  }
-  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;
-}
-
-#else
-# define walEnableBlocking(x) 0
-# define walDisableBlocking(x)
-# define walEnableBlockingMs(pWal, ms) 0
-# 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; i<WAL_NREADER; i++) pInfo->aReadMark[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->nBackfill<pWal->hdr.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; i<WAL_NREADER; i++){
-      u32 y = AtomicLoad(pInfo->aReadMark+i); SEH_INJECT_FAULT;
-      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); SEH_INJECT_FAULT;
-          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->nBackfill<mxSafeFrame ){
-      rc = walIteratorInit(pWal, pInfo->nBackfill, &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;
-      WalIndexHdr *pLive = (WalIndexHdr*)walIndexHdr(pWal);
-
-      /* Now that read-lock slot 0 is locked, check that the wal has not been
-      ** wrapped since the header was read for this checkpoint. If it was, then
-      ** there was no work to do anyway.  In this case the
-      ** (pInfo->nBackfill<pWal->hdr.mxFrame) test above only passed because
-      ** pInfo->nBackfill had already been set to 0 by the writer that wrapped
-      ** the wal file. It would also be dangerous to proceed, as there may be
-      ** fewer than pWal->hdr.mxFrame valid frames in the wal file.  */
-      int bChg = memcmp(pLive->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt));
-      if( 0==bChg ){
-        pInfo->nBackfillAttempted = mxSafeFrame; SEH_INJECT_FAULT;
-
-        /* 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 && nSize<nReq ){
-            if( (nSize+65536+(i64)pWal->hdr.mxFrame*szPage)<nReq ){
-              /* If the size of the final database is larger than the current
-              ** database plus the amount of data in the wal file, plus the
-              ** maximum size of the pending-byte page (65536 bytes), then
-              ** must be corruption somewhere.  */
-              rc = SQLITE_CORRUPT_BKPT;
-            }else{
-              sqlite3OsFileControlHint(
-                  pWal->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 );
-          SEH_INJECT_FAULT;
-          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); SEH_INJECT_FAULT;
-          }
-        }
-      }
-
-      /* 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 );
-    SEH_INJECT_FAULT;
-    if( pInfo->nBackfill<pWal->hdr.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:
-  SEH_FREE_ON_ERROR(pIter, 0);
-  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);
-  }
-}
-
-#ifdef SQLITE_USE_SEH
-/*
-** This is the "standard" exception handler used in a few places to handle
-** an exception thrown by reading from the *-shm mapping after it has become
-** invalid in SQLITE_USE_SEH builds. It is used as follows:
-**
-**   SEH_TRY { ... }
-**   SEH_EXCEPT( rc = walHandleException(pWal); )
-**
-** This function does three things:
-**
-**   1) Determines the locks that should be held, based on the contents of
-**      the Wal.readLock, Wal.writeLock and Wal.ckptLock variables. All other
-**      held locks are assumed to be transient locks that would have been
-**      released had the exception not been thrown and are dropped.
-**
-**   2) Frees the pointer at Wal.pFree, if any, using sqlite3_free().
-**
-**   3) Set pWal->apWiData[pWal->iWiPg] to pWal->pWiValue if not NULL
-**
-**   4) Returns SQLITE_IOERR.
-*/
-static int walHandleException(Wal *pWal){
-  if( pWal->exclusiveMode==0 ){
-    static const int S = 1;
-    static const int E = (1<<SQLITE_SHM_NLOCK);
-    int ii;
-    u32 mUnlock;
-    if( pWal->writeLock==2 ) pWal->writeLock = 0;
-    mUnlock = pWal->lockMask & ~(
-        (pWal->readLock<0 ? 0 : (S << WAL_READ_LOCK(pWal->readLock)))
-        | (pWal->writeLock ? (E << WAL_WRITE_LOCK) : 0)
-        | (pWal->ckptLock ? (E << WAL_CKPT_LOCK) : 0)
-        );
-    for(ii=0; ii<SQLITE_SHM_NLOCK; ii++){
-      if( (S<<ii) & mUnlock ) walUnlockShared(pWal, ii);
-      if( (E<<ii) & mUnlock ) walUnlockExclusive(pWal, ii, 1);
-    }
-  }
-  sqlite3_free(pWal->pFree);
-  pWal->pFree = 0;
-  if( pWal->pWiValue ){
-    pWal->apWiData[pWal->iWiPg] = pWal->pWiValue;
-    pWal->pWiValue = 0;
-  }
-  return SQLITE_IOERR_IN_PAGE;
-}
-
-/*
-** Assert that the Wal.lockMask mask, which indicates the locks held
-** by the connection, is consistent with the Wal.readLock, Wal.writeLock
-** and Wal.ckptLock variables. To be used as:
-**
-**   assert( walAssertLockmask(pWal) );
-*/
-static int walAssertLockmask(Wal *pWal){
-  if( pWal->exclusiveMode==0 ){
-    static const int S = 1;
-    static const int E = (1<<SQLITE_SHM_NLOCK);
-    u32 mExpect = (
-        (pWal->readLock<0 ? 0 : (S << WAL_READ_LOCK(pWal->readLock)))
-      | (pWal->writeLock ? (E << WAL_WRITE_LOCK) : 0)
-      | (pWal->ckptLock ? (E << WAL_CKPT_LOCK) : 0)
-#ifdef SQLITE_ENABLE_SNAPSHOT
-      | (pWal->pSnapshot ? (pWal->lockMask & (1 << WAL_CKPT_LOCK)) : 0)
-#endif
-    );
-    assert( mExpect==pWal->lockMask );
-  }
-  return 1;
-}
-
-/*
-** Return and zero the "system error" field set when an
-** EXCEPTION_IN_PAGE_ERROR exception is caught.
-*/
-SQLITE_PRIVATE int sqlite3WalSystemErrno(Wal *pWal){
-  int iRet = 0;
-  if( pWal ){
-    iRet = pWal->iSysErrno;
-    pWal->iSysErrno = 0;
-  }
-  return iRet;
-}
-
-#else
-# define walAssertLockmask(x) 1
-#endif /* ifdef SQLITE_USE_SEH */
-
-/*
-** 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 */
-
-    assert( walAssertLockmask(pWal) );
-
-    /* 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
-          ** fsynced (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 implementations 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 = walLockExclusive(pWal, WAL_WRITE_LOCK, 1))
-      ){
-        /* If the write-lock was just obtained, set writeLock to 2 instead of
-        ** the usual 1. This causes walIndexPage() to behave as if the
-        ** write-lock were held (so that it allocates new pages as required),
-        ** and walHandleException() to unlock the write-lock if a SEH exception
-        ** is thrown.  */
-        if( !bWriteLock ) pWal->writeLock = 2;
-        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.
-            ** Disable blocking locks first.  */
-            walDisableBlocking(pWal);
-            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( szWal<WAL_HDRSIZE ){
-    /* If the wal file is too small to contain a wal-header and the
-    ** wal-index header has mxFrame==0, then it must be safe to proceed
-    ** reading the database file only. However, the page cache cannot
-    ** be trusted, as a read/write connection may have connected, written
-    ** the db, run a checkpoint, truncated the wal file and disconnected
-    ** since this client's last read transaction.  */
-    *pChanged = 1;
-    rc = (pWal->hdr.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; i<pWal->nWiData; i++){
-      sqlite3_free((void*)pWal->apWiData[i]);
-      pWal->apWiData[i] = 0;
-    }
-    pWal->bShmUnreliable = 0;
-    sqlite3WalEndReadTransaction(pWal);
-    *pChanged = 1;
-  }
-  return rc;
-}
-
-/*
-** The final argument passed to walTryBeginRead() is of type (int*). The
-** caller should invoke walTryBeginRead as follows:
-**
-**   int cnt = 0;
-**   do {
-**     rc = walTryBeginRead(..., &cnt);
-**   }while( rc==WAL_RETRY );
-**
-** The final value of "cnt" is of no use to the caller. It is used by
-** the implementation of walTryBeginRead() as follows:
-**
-**   + Each time walTryBeginRead() is called, it is incremented. Once
-**     it reaches WAL_RETRY_PROTOCOL_LIMIT - indicating that walTryBeginRead()
-**     has many times been invoked and failed with WAL_RETRY - walTryBeginRead()
-**     returns SQLITE_PROTOCOL.
-**
-**   + If SQLITE_ENABLE_SETLK_TIMEOUT is defined and walTryBeginRead() failed
-**     because a blocking lock timed out (SQLITE_BUSY_TIMEOUT from the OS
-**     layer), the WAL_RETRY_BLOCKED_MASK bit is set in "cnt". In this case
-**     the next invocation of walTryBeginRead() may omit an expected call to
-**     sqlite3OsSleep(). There has already been a delay when the previous call
-**     waited on a lock.
-*/
-#define WAL_RETRY_PROTOCOL_LIMIT 100
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-# define WAL_RETRY_BLOCKED_MASK    0x10000000
-#else
-# define WAL_RETRY_BLOCKED_MASK    0
-#endif
-
-/*
-** 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 *pCnt){
-  volatile WalCkptInfo *pInfo;    /* Checkpoint information in wal-index */
-  int rc = SQLITE_OK;             /* Return code  */
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  int nBlockTmout = 0;
-#endif
-
-  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.
-  */
-  (*pCnt)++;
-  if( *pCnt>5 ){
-    int nDelay = 1;                      /* Pause time in microseconds */
-    int cnt = (*pCnt & ~WAL_RETRY_BLOCKED_MASK);
-    if( cnt>WAL_RETRY_PROTOCOL_LIMIT ){
-      VVA_ONLY( pWal->lockError = 1; )
-      return SQLITE_PROTOCOL;
-    }
-    if( *pCnt>=10 ) nDelay = (cnt-9)*(cnt-9)*39;
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    /* In SQLITE_ENABLE_SETLK_TIMEOUT builds, configure the file-descriptor
-    ** to block for locks for approximately nDelay us. This affects three
-    ** locks: (a) the shared lock taken on the DMS slot in os_unix.c (if
-    ** using os_unix.c), (b) the WRITER lock taken in walIndexReadHdr() if the
-    ** first attempted read fails, and (c) the shared lock taken on the
-    ** read-mark.
-    **
-    ** If the previous call failed due to an SQLITE_BUSY_TIMEOUT error,
-    ** then sleep for the minimum of 1us. The previous call already provided
-    ** an extra delay while it was blocking on the lock.
-    */
-    nBlockTmout = (nDelay+998) / 1000;
-    if( !useWal && walEnableBlockingMs(pWal, nBlockTmout) ){
-      if( *pCnt & WAL_RETRY_BLOCKED_MASK ) nDelay = 1;
-    }
-#endif
-    sqlite3OsSleep(pWal->pVfs, nDelay);
-    *pCnt &= ~WAL_RETRY_BLOCKED_MASK;
-  }
-
-  if( !useWal ){
-    assert( rc==SQLITE_OK );
-    if( pWal->bShmUnreliable==0 ){
-      rc = walIndexReadHdr(pWal, pChanged);
-    }
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    if( rc==SQLITE_BUSY_TIMEOUT ){
-      rc = SQLITE_BUSY;
-      *pCnt |= WAL_RETRY_BLOCKED_MASK;
-    }
-#endif
-    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.
-      */
-      (void)walEnableBlocking(pWal);
-      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;
-      }
-    }
-    walDisableBlocking(pWal);
-    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);
-  SEH_INJECT_FAULT;
-  {
-    u32 mxReadMark;               /* Largest aReadMark[] value */
-    int mxI;                      /* Index of largest aReadMark[] value */
-    int i;                        /* Loop counter */
-    u32 mxFrame;                  /* Wal frame to lock to */
-    if( !useWal && AtomicLoad(&pInfo->nBackfill)==pWal->hdr.mxFrame
-#ifdef SQLITE_ENABLE_SNAPSHOT
-     && ((pWal->bGetSnapshot==0 && 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->mxFrame<mxFrame ){
-      mxFrame = pWal->pSnapshot->mxFrame;
-    }
-#endif
-    for(i=1; i<WAL_NREADER; i++){
-      u32 thisMark = AtomicLoad(pInfo->aReadMark+i); SEH_INJECT_FAULT;
-      if( mxReadMark<=thisMark && thisMark<=mxFrame ){
-        assert( thisMark!=READMARK_NOT_USED );
-        mxReadMark = thisMark;
-        mxI = i;
-      }
-    }
-    if( (pWal->readOnly & WAL_SHM_RDONLY)==0
-     && (mxReadMark<mxFrame || mxI==0)
-    ){
-      for(i=1; i<WAL_NREADER; i++){
-        rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
-        if( rc==SQLITE_OK ){
-          AtomicStore(pInfo->aReadMark+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;
-    }
-
-    (void)walEnableBlockingMs(pWal, nBlockTmout);
-    rc = walLockShared(pWal, WAL_READ_LOCK(mxI));
-    walDisableBlocking(pWal);
-    if( rc ){
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-      if( rc==SQLITE_BUSY_TIMEOUT ){
-        *pCnt |= WAL_RETRY_BLOCKED_MASK;
-      }
-#else
-      assert( rc!=SQLITE_BUSY_TIMEOUT );
-#endif
-      assert((rc&0xFF)!=SQLITE_BUSY||rc==SQLITE_BUSY||rc==SQLITE_BUSY_TIMEOUT);
-      return (rc&0xFF)==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; SEH_INJECT_FAULT;
-    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
-/*
-** This function does the work of sqlite3WalSnapshotRecover().
-*/
-static int walSnapshotRecover(
-  Wal *pWal,                      /* WAL handle */
-  void *pBuf1,                    /* Temp buffer pWal->szPage bytes in size */
-  void *pBuf2                     /* Temp buffer pWal->szPage bytes in size */
-){
-  int szPage = (int)pWal->szPage;
-  int rc;
-  i64 szDb;                       /* Size of db file in bytes */
-
-  rc = sqlite3OsFileSize(pWal->pDbFd, &szDb);
-  if( rc==SQLITE_OK ){
-    volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
-    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;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** 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 ){
-    void *pBuf1 = sqlite3_malloc(pWal->szPage);
-    void *pBuf2 = sqlite3_malloc(pWal->szPage);
-    if( pBuf1==0 || pBuf2==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      pWal->ckptLock = 1;
-      SEH_TRY {
-        rc = walSnapshotRecover(pWal, pBuf1, pBuf2);
-      }
-      SEH_EXCEPT( rc = SQLITE_IOERR_IN_PAGE; )
-      pWal->ckptLock = 0;
-    }
-
-    sqlite3_free(pBuf1);
-    sqlite3_free(pBuf2);
-    walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1);
-  }
-
-  return rc;
-}
-#endif /* SQLITE_ENABLE_SNAPSHOT */
-
-/*
-** This function does the work of sqlite3WalBeginReadTransaction() (see
-** below). That function simply calls this one inside an SEH_TRY{...} block.
-*/
-static int walBeginReadTransaction(Wal *pWal, int *pChanged){
-  int rc;                         /* Return code */
-  int cnt = 0;                    /* Number of TryBeginRead attempts */
-#ifdef SQLITE_ENABLE_SNAPSHOT
-  int ckptLock = 0;
-  int bChanged = 0;
-  WalIndexHdr *pSnapshot = pWal->pSnapshot;
-#endif
-
-  assert( pWal->ckptLock==0 );
-  assert( pWal->nSehTry>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;
-    }
-    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( ckptLock ){
-    assert( pSnapshot );
-    walUnlockShared(pWal, WAL_CKPT_LOCK);
-  }
-#endif
-  return rc;
-}
-
-/*
-** 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;
-  SEH_TRY {
-    rc = walBeginReadTransaction(pWal, pChanged);
-  }
-  SEH_EXCEPT( rc = walHandleException(pWal); )
-  return rc;
-}
-
-/*
-** Finish with a read transaction.  All this does is release the
-** read-lock.
-*/
-SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal){
-#ifndef SQLITE_ENABLE_SETLK_TIMEOUT
-  assert( pWal->writeLock==0 || pWal->readLock<0 );
-#endif
-  if( pWal->readLock>=0 ){
-    (void)sqlite3WalEndWriteTransaction(pWal);
-    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.
-*/
-static int walFindFrame(
-  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);
-    SEH_INJECT_FAULT;
-    while( (iH = AtomicLoad(&sLoc.aHash[iKey]))!=0 ){
-      u32 iFrame = iH + sLoc.iZero;
-      if( iFrame<=iLast
-       && iFrame>=pWal->minFrame
-       && sLoc.aPgno[(iH-1)&(HASHTABLE_NPAGE-1)]==pgno
-      ){
-        assert( iFrame>iRead || CORRUPT_DB );
-        iRead = iFrame;
-      }
-      if( (nCollide--)==0 ){
-        *piRead = 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;
-}
-
-/*
-** 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.
-**
-** The difference between this function and walFindFrame() is that this
-** function wraps walFindFrame() in an SEH_TRY{...} block.
-*/
-SQLITE_PRIVATE int sqlite3WalFindFrame(
-  Wal *pWal,                      /* WAL handle */
-  Pgno pgno,                      /* Database page number to read data for */
-  u32 *piRead                     /* OUT: Frame number (or zero) */
-){
-  int rc;
-  SEH_TRY {
-    rc = walFindFrame(pWal, pgno, piRead);
-  }
-  SEH_EXCEPT( rc = SQLITE_IOERR_IN_PAGE; )
-  return rc;
-}
-
-/*
-** 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*)pWal->apWiData[0],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.
-  */
-  SEH_TRY {
-    if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
-      rc = SQLITE_BUSY_SNAPSHOT;
-    }
-  }
-  SEH_EXCEPT( rc = SQLITE_IOERR_IN_PAGE; )
-
-  if( rc!=SQLITE_OK ){
-    walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
-    pWal->writeLock = 0;
-  }
-  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;
-
-    SEH_TRY {
-      /* 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);
-    }
-    SEH_EXCEPT( rc = SQLITE_IOERR_IN_PAGE; )
-    pWal->iReCksum = 0;
-  }
-  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]<pWal->hdr.mxFrame ){
-    pWal->hdr.mxFrame = aWalData[0];
-    pWal->hdr.aFrameCksum[0] = aWalData[1];
-    pWal->hdr.aFrameCksum[1] = aWalData[2];
-    SEH_TRY {
-      walCleanupHash(pWal);
-    }
-    SEH_EXCEPT( rc = SQLITE_IOERR_IN_PAGE; )
-    if( pWal->iReCksum>pWal->hdr.mxFrame ){
-      pWal->iReCksum = 0;
-    }
-  }
-
-  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, &notUsed, 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( iOffset<p->iSyncPoint && 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 */
-  pData = pPage->pData;
-  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()).
-*/
-static int walFrames(
-  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 =) walFindFrame(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 || iWrite<pWal->iReCksum ){
-          pWal->iReCksum = iWrite;
-        }
-        pData = p->pData;
-        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( iOffset<w.iSyncPoint ){
-        rc = walWriteOneFrame(&w, pLast, nTruncate, iOffset);
-        if( rc ) return rc;
-        iOffset += szFrame;
-        nExtra++;
-        assert( pLast!=0 );
-      }
-    }
-    if( bSync ){
-      assert( rc==SQLITE_OK );
-      rc = sqlite3OsSync(w.pFd, WAL_SYNC_FLAGS(sync_flags));
-    }
-  }
-
-  /* If this frame set completes the first transaction in the WAL and
-  ** if PRAGMA journal_size_limit is set, then truncate the WAL to the
-  ** journal size limit, if possible.
-  */
-  if( isCommit && pWal->truncateOnCommit && 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;
-}
-
-/*
-** Write a set of frames to the log. The caller must hold the write-lock
-** on the log file (obtained using sqlite3WalBeginWriteTransaction()).
-**
-** The difference between this function and walFrames() is that this
-** function wraps walFrames() in an SEH_TRY{...} block.
-*/
-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;
-  SEH_TRY {
-    rc = walFrames(pWal, szPage, pList, nTruncate, isCommit, sync_flags);
-  }
-  SEH_EXCEPT( rc = walHandleException(pWal); )
-  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( SQLITE_CHECKPOINT_NOOP<SQLITE_CHECKPOINT_PASSIVE );
-  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. */
-  sqlite3WalDb(pWal, db);
-  if( xBusy2 ) (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.
-  */
-  if( eMode!=SQLITE_CHECKPOINT_NOOP ){
-    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;
-        }
-      }
-    }
-  }else{
-    rc = SQLITE_OK;
-  }
-
-
-  /* Read the wal-index header. */
-  SEH_TRY {
-    if( rc==SQLITE_OK ){
-      /* For a passive checkpoint, do not re-enable blocking locks after
-      ** reading the wal-index header. A passive checkpoint should not block
-      ** or invoke the busy handler. The only lock such a checkpoint may
-      ** attempt to obtain is a lock on a read-slot, and it should give up
-      ** immediately and do a partial checkpoint if it cannot obtain it. */
-      walDisableBlocking(pWal);
-      rc = walIndexReadHdr(pWal, &isChanged);
-      if( eMode2>SQLITE_CHECKPOINT_PASSIVE ) (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 ){
-      sqlite3FaultSim(660);
-      if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){
-        rc = SQLITE_CORRUPT_BKPT;
-      }else if( eMode2!=SQLITE_CHECKPOINT_NOOP ){
-        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;
-        SEH_INJECT_FAULT;
-        if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill);
-      }
-    }
-  }
-  SEH_EXCEPT( rc = walHandleException(pWal); )
-
-  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. */
-  (void)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.
-  */
-#ifndef SQLITE_USE_SEH
-  assert( pWal->readLock>=0 || pWal->lockError );
-#endif
-  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
-){
-  if( pSnapshot && ((WalIndexHdr*)pSnapshot)->iVersion==0 ){
-    /* iVersion==0 means that this is a call to sqlite3_snapshot_get().  In
-    ** this case set the bGetSnapshot flag so that if the call to
-    ** sqlite3_snapshot_get() is about to read transaction on this wal
-    ** file, it does not take read-lock 0 if the wal file has been completely
-    ** checkpointed. Taking read-lock 0 would work, but then it would be
-    ** possible for a subsequent writer to destroy the snapshot even while
-    ** this connection is holding its read-transaction open. This is contrary
-    ** to user expectations, so we avoid it by not taking read-lock 0. */
-    pWal->bGetSnapshot = 1;
-  }else{
-    pWal->pSnapshot = (WalIndexHdr*)pSnapshot;
-    pWal->bGetSnapshot = 0;
-  }
-}
-
-/*
-** 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]<pHdr2->aSalt[0] ) return -1;
-  if( pHdr1->aSalt[0]>pHdr2->aSalt[0] ) return +1;
-  if( pHdr1->mxFrame<pHdr2->mxFrame ) 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;
-  SEH_TRY {
-    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->mxFrame<walCkptInfo(pWal)->nBackfillAttempted
-      ){
-        rc = SQLITE_ERROR_SNAPSHOT;
-        walUnlockShared(pWal, WAL_CKPT_LOCK);
-      }
-    }
-  }
-  SEH_EXCEPT( rc = walHandleException(pWal); )
-  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     The size of the database in pages
-**     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
-**    0x81 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 allocates 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
-
-/*
-** Maximum amount of storage local to a database page, regardless of
-** page size.
-*/
-#define BT_MAX_LOCAL  65501  /* 65536 - 35 */
-
-/*
-** 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 nCkPage;     /* Pages in the database.  0 for partial check */
-  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 */
-  i64 nRow;         /* Number of rows visited in current tree */
-};
-
-/*
-** 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.  get2byteAligned() 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->pBt<p->pBt );
-  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 ascending 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;
-  u8 skipOk = 1;
-  Btree *p;
-  assert( sqlite3_mutex_held(db->mutex) );
-  for(i=0; i<db->nDb; 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; i<db->nDb; 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; i<db->nDb; 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 && iDb<db->nDb );
-  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; i<db->nDb; 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
-
-/* Default value for SHARED_LOCK_TRACE macro if shared-cache is disabled
-** or if the lock tracking is disabled.  This is always the value for
-** release builds.
-*/
-#define SHARED_LOCK_TRACE(X,MSG,TAB,TYPE)  /*no-op*/
-
-#ifndef SQLITE_OMIT_SHARED_CACHE
-
-#if 0
-/*  ^----  Change to 1 and recompile to enable shared-lock tracing
-**         for debugging purposes.
-**
-** Print all shared-cache locks on a BtShared.  Debugging use only.
-*/
-static void sharedLockTrace(
-  BtShared *pBt,
-  const char *zMsg,
-  int iRoot,
-  int eLockType
-){
-  BtLock *pLock;
-  if( iRoot>0 ){
-    printf("%s-%p %u%s:", zMsg, pBt, iRoot, eLockType==READ_LOCK?"R":"W");
-  }else{
-    printf("%s-%p:", zMsg, pBt);
-  }
-  for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
-    printf(" %p/%u%s", pLock->pBtree, pLock->iTable,
-           pLock->eLock==READ_LOCK ? "R" : "W");
-    while( pLock->pNext && pLock->pBtree==pLock->pNext->pBtree ){
-      pLock = pLock->pNext;
-      printf(",%u%s", pLock->iTable, pLock->eLock==READ_LOCK ? "R" : "W");
-    }
-  }
-  printf("\n");
-  fflush(stdout);
-}
-#undef SHARED_LOCK_TRACE
-#define SHARED_LOCK_TRACE(X,MSG,TAB,TYPE)  sharedLockTrace(X,MSG,TAB,TYPE)
-#endif /* Shared-lock tracing */
-
-#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;
-  }
-
-  SHARED_LOCK_TRACE(pBtree->pBt,"hasLock",iRoot,eLockType);
-
-  /* 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;
-
-  SHARED_LOCK_TRACE(pBt,"setLock", iTable, eLock);
-
-  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 );
-
-  SHARED_LOCK_TRACE(pBt, "clearAllLocks", 0, 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;
-
-  SHARED_LOCK_TRACE(pBt, "downgradeLocks", 0, 0);
-
-  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; i<pCur->iPage; 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( ((i64)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((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 = (u8)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;
-  assert( nPayload>=0 );
-  if( nPayload<=maxLocal ){
-    return (int)nPayload;
-  }else{
-    int minLocal;  /* Minimum amount of payload held locally */
-    int surplus;   /* Overflow payload available for local storage */
-    minLocal = pPage->minLocal;
-    surplus = (int)(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 */
-  u64 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 && pIter<pEnd );
-    nPayload &= 0xffffffff;
-  }
-  pIter++;
-
-  /* The next block of code is equivalent to:
-  **
-  **     pIter += getVarint(pIter, (u64*)&pInfo->nKey);
-  **
-  ** 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 = (u32)nPayload;
-  pInfo->pPayload = pIter;
-  testcase( nPayload==pPage->maxLocal );
-  testcase( nPayload==(u32)pPage->maxLocal+1 );
-  assert( pPage->maxLocal <= BT_MAX_LOCAL );
-  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 = (u16)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 && pIter<pEnd );
-  }
-  pIter++;
-  pInfo->nKey = nPayload;
-  pInfo->nPayload = nPayload;
-  pInfo->pPayload = pIter;
-  testcase( nPayload==pPage->maxLocal );
-  testcase( nPayload==(u32)pPage->maxLocal+1 );
-  assert( nPayload>=0 );
-  assert( pPage->maxLocal <= BT_MAX_LOCAL );
-  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 = (u16)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 && pIter<pEnd );
-  }
-  pIter++;
-  testcase( nSize==pPage->maxLocal );
-  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 && pIter<pEnd );
-  }
-  pIter++;
-  testcase( nSize==pPage->maxLocal );
-  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 && pIter<pEnd );
-  assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
-  return (u16)(pIter - pCell);
-}
-static u16 cellSizePtrTableLeaf(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
-
-  nSize = *pIter;
-  if( nSize>=0x80 ){
-    pEnd = &pIter[8];
-    nSize &= 0x7f;
-    do{
-      nSize = (nSize<<7) | (*++pIter & 0x7f);
-    }while( *(pIter)>=0x80 && pIter<pEnd );
-  }
-  pIter++;
-  /* pIter now points at the 64-bit integer key value, a variable length
-  ** integer. The following block moves pIter to point at the first byte
-  ** past the end of the key value. */
-  if( (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80 ){ pIter++; }
-  testcase( nSize==pPage->maxLocal );
-  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.nLocal<info.nPayload ){
-    Pgno ovfl;
-    if( SQLITE_OVERFLOW(pSrc->aDataEnd, 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]; pAddr<pEnd; pAddr+=2){
-          pc = get2byte(pAddr);
-          if( pc<iFree ){ put2byte(pAddr, pc+sz); }
-          else if( pc<iFree2 ){ put2byte(pAddr, pc+sz2); }
-        }
-        goto defragment_out;
-      }
-    }
-  }
-
-  cbrk = usableSize;
-  iCellLast = usableSize - 4;
-  iCellStart = get2byte(&data[hdr+5]);
-  if( nCell>0 ){
-    temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
-    memcpy(temp, data, usableSize);
-    src = temp;
-    for(i=0; i<nCell; i++){
-      u8 *pAddr;     /* The i-th cell pointer */
-      pAddr = &data[cellOffset + i*2];
-      pc = get2byte(pAddr);
-      testcase( pc==iCellFirst );
-      testcase( pc==iCellLast );
-      /* These conditions have already been verified in btreeInitPage()
-      ** if PRAGMA cell_size_check=ON.
-      */
-      if( pc>iCellLast ){
-        return SQLITE_CORRUPT_PAGE(pPage);
-      }
-      assert( pc>=0 && pc<=iCellLast );
-      size = pPage->xCellSize(pPage, &src[pc]);
-      cbrk -= size;
-      if( cbrk<iCellStart || pc+size>usableSize ){
-        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 encroach 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, int iStart, int iSize){
-  int iPtr;                             /* Address of ptr to next freeblock */
-  int iFreeBlk;                         /* Address of the next freeblock */
-  u8 hdr;                               /* Page header size.  0 or 100 */
-  int nFrag = 0;                        /* Reduction in fragmentation */
-  int iOrigSize = iSize;                /* Original value of iSize */
-  int x;                                /* Offset to cell content area */
-  int 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 <= (int)pPage->pBt->usableSize );
-  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
-  assert( iSize>=4 );   /* Minimum cell size is 4 */
-  assert( CORRUPT_DB || iStart<=(int)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]))<iStart ){
-      if( iFreeBlk<=iPtr ){
-        if( iFreeBlk==0 ) break; /* TH3: corrupt082.100 */
-        return SQLITE_CORRUPT_PAGE(pPage);
-      }
-      iPtr = iFreeBlk;
-    }
-    if( iFreeBlk>(int)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 > (int)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] -= (u8)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( iStart<x ) return SQLITE_CORRUPT_PAGE(pPage);
-    if( iPtr!=hdr+1 ) return SQLITE_CORRUPT_PAGE(pPage);
-    put2byte(&data[hdr+1], iFreeBlk);
-    put2byte(&data[hdr+5], iEnd);
-  }else{
-    /* Insert the new freeblock into the freelist */
-    put2byte(&data[iPtr], iStart);
-    put2byte(&data[iStart], iFreeBlk);
-    assert( iSize>=0 && iSize<=0xffff );
-    put2byte(&data[iStart+2], (u16)iSize);
-  }
-  pPage->nFree += 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( pc<top ){
-      /* EVIDENCE-OF: R-55530-52930 In a well-formed b-tree page, there will
-      ** always be at least one cell before the first freeblock.
-      */
-      return SQLITE_CORRUPT_PAGE(pPage);
-    }
-    while( 1 ){
-      if( pc>iCellLast ){
-        /* 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 || nFree<iCellFirst ){
-    return SQLITE_CORRUPT_PAGE(pPage);
-  }
-  pPage->nFree = (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; i<pPage->nCell; i++){
-    pc = get2byteAligned(&data[cellOffset+i*2]);
-    testcase( pc==iCellFirst );
-    testcase( pc==iCellLast );
-    if( pc<iCellFirst || pc>iCellLast ){
-      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 = (u16)(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;
-  int hdr = pPage->hdrOffset;
-  int 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 = (u16)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.
-*/
-static int getAndInitPage(
-  BtShared *pBt,                  /* The database file */
-  Pgno pgno,                      /* Number of the page to get */
-  MemPage **ppPage,               /* Write the page pointer here */
-  int bReadOnly                   /* True for a read-only page */
-){
-  int rc;
-  DbPage *pDbPage;
-  MemPage *pPage;
-  assert( sqlite3_mutex_held(pBt->mutex) );
-
-  if( pgno>btreePagecount(pBt) ){
-    *ppPage = 0;
-    return SQLITE_CORRUPT_BKPT;
-  }
-  rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
-  if( rc ){
-    *ppPage = 0;
-    return rc;
-  }
-  pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage);
-  if( pPage->isInit==0 ){
-    btreePageFromDbPage(pDbPage, pgno, pBt);
-    rc = btreeInitPage(pPage);
-    if( rc!=SQLITE_OK ){
-      releasePage(pPage);
-      *ppPage = 0;
-      return rc;
-    }
-  }
-  assert( pPage->pgno==pgno || CORRUPT_DB );
-  assert( pPage->aData==sqlite3PagerGetData(pDbPage) );
-  *ppPage = pPage;
-  return SQLITE_OK;
-}
-
-/*
-** 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-initializing. */
-      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 );
-
-    /* Suppress false-positive compiler warning from PVS-Studio */
-    memset(&zDbHeader[16], 0, 8);
-
-    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; i<db->nDb; 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
-  UNUSED_PARAMETER( pBt );
-  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 uninitialized
-  ** 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 = (u8)nReserve;
-  x = pBt->pageSize - pBt->usableSize;
-  if( x==nReserve && (pageSize==0 || (u32)pageSize==pBt->pageSize) ){
-    sqlite3BtreeLeave(p);
-    return SQLITE_OK;
-  }
-  if( nReserve<x ) nReserve = x;
-  if( pBt->btsFlags & 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 intentionally 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 |= (u16)(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;
-    }
-    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;
-      pBt->btsFlags |= BTS_PAGESIZE_FIXED;
-      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->btsFlags |= BTS_PAGESIZE_FIXED;
-    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.
-*/
-static SQLITE_NOINLINE int btreeBeginTrans(
-  Btree *p,                 /* The btree in which to start the transaction */
-  int wrflag,               /* True to start a write transaction */
-  int *pSchemaVersion       /* Put schema version number here, if not NULL */
-){
-  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
-
-#ifdef SQLITE_EXPERIMENTAL_PRAGMA_20251114
-    /* If both a read and write transaction will be opened by this call,
-    ** then issue a file-control as if the following pragma command had
-    ** been evaluated:
-    **
-    **     PRAGMA experimental_pragma_20251114 = 1|2
-    **
-    ** where the RHS is "1" if wrflag is 1 (RESERVED lock), or "2" if wrflag
-    ** is 2 (EXCLUSIVE lock). Ignore any result or error returned by the VFS.
-    **
-    ** WARNING: This code will likely remain part of SQLite only temporarily -
-    ** it exists to allow users to experiment with certain types of blocking
-    ** locks in custom VFS implementations. It MAY BE REMOVED AT ANY TIME.  */
-    if( pBt->pPage1==0 && wrflag ){
-      sqlite3_file *fd = sqlite3PagerFile(pPager);
-      char *aFcntl[3] = {0,0,0};
-      aFcntl[1] = "experimental_pragma_20251114";
-      assert( wrflag==1 || wrflag==2 );
-      aFcntl[2] = (wrflag==1 ? "1" : "2");
-      sqlite3OsFileControlHint(fd, SQLITE_FCNTL_PRAGMA, (void*)aFcntl);
-      sqlite3_free(aFcntl[0]);
-    }
-#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);
-    }
-#if defined(SQLITE_ENABLE_SETLK_TIMEOUT)
-    if( rc==SQLITE_BUSY_TIMEOUT ){
-      /* If a blocking lock timed out, break out of the loop here so that
-      ** the busy-handler is not invoked.  */
-      break;
-    }
-#endif
-  }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;
-}
-SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag, int *pSchemaVersion){
-  BtShared *pBt;
-  if( p->sharable
-   || p->inTrans==TRANS_NONE
-   || (p->inTrans==TRANS_READ && wrflag!=0)
-  ){
-    return btreeBeginTrans(p,wrflag,pSchemaVersion);
-  }
-  pBt = p->pBt;
-  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.
-    */
-    return sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
-  }else{
-    return SQLITE_OK;
-  }
-}
-
-#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; i<nCell; i++){
-    u8 *pCell = findCell(pPage, i);
-
-    ptrmapPutOvflPtr(pPage, pPage, pCell, &rc);
-
-    if( !pPage->leaf ){
-      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; i<nCell; i++){
-      u8 *pCell = findCell(pPage, i);
-      if( eType==PTRMAP_OVERFLOW1 ){
-        CellInfo info;
-        pPage->xParseCell(pPage, pCell, &info);
-        if( info.nLocal<info.nPayload ){
-          if( pCell+info.nSize > 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( iFreePg<iLastPg );
-
-      rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, bCommit);
-      releasePage(pLastPg);
-      if( rc!=SQLITE_OK ){
-        return rc;
-      }
-    }
-  }
-
-  if( bCommit==0 ){
-    do {
-      iLastPg--;
-    }while( iLastPg==PENDING_BYTE_PAGE(pBt) || PTRMAP_ISPAGE(pBt, iLastPg) );
-    pBt->bDoTruncate = 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) && nFin<PENDING_BYTE_PAGE(pBt) ){
-    nFin--;
-  }
-  while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){
-    nFin--;
-  }
-
-  return nFin;
-}
-
-/*
-** A write-transaction must be opened before calling this function.
-** It performs a single unit of work towards an incremental vacuum.
-**
-** If the incremental vacuum is finished after this function has run,
-** SQLITE_DONE is returned. If it is not finished, but no error occurred,
-** SQLITE_OK is returned. Otherwise an SQLite error code.
-*/
-SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *p){
-  int rc;
-  BtShared *pBt = p->pBt;
-
-  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<nFin || nFree>=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(iDb<db->nDb); 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( nFin<nOrig ){
-      rc = saveAllCursors(pBt, 0, 0);
-    }
-    for(iFree=nOrig; iFree>nFin && 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));
-}
-
-#ifdef SQLITE_DEBUG
-/*
-** Return true if and only if the Btree object will be automatically
-** closed with the BtCursor closes.  This is used within assert() statements
-** only.
-*/
-SQLITE_PRIVATE int sqlite3BtreeClosesWithCursor(
-  Btree *pBtree,       /* the btree object */
-  BtCursor *pCur       /* Corresponding cursor */
-){
-  BtShared *pBt = pBtree->pBt;
-  if( (pBt->openFlags & BTREE_SINGLE)==0 ) return 0;
-  if( pBt->pCursor!=pCur ) return 0;
-  if( pCur->pNext!=0 ) return 0;
-  if( pCur->pBtree!=pBtree ) return 0;
-  return 1;
-}
-#endif
-
-/*
-** 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;
-}
-
-/*
-** 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);
-}
-
-/*
-** 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 database.
-**
-** 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( (u64)offset+(u64)amt <= (u64)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( offset<pCur->info.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;
-        if( sqlite3FaultSim(413) ){
-          aNew = 0;
-        }else{
-          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{
-      /* Sanity check the validity of the overflow page cache */
-      assert( pCur->aOverflow[0]==nextPage
-           || pCur->aOverflow[0]==0
-           || CORRUPT_DB );
-      assert( pCur->aOverflow[0]!=0 || pCur->aOverflow[offset/ovflSize]==0 );
-
-      /* 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));
-          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->ix<pCur->pPage->nCell || CORRUPT_DB );
-  assert( pCur->info.nSize>0 );
-  assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
-  assert( pCur->info.pPayload<pCur->pPage->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){
-  int rc;
-  assert( cursorOwnsBtShared(pCur) );
-  assert( pCur->eState==CURSOR_VALID );
-  assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
-  assert( pCur->iPage>=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++;
-  rc = getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur->curPagerFlags);
-  assert( pCur->pPage!=0 || rc!=SQLITE_OK );
-  if( rc==SQLITE_OK
-   && (pCur->pPage->nCell<1 || pCur->pPage->intKey!=pCur->curIntKey)
-  ){
-    releasePage(pCur->pPage);
-    rc = SQLITE_CORRUPT_PGNO(newPgno);
-  }
-  if( rc ){
-    pCur->pPage = pCur->apPage[--pCur->iPage];
-  }
-  return rc;
-}
-
-#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,
-                        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->ix<pPage->nCell );
-    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!=0 && pCur->pPage->nCell==0) );
-    *pRes = 1;
-    rc = SQLITE_OK;
-  }
-  return rc;
-}
-
-/* Set *pRes to 1 (true) if the BTree pointed to by cursor pCur contains zero
-** rows of content.  Set *pRes to 0 (false) if the table contains content.
-** Return SQLITE_OK on success or some error code (ex: SQLITE_NOMEM) if
-** something goes wrong.
-*/
-SQLITE_PRIVATE int sqlite3BtreeIsEmpty(BtCursor *pCur, int *pRes){
-  int rc;
-
-  assert( cursorOwnsBtShared(pCur) );
-  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
-  if( NEVER(pCur->eState==CURSOR_VALID) ){
-    *pRes = 0;
-    return SQLITE_OK;
-  }
-  rc = moveToRoot(pCur);
-  if( rc==SQLITE_EMPTY ){
-    *pRes = 1;
-    rc = SQLITE_OK;
-  }else{
-    *pRes = 0;
-  }
-  return rc;
-}
-
-#ifdef SQLITE_DEBUG
-/* The cursors is CURSOR_VALID and has BTCF_AtLast set.  Verify that
-** this flags are true for a consistent database.
-**
-** This routine is is called from within assert() statements only.
-** It is an internal verification routine and does not appear in production
-** builds.
-*/
-static int cursorIsAtLastEntry(BtCursor *pCur){
-  int ii;
-  for(ii=0; ii<pCur->iPage; ii++){
-    if( pCur->aiIdx[ii]!=pCur->apPage[ii]->nCell ) return 0;
-  }
-  return pCur->ix==pCur->pPage->nCell-1 && pCur->pPage->leaf!=0;
-}
-#endif
-
-/* 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 ){
-    assert( cursorIsAtLastEntry(pCur) || CORRUPT_DB );
-    *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.nKey<intKey ){
-      if( (pCur->curFlags & BTCF_AtLast)!=0 ){
-        assert( cursorIsAtLastEntry(pCur) || CORRUPT_DB );
-        *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 slowly. */
-      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( nCellKey<intKey ){
-        lwr = idx+1;
-        if( lwr>upr ){ 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->ix<pCur->pPage->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 pPage against the key
-** pointing to by 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(
-  MemPage *pPage,
-  int idx,
-  UnpackedRecord *pIdxKey,
-  RecordCompare xRecordCompare
-){
-  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; i<pCur->iPage; i++){
-    MemPage *pPage = pCur->apPage[i];
-    if( pCur->aiIdx[i]<pPage->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->pPage,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->pPage, 0, pIdxKey, xRecordCompare)<=0
-     && pIdxKey->errCode==SQLITE_OK
-    ){
-      pCur->curFlags &= ~(BTCF_ValidOvfl|BTCF_AtLast);
-      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( (u64)nCell+(u64)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->ix<pCur->pPage->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));
-    }
-
-    /* This block is similar to an in-lined version of:
-    **
-    **    pCur->ix = (u16)lwr;
-    **    rc = moveToChild(pCur, chldPg);
-    **    if( rc ) break;
-    */
-    pCur->info.nSize = 0;
-    pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
-    if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
-      return SQLITE_CORRUPT_BKPT;
-    }
-    pCur->aiIdx[pCur->iPage] = (u16)lwr;
-    pCur->apPage[pCur->iPage] = pCur->pPage;
-    pCur->ix = 0;
-    pCur->iPage++;
-    rc = getAndInitPage(pCur->pBt, chldPg, &pCur->pPage, pCur->curPagerFlags);
-    if( rc==SQLITE_OK
-     && (pCur->pPage->nCell<1 || pCur->pPage->intKey!=pCur->curIntKey)
-    ){
-      releasePage(pCur->pPage);
-      rc = SQLITE_CORRUPT_PGNO(chldPg);
-    }
-    if( rc ){
-      pCur->pPage = pCur->apPage[--pCur->iPage];
-      break;
-    }
-    /*
-    ***** End of in-lined moveToChild() call */
- }
-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_IfSizeBetween
-  ** opcode and the OP_Count opcode with P3=1.  In either case,
-  ** the cursor will always be valid unless the btree is empty. */
-  if( pCur->eState!=CURSOR_VALID ) return 0;
-  if( NEVER(pCur->pPage->leaf==0) ) return -1;
-
-  n = pCur->pPage->nCell;
-  for(i=0; i<pCur->iPage; i++){
-    n *= pCur->apPage[i]->nCell+1;
-  }
-  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;
-  if( sqlite3FaultSim(412) ) pPage->isInit = 0;
-  if( !pPage->isInit ){
-    return SQLITE_CORRUPT_BKPT;
-  }
-  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 || (iTrunk<nearby && eMode==BTALLOC_LE))
-      ){
-        /* The list is being searched and this trunk page is the page
-        ** to allocate, regardless of whether it has leaves.
-        */
-        *pPgno = iTrunk;
-        *ppPage = pTrunk;
-        searchList = 0;
-        rc = sqlite3PagerWrite(pTrunk->pDbPage);
-        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; i<k; i++){
-              iPage = get4byte(&aData[8+i*4]);
-              if( iPage<=nearby ){
-                closest = i;
-                break;
-              }
-            }
-          }else{
-            int dist;
-            dist = sqlite3AbsInt32(get4byte(&aData[8]) - nearby);
-            for(i=1; i<k; i++){
-              int d2 = sqlite3AbsInt32(get4byte(&aData[8+i*4]) - nearby);
-              if( d2<dist ){
-                closest = i;
-                dist = d2;
-              }
-            }
-          }
-        }else{
-          closest = 0;
-        }
-
-        iPage = get4byte(&aData[8+closest*4]);
-        testcase( iPage==mxPage );
-        if( iPage>mxPage || iPage<2 ){
-          rc = SQLITE_CORRUPT_PGNO(iTrunk);
-          goto end_allocate_page;
-        }
-        testcase( iPage==mxPage );
-        if( !searchList
-         || (iPage==nearby || (iPage<nearby && eMode==BTALLOC_LE))
-        ){
-          int noContent;
-          *pPgno = iPage;
-          TRACE(("ALLOCATE: %u was leaf %u of %u on trunk %u"
-                 ": %u more free pages\n",
-                 *pPgno, closest+1, k, pTrunk->pgno, n-1));
-          rc = sqlite3PagerWrite(pTrunk->pDbPage);
-          if( rc ) goto end_allocate_page;
-          if( closest<k-1 ){
-            memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
-          }
-          put4byte(&aData[4], k-1);
-          noContent = !btreeGetHasContent(pBt, *pPgno)? PAGER_GET_NOCONTENT : 0;
-          rc = btreeGetUnusedPage(pBt, *pPgno, ppPage, noContent);
-          if( rc==SQLITE_OK ){
-            rc = sqlite3PagerWrite((*ppPage)->pDbPage);
-            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)<ovflPageSize)
-  );
-  while( nOvfl-- ){
-    Pgno iNext = 0;
-    MemPage *pOvfl = 0;
-    if( ovflPgno<2 || ovflPgno>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( pCell<pPage->aData || 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;
-      pPayload[nPayload] = 0;
-    }
-    *pnSize = n;
-    assert( nSrc<=nPayload );
-    testcase( nSrc<nPayload );
-    memcpy(pPayload, pSrc, nSrc);
-    memset(pPayload+nSrc, 0, nPayload-nSrc);
-    return SQLITE_OK;
-  }
-
-  /* If we reach this point, it means that some of the content will need
-  ** to spill onto overflow pages.
-  */
-  mn = pPage->minLocal;
-  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( pPayload<pPage->aData || 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( pPrior<pPage->aData || 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( idx<pPage->nCell );
-  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 && N<p->nCell );
-  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 && N<p->nCell );
-  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( nCell>0 );
-  assert( i<iEnd );
-  j = get2byte(&aData[hdr+5]);
-  if( j>(u32)usableSize ){ j = 0; }
-  memcpy(&pTmp[j], &aData[j], usableSize - j);
-
-  assert( pCArray->ixNx[NB*2-1]>i );
-  for(k=0; pCArray->ixNx[k]<=i; k++){}
-  pSrcEnd = pCArray->apEnd[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. */
-  assert( nCell < 10922 );
-  pPg->nCell = (u16)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 accommodate 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;
-  assert( pCArray->ixNx[NB*2-1]>i );
-  for(k=0; pCArray->ixNx[k]<=i ; k++){}
-  pEnd = pCArray->apEnd[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)<sz ) return 1;
-      pData -= sz;
-      pSlot = pData;
-    }
-    /* pSlot and pCArray->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; i<iEnd; i++){
-    u8 *pCell = pCArray->apCell[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; j++){
-        if( aOfst[j]==iAfter ){
-          aOfst[j] = iOfst;
-          break;
-        }else if( aAfter[j]==iOfst ){
-          aAfter[j] = iAfter;
-          break;
-        }
-      }
-      if( j>=nFree ){
-        if( nFree>=(int)(sizeof(aOfst)/sizeof(aOfst[0])) ){
-          for(j=0; j<nFree; j++){
-            freeSpace(pPg, aOfst[j], aAfter[j]-aOfst[j]);
-          }
-          nFree = 0;
-        }
-        aOfst[nFree] = iOfst;
-        aAfter[nFree] = iAfter;
-        if( &aData[iAfter]>pEnd ) return 0;
-        nFree++;
-      }
-      nRet++;
-    }
-  }
-  for(j=0; j<nFree; j++){
-    freeSpace(pPg, aOfst[j], aAfter[j]-aOfst[j]);
-  }
-  return nRet;
-}
-
-/*
-** pCArray contains pointers to and sizes of all cells in the page being
-** balanced.  The current page, pPg, has pPg->nCell 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( iOld<iNew ){
-    int nShift = pageFreeArray(pPg, iOld, iNew-iOld, pCArray);
-    if( NEVER(nShift>nCell) ) 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( pData<pBegin ) goto editpage_fail;
-  if( NEVER(pData>pPg->aDataEnd) ) goto editpage_fail;
-
-  /* Add cells to the start of the page */
-  if( iNew<iOld ){
-    int nAdd = MIN(nNew,iOld-iNew);
-    assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
-    assert( nAdd>=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; i<pPg->nOverflow; i++){
-    int iCell = (iOld + pPg->aiOvfl[i]) - iNew;
-    if( iCell>=0 && iCell<nNew ){
-      pCellptr = &pPg->aCellIdx[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;
-  }
-
-  assert( nNew < 10922 );
-  pPg->nCell = (u16)nNew;
-  pPg->nOverflow = 0;
-
-  put2byte(&aData[hdr+3], pPg->nCell);
-  put2byte(&aData[hdr+5], pData - aData);
-
-#ifdef SQLITE_DEBUG
-  for(i=0; i<nNew && !CORRUPT_DB; i++){
-    u8 *pCell = pCArray->apCell[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. */
-  if( nNew<1 ) return SQLITE_CORRUPT_BKPT;
-  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;
-    b.ixNx[NB*2-1] = 0x7fffffff;
-    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 the 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) && pCell<pStop );
-    pStop = &pCell[9];
-    while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
-
-    /* Insert the new divider cell into pParent. */
-    if( rc==SQLITE_OK ){
-      rc = insertCell(pParent, pParent->nCell, 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; i<nPage; i++){
-    Pgno n;
-    u8 e;
-    MemPage *pPage = apPage[i];
-    BtShared *pBt = pPage->pBt;
-    assert( pPage->isInit );
-
-    for(j=0; j<pPage->nCell; j++){
-      CellInfo info;
-      u8 *z;
-
-      z = findCell(pPage, j);
-      pPage->xParseCell(pPage, z, &info);
-      if( info.nLocal<info.nPayload ){
-        Pgno ovfl = get4byte(&z[info.nSize-4]);
-        ptrmapGet(pBt, ovfl, &e, &n);
-        assert( n==pPage->pgno && 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[] */
-  u64 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));
-  assert( sizeof(b) - sizeof(b.ixNx) == offsetof(CellArray,ixNx) );
-  memset(&b, 0, sizeof(b)-sizeof(b.ixNx[0]));
-  b.ixNx[NB*2-1] = 0x7fffffff;
-  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);
-    }
-    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; i<nOld; i++){
-    MemPage *pOld = apOld[i];
-    int limit = pOld->nCell;
-    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_PAGE(pOld);
-      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(limit<pOld->aiOvfl[0]) ){
-        rc = SQLITE_CORRUPT_PAGE(pOld);
-        goto balance_cleanup;
-      }
-      limit = pOld->aiOvfl[0];
-      for(j=0; j<limit; j++){
-        b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
-        piCell += 2;
-        b.nCell++;
-      }
-      for(k=0; k<pOld->nOverflow; 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( piCell<piEnd ){
-      assert( b.nCell<nMaxCells );
-      b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
-      piCell += 2;
-      b.nCell++;
-    }
-    assert( (b.nCell-nCellAtStart)==(pOld->nCell+pOld->nOverflow) );
-
-    cntOld[i] = b.nCell;
-    if( i<nOld-1 && !leafData){
-      u16 sz = (u16)szNew[i];
-      u8 *pTemp;
-      assert( b.nCell<nMaxCells );
-      b.szCell[b.nCell] = sz;
-      pTemp = &aSpace1[iSpace1];
-      iSpace1 += sz;
-      assert( sz<=pBt->maxLocal+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; i<nOld; i++, k++){
-    MemPage *p = apOld[i];
-    b.apEnd[k] = p->aDataEnd;
-    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; j<p->nOverflow; j++){
-      szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]);
-    }
-    cntNew[i] = cntOld[i];
-  }
-  k = nOld;
-  for(i=0; i<k; i++){
-    int sz;
-    while( szNew[i]>usableSpace ){
-      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]<b.nCell ){
-          sz = 2 + cachedCellSize(&b, cntNew[i]);
-        }else{
-          sz = 0;
-        }
-      }
-      szNew[i+1] += sz;
-      cntNew[i]--;
-    }
-    while( cntNew[i]<b.nCell ){
-      sz = 2 + cachedCellSize(&b, cntNew[i]);
-      if( szNew[i]+sz>usableSpace ) break;
-      szNew[i] += sz;
-      cntNew[i]++;
-      if( !leafData ){
-        if( cntNew[i]<b.nCell ){
-          sz = 2 + cachedCellSize(&b, cntNew[i]);
-        }else{
-          sz = 0;
-        }
-      }
-      szNew[i+1] -= sz;
-    }
-    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<nMaxCells );
-      assert( r<nMaxCells );
-      szR = cachedCellSize(&b, r);
-      szD = b.szCell[d];
-      if( szRight!=0
-       && (bBulk || szRight+szD+2 > 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 following
-  ** 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; i<k; i++){
-    MemPage *pNew;
-    if( i<nOld ){
-      pNew = apNew[i] = apOld[i];
-      apOld[i] = 0;
-      rc = sqlite3PagerWrite(pNew->pDbPage);
-      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; i<nNew; i++){
-    aPgno[i] = apNew[i]->pgno;
-    assert( apNew[i]->pDbPage->flags & PGHDR_WRITEABLE );
-    assert( apNew[i]->pDbPage->flags & PGHDR_DIRTY );
-  }
-  for(i=0; i<nNew-1; i++){
-    int iB = i;
-    for(j=i+1; j<nNew; j++){
-      if( apNew[j]->pgno < 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;
-    if( nNew>nOld ){
-      pOld = apNew[nOld-1];
-    }else{
-      pOld = 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<b.nCell; i++){
-      u8 *pCell = b.apCell[i];
-      while( i==cntOldNext ){
-        iOld++;
-        assert( iOld<nNew || iOld<nOld );
-        assert( iOld>=0 && iOld<NB );
-        pOld = iOld<nNew ? apNew[iOld] : apOld[iOld];
-        cntOldNext += pOld->nCell + 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; i<nNew-1; i++){
-    u8 *pCell;
-    u8 *pTemp;
-    int sz;
-    u8 *pSrcEnd;
-    MemPage *pNew = apNew[i];
-    j = cntNew[i];
-
-    assert( j<nMaxCells );
-    assert( b.apCell[j]!=0 );
-    pCell = b.apCell[j];
-    sz = b.szCell[j] + leafCorrection;
-    pTemp = &aOvflSpace[iOvflSpace];
-    if( !pNew->leaf ){
-      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 );
-    assert( b.ixNx[NB*2-1]>j );
-    for(k=0; b.ixNx[k]<=j; k++){}
-    pSrcEnd = b.apEnd[k];
-    if( SQLITE_OVERFLOW(pSrcEnd, pCell, pCell+sz) ){
-      rc = SQLITE_CORRUPT_BKPT;
-      goto balance_cleanup;
-    }
-    rc = insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno);
-    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<nNew; i++){
-    int iPg = i<0 ? -i : i;
-    assert( iPg>=0 && iPg<nNew );
-    assert( iPg>=1 || i>=0 );
-    assert( iPg<ArraySize(cntOld) );
-    if( abDone[iPg] ) continue;         /* Skip pages already processed */
-    if( i>=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 = iPg<nOld ? (cntOld[iPg-1] + !leafData) : b.nCell;
-        iNew = cntNew[iPg-1] + !leafData;
-        nNewCell = cntNew[iPg] - iNew;
-      }
-
-      rc = editPage(apNew[iPg], iOld, iNew, nNewCell, &b);
-      if( rc ) goto balance_cleanup;
-      abDone[iPg]++;
-      apNew[iPg]->nFree = 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; i<nNew; i++){
-      u32 key = get4byte(&apNew[i]->aData[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; i<nOld; i++){
-    freePage(apOld[i], &rc);
-  }
-
-#if 0
-  if( ISAUTOVACUUM(pBt) && rc==SQLITE_OK && apNew[0]->isInit ){
-    /* 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; i<nOld; i++){
-    releasePage(apOld[i]);
-  }
-  for(i=0; i<nNew; i++){
-    releasePage(apNew[i]);
-  }
-
-  return rc;
-}
-
-
-/*
-** This function is called when the root page of a b-tree structure is
-** overfull (has one or more overflow pages).
-**
-** A new child page is allocated and the contents of the current root
-** page, including overflow cells, are copied into the child. The root
-** page is then overwritten to make it an empty page with the right-child
-** pointer pointing to the new page.
-**
-** Before returning, all pointer-map entries corresponding to pages
-** that the new child-page now contains pointers to are updated. The
-** entry corresponding to the new right-child pointer of the root
-** page is also updated.
-**
-** If successful, *ppChild is set to contain a reference to the child
-** page and SQLITE_OK is returned. In this case the caller is required
-** to call releasePage() on *ppChild exactly once. If an error occurs,
-** an error code is returned and *ppChild is set to 0.
-*/
-static int balance_deeper(MemPage *pRoot, MemPage **ppChild){
-  int rc;                        /* Return value from subprocedures */
-  MemPage *pChild = 0;           /* Pointer to a new child page */
-  Pgno pgnoChild = 0;            /* Page number of the new child page */
-  BtShared *pBt = pRoot->pBt;    /* 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_PAGE(pCur->pPage);
-    }
-  }
-  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_PAGE(pPage);
-    }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 ){
-    /* Overwriting with zeros */
-    int i;
-    for(i=0; i<iAmt && pDest[i]==0; i++){}
-    if( i<iAmt ){
-      int rc = sqlite3PagerWrite(pPage->pDbPage);
-      if( rc ) return rc;
-      memset(pDest + i, 0, iAmt - i);
-    }
-  }else{
-    if( nData<iAmt ){
-      /* Mixed read data and zeros at the end.  Make a recursive call
-      ** to write the zeros then fall through to write the real data */
-      int rc = btreeOverwriteContent(pPage, pDest+nData, pX, iOffset+nData,
-                                 iAmt-nData);
-      if( rc ) return rc;
-      iAmt = nData;
-    }
-    if( memcmp(pDest, ((u8*)pX->pData) + 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 overwrite */
-  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.nLocal<nTotal );  /* pCur is an overflow cell */
-
-  /* Overwrite the local portion first */
-  rc = btreeOverwriteContent(pPage, pCur->info.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_PAGE(pPage);
-    }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( iOffset<nTotal );
-  return SQLITE_OK;
-}
-
-/*
-** Overwrite the cell that cursor pCur is pointing to with fresh content
-** contained in pX.
-*/
-static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
-  int nTotal = pX->nData + 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_PAGE(pPage);
-  }
-  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_PGNO(pCur->pgnoRoot);
-    }
-  }
-
-  /* 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 = (int)pX->nKey;  assert( pX->nKey<=0x7fffffff );
-        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_PAGE(pPage);
-    }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;
-      newCell[3] = 0;
-    }
-    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_PAGE(pPage);
-    }
-    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) || szNew<pPage->minLocal)
-    ){
-      /* 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_PAGE(pPage);
-      }
-      if( oldCell+szNew > pPage->aDataEnd ){
-        return SQLITE_CORRUPT_PAGE(pPage);
-      }
-      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|BTCF_ValidOvfl);
-  }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|BTCF_ValidOvfl);
-    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++) = (u8)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_PAGE(pSrc->pPage);
-  }
-  nRem = pSrc->info.nPayload;
-  if( nIn==nRem && nIn<pDest->pPage->maxLocal ){
-    memcpy(aOut, aIn, nIn);
-    pBt->nPreformatSize = nIn + (int)(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 = (int)nOut + (int)(aOut - pBt->pTmpSpace);
-    if( nOut<pSrc->info.nPayload ){
-      pPgnoOut = &aOut[nOut];
-      pBt->nPreformatSize += 4;
-    }
-
-    if( nRem>nIn ){
-      if( aIn+nIn+4>pSrc->pPage->aDataEnd ){
-        return SQLITE_CORRUPT_PAGE(pSrc->pPage);
-      }
-      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 = 0;  /* Prevent harmless static-analyzer warning */
-        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_PGNO(pCur->pgnoRoot);
-    }
-  }
-  assert( pCur->eState==CURSOR_VALID );
-
-  iCellDepth = pCur->iPage;
-  iCellIdx = pCur->ix;
-  pPage = pCur->pPage;
-  if( pPage->nCell<=iCellIdx ){
-    return SQLITE_CORRUPT_PAGE(pPage);
-  }
-  pCell = findCell(pPage, iCellIdx);
-  if( pPage->nFree<0 && btreeComputeFreeSpace(pPage) ){
-    return SQLITE_CORRUPT_PAGE(pPage);
-  }
-  if( pCell<&pPage->aCellIdx[pPage->nCell] ){
-    return SQLITE_CORRUPT_PAGE(pPage);
-  }
-
-  /* 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( iCellDepth<pCur->iPage-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_PAGE(pLeaf);
-    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 flags 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_PGNO(pgnoRoot);
-    }
-    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_PGNO(pgnoRoot);
-      }
-      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_PGNO(pgno);
-  }
-  rc = getAndInitPage(pBt, pgno, &pPage, 0);
-  if( rc ) return rc;
-  if( (pBt->openFlags & BTREE_SINGLE)==0
-   && sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1))
-  ){
-    rc = SQLITE_CORRUPT_PAGE(pPage);
-    goto cleardatabasepage_out;
-  }
-  hdr = pPage->hdrOffset;
-  for(i=0; i<pPage->nCell; 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_PGNO(iTable);
-  }
-
-  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( pCheck->aPgRef!=0 );
-  assert( iPg<=pCheck->nCkPage && 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( pCheck->aPgRef!=0 );
-  assert( iPg<=pCheck->nCkPage && 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->nCkPage || 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]<aHeap[j] ) break;
-    x = aHeap[i];
-    aHeap[i] = aHeap[j];
-    aHeap[j] = x;
-    i = j;
-  }
-  return 1;
-}
-
-#ifndef SQLITE_OMIT_INTEGRITY_CHECK
-/*
-** Do various sanity checks on a single page of a tree.  Return
-** the tree depth.  Root pages return 0.  Parents of root pages
-** return 1, and so forth.
-**
-** These checks are done:
-**
-**      1.  Make sure that cells and freeblocks do not overlap
-**          but combine to completely cover the page.
-**      2.  Make sure integer cell keys are in order.
-**      3.  Check the integrity of overflow pages.
-**      4.  Recursively call checkTreePage on all children.
-**      5.  Verify that the depth of all children is the same.
-*/
-static int checkTreePage(
-  IntegrityCk *pCheck,  /* Context for the sanity check */
-  Pgno iPage,           /* Page number of the page to check */
-  i64 *piMinKey,        /* Write minimum integer primary key here */
-  i64 maxKey            /* Error if integer primary key greater than this */
-){
-  MemPage *pPage = 0;      /* The page being analyzed */
-  int i;                   /* Loop counter */
-  int rc;                  /* Result code from subroutine call */
-  int depth = -1, d2;      /* Depth of a subtree */
-  int pgno;                /* Page number */
-  int nFrag;               /* Number of fragmented bytes on the page */
-  int hdr;                 /* Offset to the page header */
-  int cellStart;           /* Offset to the start of the cell pointer array */
-  int nCell;               /* Number of cells */
-  int doCoverageCheck = 1; /* True if cell coverage checking should be done */
-  int keyCanBeEqual = 1;   /* True if IPK can be equal to maxKey
-                           ** False if IPK must be strictly less than maxKey */
-  u8 *data;                /* Page content */
-  u8 *pCell;               /* Cell content */
-  u8 *pCellIdx;            /* Next element of the cell pointer array */
-  BtShared *pBt;           /* The BtShared object that owns pPage */
-  u32 pc;                  /* Address of a cell */
-  u32 usableSize;          /* Usable size of the page */
-  u32 contentOffset;       /* Offset to the start of the cell content area */
-  u32 *heap = 0;           /* Min-heap used for checking cell coverage */
-  u32 x, prev = 0;         /* Next and previous entry on the min-heap */
-  const char *saved_zPfx = pCheck->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->v1 = iPage;
-  if( (rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0 ){
-    checkAppendMsg(pCheck,
-       "unable to get the page. error code=%d", rc);
-    if( rc==SQLITE_IOERR_NOMEM ) pCheck->rc = SQLITE_NOMEM;
-    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 );
-  if( pPage->leaf || pPage->intKey==0 ){
-    pCheck->nRow += 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( pc<contentOffset || pc>usableSize-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));
-      }
-    }
-    assert( heap!=0 );
-    /* 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 */
-  Mem *aCnt,    /* Memory cells to write counts for each tree to */
-  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 );
-  assert( aCnt!=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.nCkPage = btreePagecount(sCheck.pBt);
-  sCheck.mxErr = mxErr;
-  sqlite3StrAccumInit(&sCheck.errMsg, 0, zErr, sizeof(zErr), SQLITE_MAX_LENGTH);
-  sCheck.errMsg.printfFlags = SQLITE_PRINTF_INTERNAL;
-  if( sCheck.nCkPage==0 ){
-    goto integrity_ck_cleanup;
-  }
-
-  sCheck.aPgRef = sqlite3MallocZero((sCheck.nCkPage / 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.nCkPage ) 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)i<nRoot; i++) if( mx<aRoot[i] ) mx = aRoot[i];
-      mxInHdr = get4byte(&pBt->pPage1->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)i<nRoot && sCheck.mxErr; i++){
-    sCheck.nRow = 0;
-    if( aRoot[i] ){
-      i64 notUsed;
-#ifndef SQLITE_OMIT_AUTOVACUUM
-      if( pBt->autoVacuum && aRoot[i]>1 && !bPartial ){
-        checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0);
-      }
-#endif
-      sCheck.v0 = aRoot[i];
-      checkTreePage(&sCheck, aRoot[i], &notUsed, LARGEST_INT64);
-    }
-    sqlite3MemSetArrayInt64(aCnt, i, sCheck.nRow);
-  }
-  pBt->db->flags = savedDbFlags;
-
-  /* Make sure every page in the file is referenced
-  */
-  if( !bPartial ){
-    for(i=1; i<=sCheck.nCkPage && 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;
-  assert( nBytes==0 || nBytes==sizeof(Schema) );
-  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;
-  UNUSED_PARAMETER(p);  /* only used in DEBUG builds */
-  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
-
-  /* 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;
-  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 );
-
-  /* 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 && iOff<iEnd; iOff+=nDestPgsz){
-    DbPage *pDestPg = 0;
-    Pgno iDest = (Pgno)(iOff/nDestPgsz)+1;
-    if( iDest==PENDING_BYTE_PAGE(p->pDest->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 || ii<nPage) && p->iNext<=(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( pgszSrc<pgszDest ){
-          int ratio = pgszDest/pgszSrc;
-          nDestTruncate = (nSrcPage+ratio-1)/ratio;
-          if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
-            nDestTruncate--;
-          }
-        }else{
-          nDestTruncate = nSrcPage * (pgszSrc/pgszDest);
-        }
-        assert( nDestTruncate>0 );
-
-        if( pgszSrc<pgszDest ){
-          /* If the source page-size is smaller than the destination page-size,
-          ** two extra things may need to happen:
-          **
-          **   * The destination may need to be truncated, and
-          **
-          **   * Data stored on the pages immediately following the
-          **     pending-byte page in the source database may need to be
-          **     copied into the destination database.
-          */
-          const i64 iSize = (i64)pgszSrc * (i64)nSrcPage;
-          sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
-          Pgno iPg;
-          int nDstPage;
-          i64 iOff;
-          i64 iEnd;
-
-          assert( pFile );
-          assert( nDestTruncate==0
-              || (i64)nDestTruncate*(i64)pgszDest >= 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 && iOff<iEnd;
-            iOff+=pgszSrc
-          ){
-            PgHdr *pSrcPg = 0;
-            const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
-            rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg, 0);
-            if( rc==SQLITE_OK ){
-              u8 *zData = sqlite3PagerGetData(pSrcPg);
-              rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
-            }
-            sqlite3PagerUnref(pSrcPg);
-          }
-          if( rc==SQLITE_OK ){
-            rc = backupTruncateFile(pFile, iSize);
-          }
-
-          /* Sync the database file to disk. */
-          if( rc==SQLITE_OK ){
-            rc = sqlite3PagerSync(pDestPager, 0);
-          }
-        }else{
-          sqlite3PagerTruncateImage(pDestPager, nDestTruncate);
-          rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0);
-        }
-
-        /* Finish committing the transaction to the destination database. */
-        if( SQLITE_OK==rc
-         && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 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) && iPage<p->iNext ){
-      /* 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;
-
-  /* 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|MEM_IntReal) ){
-#if GCC_VERSION>=7000000 && GCC_VERSION<15000000 && defined(__i386__)
-    /* Work-around for GCC bug or bugs:
-    ** https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96270
-    ** https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114659
-    ** The problem appears to be fixed in GCC 15 */
-    i64 x;
-    assert( (MEM_Str&~p->flags)*4==sizeof(x) );
-    memcpy(&x, (char*)&p->u, (MEM_Str&~p->flags)*4);
-    p->n = sqlite3Int64ToText(x, zBuf);
-#else
-    p->n = sqlite3Int64ToText(p->u.i, zBuf);
-#endif
-    if( p->flags & MEM_IntReal ){
-      memcpy(zBuf+p->n,".0", 3);
-      p->n += 2;
-    }
-  }else{
-    sqlite3StrAccumInit(&acc, 0, zBuf, sz, 0);
-    sqlite3_str_appendf(&acc, "%!.*g",
-         (p->db ? p->db->nFpDigit : 17), 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://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;
-  if( p->db==0 ){
-    return 1;  /* db->nFpDigit required to validate p->z[] */
-  }
-  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->szMalloc<szNew ){
-    return sqlite3VdbeMemGrow(pMem, szNew, 0);
-  }
-  assert( (pMem->flags & MEM_Dyn)==0 );
-  pMem->z = pMem->zMalloc;
-  pMem->flags &= (MEM_Null|MEM_Int|MEM_Real|MEM_IntReal);
-  return SQLITE_OK;
-}
-
-/*
-** If pMem is already a string, detect if it is a zero-terminated
-** string, or make it into one if possible, and mark it as such.
-**
-** This is an optimization.  Correct operation continues even if
-** this routine is a no-op.
-**
-** Return true if the strig is zero-terminated after this routine is
-** called and false if it is not.
-*/
-SQLITE_PRIVATE int sqlite3VdbeMemZeroTerminateIfAble(Mem *pMem){
-  if( (pMem->flags & (MEM_Str|MEM_Term|MEM_Ephem|MEM_Static))!=MEM_Str ){
-    /* pMem must be a string, and it cannot be an ephemeral or static string */
-    return 0;
-  }
-  if( pMem->enc!=SQLITE_UTF8 ) return 0;
-  assert( pMem->z!=0 );
-  if( pMem->flags & MEM_Dyn ){
-    if( pMem->xDel==sqlite3_free
-     && sqlite3_msize(pMem->z) >= (u64)(pMem->n+1)
-    ){
-      pMem->z[pMem->n] = 0;
-      pMem->flags |= MEM_Term;
-      return 1;
-    }
-    if( pMem->xDel==sqlite3RCStrUnref ){
-      /* Blindly assume that all RCStr objects are zero-terminated */
-      pMem->flags |= MEM_Term;
-      return 1;
-    }
-  }else if( pMem->szMalloc >= pMem->n+1 ){
-    pMem->z[pMem->n] = 0;
-    pMem->flags |= MEM_Term;
-    return 1;
-  }
-  return 0;
-}
-
-/*
-** 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);
-}
-
-/*
-** 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 sqlite3RealToI64(pMem->u.r);
-  }else if( (flags & (MEM_Str|MEM_Blob))!=0 && pMem->z!=0 ){
-    return memIntValue(pMem);
-  }else{
-    return 0;
-  }
-}
-
-/*
-** This routine implements the uncommon and slower path for
-** sqlite3MemRealValueRC() that has to deal with input strings
-** that are not UTF8 or that are not zero-terminated.  It is
-** broken out into a separate no-inline routine so that the
-** main sqlite3MemRealValueRC() routine can avoid unnecessary
-** stack pushes.
-**
-** A text->float translation of pMem->z is written into *pValue.
-**
-** Result code invariants:
-**
-**    rc==0         =>   ERROR: Input string not well-formed, or OOM
-**    rc<0          =>   Some prefix of the input is well-formed
-**    rc>0          =>   All of the input is well-formed
-**    (rc&2)==0     =>   The number is expressed as an integer, with no
-**                       decimal point or eNNN suffix.
-*/
-static SQLITE_NOINLINE int sqlite3MemRealValueRCSlowPath(
-  Mem *pMem,
-  double *pValue
-){
-  int rc = SQLITE_OK;
-  *pValue = 0.0;
-  if( pMem->enc==SQLITE_UTF8 ){
-    char *zCopy = sqlite3DbStrNDup(pMem->db, pMem->z, pMem->n);
-    if( zCopy ){
-      rc = sqlite3AtoF(zCopy, pValue);
-      sqlite3DbFree(pMem->db, zCopy);
-    }
-    return rc;
-  }else{
-    int n, i, j;
-    char *zCopy;
-    const char *z;
-
-    n = pMem->n & ~1;
-    zCopy = sqlite3DbMallocRaw(pMem->db, n/2 + 2);
-    if( zCopy ){
-      z = pMem->z;
-      if( pMem->enc==SQLITE_UTF16LE ){
-        for(i=j=0; i<n-1; i+=2, j++){
-          zCopy[j] = z[i];
-          if( z[i+1]!=0 ) break;
-        }
-      }else{
-        for(i=j=0; i<n-1; i+=2, j++){
-          if( z[i]!=0 ) break;
-          zCopy[j] = z[i+1];
-        }
-      }
-      assert( j<=n/2 );
-      zCopy[j] = 0;
-      rc = sqlite3AtoF(zCopy, pValue);
-      if( i<n ) rc = -100;
-      sqlite3DbFree(pMem->db, zCopy);
-    }
-    return rc;
-  }
-}
-
-/*
-** Invoke sqlite3AtoF() on the text value of pMem.  Write the
-** translation of the text input into *pValue.
-**
-** The caller must ensure that pMem->db!=0 and that pMem is in
-** mode MEM_Str or MEM_Blob.
-**
-** Result code invariants:
-**
-**    rc==0         =>   ERROR: Input string not well-formed, or OOM
-**    rc<0          =>   Some prefix of the input is well-formed
-**    rc>0          =>   All of the input is well-formed
-**    (rc&2)==0     =>   The number is expressed as an integer, with no
-**                       decimal point or eNNN suffix.
-*/
-SQLITE_PRIVATE int sqlite3MemRealValueRC(Mem *pMem, double *pValue){
-  testcase( pMem->db==0 );
-  assert( pMem->flags & (MEM_Str|MEM_Blob) );
-  if( pMem->z==0 ){
-    *pValue = 0.0;
-    return 0;
-  }else if( pMem->enc==SQLITE_UTF8
-   && ((pMem->flags & MEM_Term)!=0 || sqlite3VdbeMemZeroTerminateIfAble(pMem))
-  ){
-    return sqlite3AtoF(pMem->z, pValue);
-  }else if( pMem->n==0 ){
-    *pValue = 0.0;
-    return 0;
-  }else{
-    return sqlite3MemRealValueRCSlowPath(pMem, pValue);
-  }
-}
-
-/*
-** This routine acts as a bridge from sqlite3VdbeRealValue() to
-** sqlite3VdbeRealValueRC, allowing sqlite3VdbeRealValue() to avoid
-** stuffing values onto the stack.
-*/
-static SQLITE_NOINLINE double sqlite3MemRealValueNoRC(Mem *pMem){
-  double r;
-  (void)sqlite3MemRealValueRC(pMem, &r);
-  return r;
-}
-
-/*
-** 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.
-*/
-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 sqlite3MemRealValueNoRC(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 = sqlite3RealToI64(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 && ix<LARGEST_INT64 ){
-      pMem->u.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<-9223372036854774784.0 ) return SMALLEST_INT64;
-  if( r>+9223372036854774784.0 ) 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 = sqlite3MemRealValueRC(pMem, &pMem->u.r);
-    if( ((rc&2)==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<2)
-     || 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: {
-      int rc;
-      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;
-      rc = sqlite3VdbeChangeEncoding(pMem, encoding);
-      if( rc ) return rc;
-      sqlite3VdbeMemZeroTerminateIfAble(pMem);
-    }
-  }
-  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;
-  }
-}
-
-/*
-** Set the iIdx'th entry of array aMem[] to contain integer value val.
-*/
-SQLITE_PRIVATE void sqlite3MemSetArrayInt64(sqlite3_value *aMem, int iIdx, i64 val){
-  sqlite3VdbeMemSetInt64(&aMem[iIdx], val);
-}
-
-/* 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;
-  if( pMem->bScopy ){
-    for(i=1, pX=pVdbe->aMem+1; i<pVdbe->nMem; 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->bScopy = 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;
-    }
-    assert( pMem->z!=0 );
-    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;
-}
-
-/* Like sqlite3VdbeMemSetStr() except:
-**
-**   enc is always SQLITE_UTF8
-**   pMem->db is always non-NULL
-*/
-SQLITE_PRIVATE int sqlite3VdbeMemSetText(
-  Mem *pMem,          /* Memory cell to set to string value */
-  const char *z,      /* String pointer */
-  i64 n,              /* Bytes in string, or negative */
-  void (*xDel)(void*) /* Destructor function */
-){
-  i64 nByte = n;      /* New value for pMem->n */
-  u16 flags;
-
-  assert( pMem!=0 );
-  assert( pMem->db!=0 );
-  assert( sqlite3_mutex_held(pMem->db->mutex) );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
-
-  /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
-  if( !z ){
-    sqlite3VdbeMemSetNull(pMem);
-    return SQLITE_OK;
-  }
-
-  if( nByte<0 ){
-    nByte = strlen(z);
-    flags = MEM_Str|MEM_Term;
-  }else{
-    flags = MEM_Str;
-  }
-  if( nByte>(i64)pMem->db->aLimit[SQLITE_LIMIT_LENGTH] ){
-    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 + 1;
-    testcase( nAlloc==31 );
-    testcase( nAlloc==32 );
-    if( sqlite3VdbeMemClearAndResize(pMem, (int)MAX(nAlloc,32)) ){
-      return SQLITE_NOMEM_BKPT;
-    }
-    assert( pMem->z!=0 );
-    memcpy(pMem->z, z, nByte);
-    pMem->z[nByte] = 0;
-  }else{
-    sqlite3VdbeMemRelease(pMem);
-    pMem->z = (char *)z;
-    if( xDel==SQLITE_DYNAMIC ){
-      pMem->zMalloc = pMem->z;
-      pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
-      pMem->xDel = 0;
-    }else if( xDel==SQLITE_STATIC ){
-      pMem->xDel = xDel;
-      flags |= MEM_Static;
-    }else{
-      pMem->xDel = xDel;
-      flags |= MEM_Dyn;
-    }
-  }
-  pMem->flags = flags;
-  pMem->n = (int)(nByte & 0x7fffffff);
-  pMem->enc = SQLITE_UTF8;
-  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;
-  testcase( amt==SQLITE_MAX_ALLOCATION_SIZE-1 );
-  testcase( amt==SQLITE_MAX_ALLOCATION_SIZE );
-  if( amt>=SQLITE_MAX_ALLOCATION_SIZE ){
-    return SQLITE_NOMEM_BKPT;
-  }
-  if( (u64)amt + (u64)offset > (u64)sqlite3BtreeMaxRecordSize(pCur) ){
-    return SQLITE_CORRUPT_BKPT;
-  }
-  if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+1)) ){
-    rc = sqlite3BtreePayload(pCur, offset, amt, pMem->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);
-}
-
-/* Return true if sqlit3_value object pVal is a string or blob value
-** that uses the destructor specified in the second argument.
-**
-** TODO:  Maybe someday promote this interface into a published API so
-** that third-party extensions can get access to it?
-*/
-SQLITE_PRIVATE int sqlite3ValueIsOfClass(const sqlite3_value *pVal, void(*xFree)(void*)){
-  if( ALWAYS(pVal!=0)
-   && ALWAYS((pVal->flags & (MEM_Str|MEM_Blob))!=0)
-   && (pVal->flags & MEM_Dyn)!=0
-   && pVal->xDel==xFree
-  ){
-    return 1;
-  }else{
-    return 0;
-  }
-}
-
-/*
-** 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 */
-      i64 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; i<nCol; i++){
-            pRec->aMem[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;
-    sqlite3VdbeMemSetNull(&pRec->aMem[p->iVal]);
-    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;                   /* Number of function arguments */
-  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|SQLITE_FUNC_RUNONLY))!=0
-  ){
-    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; i<nVal; i++){
-      rc = sqlite3Stat4ValueFromExpr(pCtx->pParse, pList->a[i].pExpr, 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; i<nVal; i++){
-      sqlite3ValueFree(apVal[i]);
-    }
-    sqlite3DbFreeNN(db, apVal);
-  }
-
-  *ppVal = pVal;
-  return rc;
-}
-#else
-# define valueFromFunction(a,b,c,d,e,f) SQLITE_OK
-#endif /* defined(SQLITE_ENABLE_STAT4) */
-
-/*
-** Extract a value from the supplied expression in the manner described
-** above sqlite3ValueFromExpr(). Allocate the sqlite3_value object
-** using valueNew().
-**
-** If pCtx is NULL and an error occurs after the sqlite3_value object
-** has been allocated, it is freed before returning. Or, if pCtx is not
-** NULL, it is assumed that the caller will free any allocated object
-** in all cases.
-*/
-static int valueFromExpr(
-  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 */
-  struct ValueNewStat4Ctx *pCtx   /* Second argument for valueNew() */
-){
-  int op;
-  char *zVal = 0;
-  sqlite3_value *pVal = 0;
-  int negInt = 1;
-  const char *zNeg = "";
-  int rc = SQLITE_OK;
-
-  assert( pExpr!=0 );
-  while( (op = pExpr->op)==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. Except - do not do this
-  ** for hexadecimal literals.  */
-  if( op==TK_UMINUS ){
-    Expr *pLeft = pExpr->pLeft;
-    if( (pLeft->op==TK_INTEGER || pLeft->op==TK_FLOAT) ){
-      if( ExprHasProperty(pLeft, EP_IntValue)
-       || pLeft->u.zToken[0]!='0' || (pLeft->u.zToken[1] & ~0x20)!='X'
-      ){
-        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{
-      i64 iVal;
-      if( op==TK_INTEGER && 0==sqlite3DecOrHexToI64(pExpr->u.zToken, &iVal) ){
-        sqlite3VdbeMemSetInt64(pVal, iVal*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( affinity==SQLITE_AFF_BLOB ){
-      if( op==TK_FLOAT ){
-        assert( pVal && pVal->z && pVal->flags==(MEM_Str|MEM_Term) );
-        sqlite3AtoF(pVal->z, &pVal->u.r);
-        pVal->flags = MEM_Real;
-      }else if( op==TK_INTEGER ){
-        /* This case is required by -9223372036854775808 and other strings
-        ** that look like integers but cannot be handled by the
-        ** sqlite3DecOrHexToI64() call above.  */
-        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;
-      sqlite3ValueApplyAffinity(pVal, affinity, enc);
-    }
-  }
-
-  *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; i<nElem; i++){
-      sqlite3_value *pVal = 0;
-      Expr *pElem = (pExpr ? sqlite3VectorFieldSubexpr(pExpr, i) : 0);
-      u8 aff = sqlite3IndexColumnAffinity(pParse->db, 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.
-**
-** If the buffer does not contain a well-formed record, this routine may
-** read several bytes past the end of the buffer. Callers must therefore
-** ensure that any buffer which may contain a corrupt record is padded
-** with at least 8 bytes of addressable memory.
-*/
-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 */
-  u32 nHdr;                       /* Size of the header in the record */
-  u32 iHdr;                       /* Next unread header byte */
-  i64 iField;                     /* Next unread data byte */
-  u32 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>(u32)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; i<nCol; i++){
-      sqlite3VdbeMemRelease(&aMem[i]);
-    }
-    sqlite3KeyInfoUnref(pRec->pKeyInfo);
-    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 u64 n = 0;
-  (void)pc;
-  (void)pOp;
-  n++;
-  if( n==LARGEST_UINT64 ) abort(); /* so that n is used, preventing a warning */
-}
-#endif
-
-/*
-** Slow paths for sqlite3VdbeAddOp3() and sqlite3VdbeAddOp4Int() for the
-** unusual case when we need to increase the size of the Vdbe.aOp[] array
-** before adding the new opcode.
-*/
-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);
-}
-static SQLITE_NOINLINE int addOp4IntSlow(
-  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;
-}
-
-
-/*
-** 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, p4  Operands
-*/
-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);
-}
-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;
-
-  /* Replicate this logic in sqlite3VdbeAddOp4Int()
-  ** vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv   */
-#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
-  /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  ** Replicate in sqlite3VdbeAddOp4Int() */
-
-  return i;
-}
-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 i;
-  VdbeOp *pOp;
-
-  i = p->nOp;
-  if( p->nOpAlloc<=i ){
-    return addOp4IntSlow(p, op, p1, p2, p3, p4);
-  }
-  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.i = p4;
-  pOp->p4type = P4_INT32;
-
-  /* Replicate this logic in sqlite3VdbeAddOp3()
-  ** vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv   */
-#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
-  /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  ** Replicate in sqlite3VdbeAddOp3() */
-
-  return i;
-}
-
-/* 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 addr;
-  sqlite3_context *pCtx;
-  assert( v );
-  pCtx = sqlite3DbMallocRawNN(pParse->db, SZ_CONTEXT(nArg));
-  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, -1, -1, 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; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
-  sqlite3MayAbort(p->pParse);
-}
-
-/* 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; i<nNewSize; i++) p->aLabel[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(i<p->nOp); 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->iAddr<nOp );
-
-    pRet = &aOp[p->iAddr];
-    p->iAddr++;
-    if( p->iAddr==nOp ){
-      p->iSub++;
-      p->iAddr = 0;
-    }
-
-    if( pRet->p4type==P4_SUBPROGRAM ){
-      i64 nByte = (1+(u64)p->nSub)*sizeof(SubProgram*);
-      int j;
-      for(j=0; j<p->nSub; 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 the xUpdate/xFilter
-**     methods of any virtual table and store that value in *pMaxVtabArgs.
-**
-** (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 *pMaxVtabArgs){
-  int nMaxVtabArgs = *pMaxVtabArgs;
-  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 terminates 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>nMaxVtabArgs ) nMaxVtabArgs = pOp->p2;
-          break;
-        }
-        case OP_VFilter: {
-          int n;
-          /* The instruction immediately prior to VFilter will be an
-          ** OP_Integer that sets the "argc" value for the VFilter.  See
-          ** the code where OP_VFilter is generated at tag-20250207a. */
-          assert( (pOp - p->aOp) >= 3 );
-          assert( pOp[-1].opcode==OP_Integer );
-          assert( pOp[-1].p2==pOp->p3+1 );
-          n = pOp[-1].p1;
-          if( n>nMaxVtabArgs ) nMaxVtabArgs = 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)];
-          }
-
-          /* OPFLG_JUMP opcodes never have P2==0, though OPFLG_JUMP0 opcodes
-          ** might */
-          assert( pOp->p2>0
-                  || (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP0)!=0 );
-
-          /* Jumps never go off the end of the bytecode array */
-          assert( pOp->p2<p->nOp
-                  || (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)==0 );
-          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;
-  *pMaxVtabArgs = nMaxVtabArgs;
-  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( iLast<v->nOp );
-  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( pOp->p3==20230325 && pOp->opcode==OP_NotNull ){
-        /* This is a deliberately taken illegal branch.  tag-20230325-2 */
-        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( iDest<iFirst || iDest>iLast ){
-        int j = iDest;
-        for(; j<v->nOp; 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; i<p->nOp; 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; i<nOp; i++, aOp++, pOut++){
-    pOut->opcode = 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) ){
-    i64 nByte = (1+(i64)p->nScan) * 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; ii<ArraySize(pScan->aAddrRange); 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 ){
-      if( addrLoop>0 ) pScan->addrLoop = addrLoop;
-      if( addrVisit>0 ) 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);
-#ifdef SQLITE_DEBUG
-  while( pOp->opcode==OP_ReleaseReg ) pOp--;
-#endif
-  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 ephemeral, 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;
-    }
-    case P4_TABLEREF: {
-      if( db->pnBytesFreed==0 ) sqlite3DeleteTable(db, (Table*)p4);
-      break;
-    }
-    case P4_SUBRTNSIG: {
-      SubrtnSig *pSig = (SubrtnSig*)p4;
-      sqlite3DbFree(db, pSig->zAff);
-      sqlite3DbFree(db, pSig);
-      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 && addr<p->nOp );
-  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 ){
-    assert( pOp->p4type > P4_FREE_IF_LE );
-    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( addr<p->nOp );
-  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 && addr<p->nOp) || 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; j<pKeyInfo->nKeyField; 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;
-    }
-    case P4_INDEX: {
-      zP4 = pOp->p4.pIdx->zName;
-      break;
-    }
-    case P4_SUBRTNSIG: {
-      SubrtnSig *pSig = pOp->p4.pSubrtnSig;
-      sqlite3_str_appendf(&x, "subrtnsig:%d,%s", pSig->selId, pSig->zAff);
-      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 && i<p->db->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; i<nDb; i++){
-    if( i!=1 && DbMaskTest(p->lockMask,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; i<nDb; i++){
-    if( i!=1 && DbMaskTest(p->lockMask,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){
-  assert( db!=0 );
-  if( N>0 ){
-    do{
-      p->flags = flags;
-      p->db = db;
-      p->szMalloc = 0;
-#ifdef SQLITE_DEBUG
-      p->pScopyFrom = 0;
-      p->bScopy = 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;
-    assert( db!=0 );
-    if( db->pnBytesFreed ){
-      do{
-        if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
-      }while( (++p)<pEnd );
-      return;
-    }
-    do{
-      assert( (&p[1])==pEnd || p[0].db==p[1].db );
-      assert( sqlite3VdbeCheckMemInvariants(p) );
-
-      /* This block is really an inlined version of sqlite3VdbeMemRelease()
-      ** that takes advantage of the fact that the memory cell value is
-      ** being set to NULL after releasing any dynamic resources.
-      **
-      ** The justification for duplicating code is that according to
-      ** callgrind, this causes a certain test case to hit the CPU 4.7
-      ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
-      ** sqlite3MemRelease() were called from here. With -O2, this jumps
-      ** to 6.6 percent. The test case is inserting 1000 rows into a table
-      ** with no indexes using a single prepared INSERT statement, bind()
-      ** and reset(). Inserts are grouped into a transaction.
-      */
-      testcase( 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)<pEnd );
-  }
-}
-
-#ifdef SQLITE_DEBUG
-/*
-** Verify that pFrame is a valid VdbeFrame pointer.  Return true if it is
-** and false if something is wrong.
-**
-** This routine is intended for use inside of assert() statements only.
-*/
-SQLITE_PRIVATE int sqlite3VdbeFrameIsValid(VdbeFrame *pFrame){
-  if( pFrame->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; i<nSub; i++){
-      nRow += apSub[i]->nOp;
-    }
-  }
-  iPc = *piPc;
-  while(1){  /* Loop exits via break */
-    i = iPc++;
-    if( i>=nRow ){
-      p->rc = SQLITE_OK;
-      rc = SQLITE_DONE;
-      break;
-    }
-    if( i<p->nOp ){
-      /* 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( i<apSub[j]->nOp || j+1<nSub );
-      }
-      aOp = apSub[j]->aOp;
-    }
-
-    /* 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; j<nSub; j++){
-        if( apSub[j]==aOp[i].p4.pProgram ) break;
-      }
-      if( j==nSub ){
-        p->rc = 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; i<p->nChildCsr; 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);
-        assert( 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);
-        assert( 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; i<p->nMem; 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; i<p->nOp; 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;                      /* Max number args to xFilter or xUpdate */
-  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 );
-  assert( pParse->db==p->db );
-  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 ){
-    if( nMem<10 ) nMem = 10;
-    p->explain = pParse->explain;
-    p->nResColumn = 12 - 4*p->explain;
-  }
-  p->expired = 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*));
-    }
-  }
-#ifdef SQLITE_DEBUG
-  p->napArg = nArg;
-#endif
-
-  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);
-}
-static SQLITE_NOINLINE void freeCursorWithCache(Vdbe *p, VdbeCursor *pCx){
-  VdbeTxtBlbCache *pCache = pCx->pCache;
-  assert( pCx->colCache );
-  pCx->colCache = 0;
-  pCx->pCache = 0;
-  if( pCache->pCValue ){
-    sqlite3RCStrUnref(pCache->pCValue);
-    pCache->pCValue = 0;
-  }
-  sqlite3DbFree(p->db, pCache);
-  sqlite3VdbeFreeCursorNN(p, pCx);
-}
-SQLITE_PRIVATE void sqlite3VdbeFreeCursorNN(Vdbe *p, VdbeCursor *pCx){
-  if( pCx->colCache ){
-    freeCursorWithCache(p, pCx);
-    return;
-  }
-  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; i<p->nCursor; 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->nResAlloc ){
-    releaseMemArray(p->aColName, p->nResAlloc*COLNAME_N);
-    sqlite3DbFree(db, p->aColName);
-  }
-  n = nResColumn*COLNAME_N;
-  p->nResColumn = p->nResAlloc = (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( idx<p->nResAlloc );
-  assert( var<COLNAME_N );
-  if( p->db->mallocFailed ){
-    assert( !zName || xDel!=SQLITE_DYNAMIC );
-    return SQLITE_NOMEM_BKPT;
-  }
-  assert( p->aColName!=0 );
-  pColName = &(p->aColName[idx+var*p->nResAlloc]);
-  rc = sqlite3VdbeMemSetText(pColName, zName, -1, 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 && i<db->nDb; 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
-  ){
-    if( needXcommit ){
-      for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
-        Btree *pBt = db->aDb[i].pBt;
-        if( sqlite3BtreeTxnState(pBt)>=SQLITE_TXN_WRITE ){
-          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 && i<db->nDb; i++){
-      Btree *pBt = db->aDb[i].pBt;
-      int txn = sqlite3BtreeTxnState(pBt);
-      if( txn!=SQLITE_TXN_NONE ){
-        assert( needXcommit || txn==SQLITE_TXN_READ );
-        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; i<db->nDb; 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 && i<db->nDb; 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; i<db->nDb; 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; i<db->nDb; 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;
-}
-
-
-/*
-** These functions are 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 foreign key constraint violations
-** return an error code. Otherwise, SQLITE_OK.
-**
-** If there are outstanding FK violations and this function returns
-** non-zero, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY
-** and write an error message to it.
-*/
-#ifndef SQLITE_OMIT_FOREIGN_KEY
-static SQLITE_NOINLINE int vdbeFkError(Vdbe *p){
-  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;
-}
-SQLITE_PRIVATE int sqlite3VdbeCheckFkImmediate(Vdbe *p){
-  if( p->nFkConstraint==0 ) return SQLITE_OK;
-  return vdbeFkError(p);
-}
-SQLITE_PRIVATE int sqlite3VdbeCheckFkDeferred(Vdbe *p){
-  sqlite3 *db = p->db;
-  if( (db->nDeferredCons+db->nDeferredImmCons)==0 ) return SQLITE_OK;
-  return vdbeFkError(p);
-}
-#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) ){
-      (void)sqlite3VdbeCheckFkImmediate(p);
-    }
-
-    /* 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 = sqlite3VdbeCheckFkDeferred(p);
-        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 ){
-          sqlite3SystemError(db, rc);
-          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; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
-  if( p->aMem ){
-    for(i=0; i<p->nMem; 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; i<p->nOp; 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; i<p->nOp; 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_STATE<VDBE_READY_STATE );
-  if( p->eVdbeState>=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->nResAlloc*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; i<p->nScan; 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;
-  }
-}
-static int serialGet7(
-  const unsigned char *buf,     /* Buffer to deserialize from */
-  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;
-  assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
-  swapMixedEndianFloat(x);
-  memcpy(&pMem->u.r, &x, sizeof(x));
-  if( IsNaN(x) ){
-    pMem->flags = MEM_Null;
-    return 1;
-  }
-  pMem->flags = MEM_Real;
-  return 0;
-}
-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;
-}
-/*
-** Allocate sufficient space for an UnpackedRecord structure large enough
-** to hold a decoded index record for pKeyInfo.
-**
-** The space is allocated using sqlite3DbMallocRaw().  If an OOM error
-** occurs, NULL is returned.
-*/
-SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(
-  KeyInfo *pKeyInfo               /* Description of the record */
-){
-  UnpackedRecord *p;              /* Unpacked record to return */
-  u64 nByte;                      /* Number of bytes required for *p */
-  assert( sizeof(UnpackedRecord) + sizeof(Mem)*65536 < 0x7fffffff );
-  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))];
-  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(
-  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;
-  KeyInfo *pKeyInfo = p->pKeyInfo;
-
-  p->default_rc = 0;
-  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
-  idx = getVarint32(aKey, szHdr);
-  d = szHdr;
-  u = 0;
-  while( idx<szHdr && d<=(u32)nKey ){
-    u32 serial_type;
-
-    idx += getVarint32(&aKey[idx], serial_type);
-    pMem->enc = 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);
-    if( (++u)>=p->nField ) break;
-    pMem++;
-  }
-  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-(u<p->nField));
-  }
-  testcase( u == pKeyInfo->nKeyField + 1 );
-  testcase( u < pKeyInfo->nKeyField + 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
-    ){
-      if( serial_type1>=1
-       && serial_type1<=7
-       && d1+(u64)sqlite3VdbeSerialTypeLen(serial_type1)<=(u64)nKey1+8
-       && CORRUPT_DB
-      ){
-        return 1;  /* corrupt record not detected by
-                   ** sqlite3VdbeRecordCompareWithSkip().  Return true
-                   ** to avoid firing the assert() */
-      }
-      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( idx1<szHdr1 && i<pPKey2->nField );
-
-  /* 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( idx<szHdr ){
-    idx += getVarint32(aKey+idx, notUsed);
-    nField++;
-  }
-  assert( nField <= pKeyInfo->nAllField );
-}
-#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 SQLITE_NOINLINE int vdbeCompareMemStringWithEncodingChange(
-  const Mem *pMem1,
-  const Mem *pMem2,
-  const CollSeq *pColl,
-  u8 *prcErr                      /* If an OOM occurs, set to SQLITE_NOMEM */
-){
-  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;
-}
-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{
-    return vdbeCompareMemStringWithEncodingChange(pMem1,pMem2,pColl,prcErr);
-  }
-}
-
-/*
-** 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; i<n; i++){
-    if( z[i] ) return 0;
-  }
-  return 1;
-}
-
-/*
-** Compare two blobs.  Return negative, zero, or positive if the first
-** is less than, equal to, or greater than the second, respectively.
-** If one blob is a prefix of the other, then the shorter is the lessor.
-*/
-SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){
-  int c;
-  int n1 = pB1->n;
-  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;
-}
-
-/* The following two functions are used only within testcase() to prove
-** test coverage.  These functions do no exist for production builds.
-** We must use separate SQLITE_NOINLINE functions here, since otherwise
-** optimizer code movement causes gcov to become very confused.
-*/
-#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
-static int SQLITE_NOINLINE doubleLt(double a, double b){ return a<b; }
-static int SQLITE_NOINLINE doubleEq(double a, double b){ return a==b; }
-#endif
-
-/*
-** 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( sqlite3IsNaN(r) ){
-    /* SQLite considers NaN to be a NULL. And all integer values are greater
-    ** than NULL */
-    return 1;
-  }else{
-    i64 y;
-    if( r<-9223372036854775808.0 ) return +1;
-    if( r>=9223372036854775808.0 ) return -1;
-    y = (i64)r;
-    if( i<y ) return -1;
-    if( i>y ) return +1;
-    testcase( doubleLt(((double)i),r) );
-    testcase( doubleLt(r,((double)i)) );
-    testcase( doubleEq(r,((double)i)) );
-    return (((double)i)<r) ? -1 : (((double)i)>r);
-  }
-}
-
-/*
-** 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 ){
-        serialGet7(&aKey1[d1], &mem1);
-        rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r);
-      }else{
-        i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]);
-        i64 rhs = pRhs->u.i;
-        if( lhs<rhs ){
-          rc = -1;
-        }else if( lhs>rhs ){
-          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 numeric values are.  */
-        rc = serial_type==10 ? -1 : +1;
-      }else if( serial_type==0 ){
-        rc = -1;
-      }else{
-        if( serial_type==7 ){
-          if( serialGet7(&aKey1[d1], &mem1) ){
-            rc = -1;  /* mem1 is a NaN */
-          }else if( mem1.u.r<pRhs->u.r ){
-            rc = -1;
-          }else if( mem1.u.r>pRhs->u.r ){
-            rc = +1;
-          }else{
-            assert( rc==0 );
-          }
-        }else{
-          sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
-          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];
-      if( serial_type==0
-       || serial_type==10
-       || (serial_type==7 && serialGet7(&aKey1[d1], &mem1)!=0)
-      ){
-        assert( rc==0 );
-      }else{
-        rc = 1;
-      }
-    }
-
-    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( v<lhs ){
-    res = pPKey2->r2;
-  }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.  */
-  assert( p->pKeyInfo->aSortFlags!=0 );
-  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.n<szHdr+lenRowid) ){
-    goto idx_rowid_corruption;
-  }
-
-  /* Fetch the integer off the end of the index record */
-  sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
-  *rowid = v.u.i;
-  sqlite3VdbeMemReleaseMalloc(&m);
-  return SQLITE_OK;
-
-  /* Jump here if database corruption is detected after m has been
-  ** allocated.  Free the m object and return SQLITE_CORRUPT. */
-idx_rowid_corruption:
-  testcase( m.szMalloc!=0 );
-  sqlite3VdbeMemReleaseMalloc(&m);
-  return SQLITE_CORRUPT_BKPT;
-}
-
-/*
-** Compare the key of the index entry that cursor pC is pointing to against
-** the key string in pUnpacked.  Write into *pRes a number
-** that is negative, zero, or positive if pC is less than, equal to,
-** or greater than pUnpacked.  Return SQLITE_OK on success.
-**
-** pUnpacked is either created without a rowid or is truncated so that it
-** omits the rowid at the end.  The rowid at the end of the index entry
-** is ignored as well.  Hence, this routine only compares the prefixes
-** of the keys prior to the final rowid, not the entire key.
-*/
-SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(
-  sqlite3 *db,                     /* Database connection */
-  VdbeCursor *pC,                  /* The cursor to compare against */
-  UnpackedRecord *pUnpacked,       /* Unpacked version of key */
-  int *res                         /* Write the comparison result here */
-){
-  i64 nCellKey = 0;
-  int rc;
-  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 ){
-    *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
-         || (v->db->mDbFlags & DBFLAG_InternalFunc)!=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
-       || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 );
-  if( iVar>=32 ){
-    v->expmask |= 0x80000000;
-  }else{
-    v->expmask |= ((u32)1 << (iVar-1));
-  }
-}
-
-/*
-** Helper function for vdbeIsMatchingIndexKey(). Return true if column
-** iCol should be ignored when comparing a record with a record from
-** an index on disk. The field should be ignored if:
-**
-**   * the corresponding bit in mask is set, and
-**   * either:
-**       - bIntegrity is false, or
-**       - the two Mem values are both real values that differ by
-**         BTREE_ULPDISTORTION or fewer ULPs.
-*/
-static int vdbeSkipField(
-  Bitmask mask,                   /* Mask of indexed expression fields */
-  int iCol,                       /* Column of index being considered */
-  Mem *pMem1,                     /* Expected index value */
-  Mem *pMem2,                     /* Actual indexed value */
-  int bIntegrity                  /* True if running PRAGMA integrity_check */
-){
-#define BTREE_ULPDISTORTION 2
-  if( iCol>=BMS || (mask & MASKBIT(iCol))==0 ) return 0;
-  if( bIntegrity==0 ) return 1;
-  if( (pMem1->flags & MEM_Real) && (pMem2->flags & MEM_Real) ){
-    u64 m1, m2;
-    memcpy(&m1,&pMem1->u.r,8);
-    memcpy(&m2,&pMem2->u.r,8);
-    if( (m1<m2 ? m2-m1 : m1-m2) <= BTREE_ULPDISTORTION ){
-      return 1;
-    }
-  }
-  return 0;
-}
-
-/*
-** This function compares the unpacked record with the current key that
-** cursor pCur points to. If bInt is false, all fields for which the
-** corresponding bit in parameter "mask" is set are ignored. Or, if
-** bInt is true, then a difference of BTREE_ULPDISTORTION or fewer ULPs
-** in real values is overlooked for fields with the corresponding bit
-** set in mask.
-**
-** Return the usual less than zero, zero, or greater than zero if the
-** remaining fields of the cursor cursor key are less than, equal to or
-** greater than those in (*p).
-*/
-static int vdbeIsMatchingIndexKey(
-  BtCursor *pCur,            /* Cursor open on index */
-  int bInt,                  /* True for integrity_check-style search */
-  Bitmask mask,              /* Mask of columns to skip */
-  UnpackedRecord *p,         /* Index key being deleted */
-  int *piRes                 /* 0 for a match, non-zero for not a match */
-){
-  u8 *aRec = 0;
-  u32 nRec = 0;
-  Mem mem;
-  int rc = SQLITE_OK;
-
-  memset(&mem, 0, sizeof(mem));
-  mem.enc = p->pKeyInfo->enc;
-  mem.db = p->pKeyInfo->db;
-  nRec = sqlite3BtreePayloadSize(pCur);
-  if( nRec>0x7fffffff ){
-    return SQLITE_CORRUPT_BKPT;
-  }
-
-  /* Allocate 5 extra bytes at the end of the buffer. This allows the
-  ** getVarint32() call below to read slightly past the end of the buffer
-  ** if the record is corrupt. */
-  aRec = sqlite3MallocZero(nRec+5);
-  if( aRec==0 ){
-    rc = SQLITE_NOMEM_BKPT;
-  }else{
-    rc = sqlite3BtreePayload(pCur, 0, nRec, aRec);
-  }
-
-  if( rc==SQLITE_OK ){
-    u32 szHdr = 0;                /* Size of record header in bytes */
-    u32 idxHdr = 0;               /* Current index in header */
-
-    idxHdr = getVarint32(aRec, szHdr);
-    if( szHdr>98307 ){
-      rc = SQLITE_CORRUPT;
-    }else{
-      int res = 0;                /* Result of this function call */
-      u32 idxRec = szHdr;         /* Index of next field in record body */
-      int ii = 0;                 /* Iterator variable */
-
-      int nCol = p->pKeyInfo->nAllField;
-      for(ii=0; ii<nCol && rc==SQLITE_OK; ii++){
-        u32 iSerial = 0;
-        int nSerial = 0;
-
-        if( idxHdr>=szHdr ){
-          rc = SQLITE_CORRUPT_BKPT;
-          break;
-        }
-        idxHdr += getVarint32(&aRec[idxHdr], iSerial);
-        nSerial = sqlite3VdbeSerialTypeLen(iSerial);
-        if( (idxRec+nSerial)>nRec ){
-          rc = SQLITE_CORRUPT_BKPT;
-        }else{
-          sqlite3VdbeSerialGet(&aRec[idxRec], iSerial, &mem);
-          if( vdbeSkipField(mask, ii, &p->aMem[ii], &mem, bInt)==0 ){
-            res = sqlite3MemCompare(&mem, &p->aMem[ii], p->pKeyInfo->aColl[ii]);
-            if( res!=0 ) break;
-          }
-        }
-        idxRec += sqlite3VdbeSerialTypeLen(iSerial);
-      }
-
-      *piRes = res;
-    }
-  }
-
-  sqlite3_free(aRec);
-  return rc;
-}
-
-/*
-** This is called when the record in (*p) should be found in the index
-** opened by cursor pCur, but was not. This may happen as part of a DELETE
-** operation or an integrity check.
-**
-** One reason that an exact match was not found may be the EIIB bug - that
-** a text-to-float conversion may have caused a real value in record (*p)
-** to be slightly different from its counterpart on disk. This function
-** attempts to find the right index record. If it does find the right
-** record, it leaves *pCur pointing to it and sets (*pRes) to 0 before
-** returning. Otherwise, (*pRes) is set to non-zero and an SQLite error
-** code returned.
-**
-** The algorithm used to find the correct record is:
-**
-**   * Scan up to BTREE_FDK_RANGE entries either side of the current entry.
-**     If parameter bIntegrity is false, then all fields that are indexed
-**     expressions or virtual table columns are omitted from the comparison.
-**     If bIntegrity is true, then small differences in real values in
-**     such fields are overlooked, but they are not omitted from the comparison
-**     altogether.
-**
-**   * If the above fails to find an entry and bIntegrity is false, search
-**     the entire index.
-*/
-SQLITE_PRIVATE int sqlite3VdbeFindIndexKey(
-  BtCursor *pCur,
-  Index *pIdx,
-  UnpackedRecord *p,
-  int *pRes,
-  int bIntegrity
-){
-#define BTREE_FDK_RANGE 10
-  int nStep = 0;
-  int res = 1;
-  int rc = SQLITE_OK;
-  int ii = 0;
-
-  /* Calculate a mask based on the first 64 columns of the index. The mask
-  ** bit is set if the corresponding index field is either an expression
-  ** or a virtual column of the table.  */
-  Bitmask mask = 0;
-  for(ii=0; ii<MIN(pIdx->nColumn, BMS); ii++){
-    int iCol = pIdx->aiColumn[ii];
-    if( (iCol==XN_EXPR)
-     || (iCol>=0 && (pIdx->pTable->aCol[iCol].colFlags & COLFLAG_VIRTUAL))
-    ){
-      mask |= MASKBIT(ii);
-    }
-  }
-
-  /* If the mask is 0 at this point, then the index contains no expressions
-  ** or virtual columns. So do not search for a match - return so that the
-  ** caller may declare the db corrupt immediately. Or, if mask is non-zero,
-  ** proceed.  */
-  if( mask!=0 ){
-
-    /* Move the cursor back BTREE_FDK_RANGE entries. If this hits an EOF,
-    ** position the cursor at the first entry in the index and set nStep
-    ** to -1 so that the first loop below scans the entire index. Otherwise,
-    ** set nStep to BTREE_FDK_RANGE*2 so that the first loop below scans
-    ** just that many entries.  */
-    for(ii=0; sqlite3BtreeEof(pCur)==0 && ii<BTREE_FDK_RANGE; ii++){
-      rc = sqlite3BtreePrevious(pCur, 0);
-    }
-    if( rc==SQLITE_DONE ){
-      rc = sqlite3BtreeFirst(pCur, &res);
-      nStep = -1;
-    }else{
-      nStep = BTREE_FDK_RANGE*2;
-    }
-
-    /* This loop runs at most twice to search for a key with matching PK
-    ** fields in the index. The second iteration always searches the entire
-    ** index. The first iteration searches nStep entries starting with the
-    ** current cursor entry if (nStep>=0), or the entire index if (nStep<0).  */
-    while( sqlite3BtreeCursorIsValidNN(pCur) ){
-      for(ii=0; rc==SQLITE_OK && (ii<nStep || nStep<0); ii++){
-        rc = vdbeIsMatchingIndexKey(pCur, bIntegrity, mask, p, &res);
-        if( res==0 || rc!=SQLITE_OK ) break;
-        rc = sqlite3BtreeNext(pCur, 0);
-      }
-      if( rc==SQLITE_DONE ){
-        rc = SQLITE_OK;
-        assert( res!=0 );
-      }
-      if( nStep<0 || rc!=SQLITE_OK || res==0 || bIntegrity ) break;
-
-      /* The first, non-exhaustive, search failed to find an entry with
-      ** matching PK fields. So restart for an exhaustive search of the
-      ** entire index.  */
-      nStep = -1;
-      rc = sqlite3BtreeFirst(pCur, &res);
-    }
-  }
-
-  *pRes = res;
-  return rc;
-}
-
-#ifndef SQLITE_OMIT_DATETIME_FUNCS
-/*
-** 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;
-}
-#endif /* SQLITE_OMIT_DATETIME_FUNCS */
-
-#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; i<nField; i++){
-      Mem *pMem = &p->aMem[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;
-#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.pKeyinfo = (KeyInfo*)&preupdate.uKey;
-  preupdate.pKeyinfo->db = db;
-  preupdate.pKeyinfo->enc = ENC(db);
-  preupdate.pKeyinfo->nKeyField = pTab->nCol;
-  preupdate.pKeyinfo->aSortFlags = 0; /* Indicate .aColl, .nAllField uninit */
-  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.pKeyinfo->nKeyField+1,preupdate.pUnpacked);
-  vdbeFreeUnpacked(db, preupdate.pKeyinfo->nKeyField+1,preupdate.pNewUnpacked);
-  sqlite3VdbeMemRelease(&preupdate.oldipk);
-  if( preupdate.aNew ){
-    int i;
-    for(i=0; i<pCsr->nField; i++){
-      sqlite3VdbeMemRelease(&preupdate.aNew[i]);
-    }
-    sqlite3DbNNFreeNN(db, preupdate.aNew);
-  }
-  if( preupdate.apDflt ){
-    int i;
-    for(i=0; i<pTab->nCol; i++){
-      sqlite3ValueFree(preupdate.apDflt[i]);
-    }
-    sqlite3DbFree(db, preupdate.apDflt);
-  }
-}
-#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
-
-#ifdef SQLITE_ENABLE_PERCENTILE
-/*
-** Return the name of an SQL function associated with the sqlite3_context.
-*/
-SQLITE_PRIVATE const char *sqlite3VdbeFuncName(const sqlite3_context *pCtx){
-  assert( pCtx!=0 );
-  assert( pCtx->pFunc!=0 );
-  return pCtx->pFunc->zName;
-}
-#endif /* SQLITE_ENABLE_PERCENTILE */
-
-/************** 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->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;
-#endif
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pStmt==0 ){
-    return SQLITE_MISUSE_BKPT;
-  }
-#endif
-#if SQLITE_THREADSAFE
-  mutex = p->db->mutex;
-#endif
-  sqlite3_mutex_enter(mutex);
-  for(i=0; i<p->nVar; 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 if 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;
-  if( enc==SQLITE_UTF8 ){
-    rc = sqlite3VdbeMemSetText(pOut, z, n, xDel);
-  }else if( enc==SQLITE_UTF8_ZT ){
-    /* It is usually considered improper to assert() on an input. However,
-    ** the following assert() is checking for inputs that are documented
-    ** to result in undefined behavior. */
-    assert( z==0
-         || n<0
-         || n>pOut->db->aLimit[SQLITE_LIMIT_LENGTH]
-         || z[n]==0
-    );
-    rc = sqlite3VdbeMemSetText(pOut, z, n, xDel);
-    pOut->flags |= MEM_Term;
-  }else{
-    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 not NULL */
-){
-  assert( xDel!=SQLITE_DYNAMIC );
-  if( xDel==0 ){
-    /* noop */
-  }else if( xDel==SQLITE_TRANSIENT ){
-    /* noop */
-  }else{
-    xDel((void*)p);
-  }
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx!=0 ){
-    sqlite3_result_error_toobig(pCtx);
-  }
-#else
-  assert( pCtx!=0 );
-  sqlite3_result_error_toobig(pCtx);
-#endif
-  return SQLITE_TOOBIG;
-}
-SQLITE_API void sqlite3_result_blob(
-  sqlite3_context *pCtx,
-  const void *z,
-  int n,
-  void (*xDel)(void *)
-){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 || n<0 ){
-    invokeValueDestructor(z, xDel, pCtx);
-    return;
-  }
-#endif
-  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( xDel!=SQLITE_DYNAMIC );
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ){
-    invokeValueDestructor(z, xDel, 0);
-    return;
-  }
-#endif
-  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
-  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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
-  sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
-}
-SQLITE_API void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
-  sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
-}
-SQLITE_API void sqlite3_result_null(sqlite3_context *pCtx){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  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;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ){
-    invokeValueDestructor(pPtr, xDestructor, 0);
-    return;
-  }
-#endif
-  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;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-#if defined(SQLITE_STRICT_SUBTYPE) && SQLITE_STRICT_SUBTYPE+0!=0
-  if( pCtx->pFunc!=0
-   && (pCtx->pFunc->funcFlags & SQLITE_RESULT_SUBTYPE)==0
-  ){
-    char zErr[200];
-    sqlite3_snprintf(sizeof(zErr), zErr,
-                     "misuse of sqlite3_result_subtype() by %s()",
-                     pCtx->pFunc->zName);
-    sqlite3_result_error(pCtx, zErr, -1);
-    return;
-  }
-#endif /* SQLITE_STRICT_SUBTYPE */
-  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 *)
-){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ){
-    invokeValueDestructor(z, xDel, 0);
-    return;
-  }
-#endif
-  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
-){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ){
-    invokeValueDestructor(z, xDel, 0);
-    return;
-  }
-#endif
-  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
-  assert( xDel!=SQLITE_DYNAMIC );
-  if( enc!=SQLITE_UTF8 && enc!=SQLITE_UTF8_ZT ){
-    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);
-    sqlite3VdbeMemZeroTerminateIfAble(pCtx->pOut);
-  }
-}
-#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;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-  if( pValue==0 ){
-    sqlite3_result_null(pCtx);
-    return;
-  }
-#endif
-  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;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return SQLITE_MISUSE_BKPT;
-#endif
-  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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  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; i<db->nDb; 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);
-      }
-    }
-  }
-#else
-  UNUSED_PARAMETER(db);
-#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 + 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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( p==0 ) return 0;
-#endif
-  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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( p==0 ) return 0;
-#else
-  assert( p && p->pOut );
-#endif
-  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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( p==0 ) return 0;
-#else
-  assert( p );
-#endif
-  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
-** preceded 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_BKPT;
-  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,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;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return 0;
-#endif
-  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;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pCtx==0 ) return;
-#endif
-  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;
-  if( pVm==0 ) return 0;
-  return pVm->nResColumn;
-}
-
-/*
-** 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,
-        /* .bScopy     = */ 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 && i<pVm->nResColumn && 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_double()
-**     sqlite3_column_bytes()
-**     sqlite3_column_bytes16()
-**     sqlite3_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;
-}
-
-/*
-** Column names appropriate for EXPLAIN or EXPLAIN QUERY PLAN.
-*/
-static const char * const azExplainColNames8[] = {
-   "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",  /* EXPLAIN */
-   "id", "parent", "notused", "detail"                         /* EQP */
-};
-static const u16 azExplainColNames16data[] = {
-  /*   0 */  'a', 'd', 'd', 'r',                0,
-  /*   5 */  'o', 'p', 'c', 'o', 'd', 'e',      0,
-  /*  12 */  'p', '1',                          0,
-  /*  15 */  'p', '2',                          0,
-  /*  18 */  'p', '3',                          0,
-  /*  21 */  'p', '4',                          0,
-  /*  24 */  'p', '5',                          0,
-  /*  27 */  'c', 'o', 'm', 'm', 'e', 'n', 't', 0,
-  /*  35 */  'i', 'd',                          0,
-  /*  38 */  'p', 'a', 'r', 'e', 'n', 't',      0,
-  /*  45 */  'n', 'o', 't', 'u', 's', 'e', 'd', 0,
-  /*  53 */  'd', 'e', 't', 'a', 'i', 'l',      0
-};
-static const u8 iExplainColNames16[] = {
-  0, 5, 12, 15, 18, 21, 24, 27,
-  35, 38, 45, 53
-};
-
-/*
-** 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
-  if( N<0 ) return 0;
-  ret = 0;
-  p = (Vdbe *)pStmt;
-  db = p->db;
-  assert( db!=0 );
-  sqlite3_mutex_enter(db->mutex);
-
-  if( p->explain ){
-    if( useType>0 ) goto columnName_end;
-    n = p->explain==1 ? 8 : 4;
-    if( N>=n ) goto columnName_end;
-    if( useUtf16 ){
-      int i = iExplainColNames16[N + 8*p->explain - 8];
-      ret = (void*)&azExplainColNames16data[i];
-    }else{
-      ret = (void*)azExplainColNames8[N + 8*p->explain - 8];
-    }
-    goto columnName_end;
-  }
-  n = p->nResColumn;
-  if( N<n ){
-    u8 prior_mallocFailed = db->mallocFailed;
-    N += useType*n;
-#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;
-    }
-  }
-columnName_end:
-  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. Otherwise 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.
-**
-** (tag-20240917-01) If  vdbeUnbind(p,(u32)(i-1))  returns SQLITE_OK,
-** that means all of the the following will be true:
-**
-**     p!=0
-**     p->pVar!=0
-**     i>0
-**     i<=p->nVar
-**
-** An assert() is normally added after vdbeUnbind() to help static analyzers
-** realize this.
-*/
-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_BKPT);
-    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<<i))!=0 ){
-    p->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 ){
-    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
-    if( zData!=0 ){
-      pVar = &p->aVar[i-1];
-      if( encoding==SQLITE_UTF8 ){
-        rc = sqlite3VdbeMemSetText(pVar, zData, nData, xDel);
-      }else if( encoding==SQLITE_UTF8_ZT ){
-        /* It is usually consider improper to assert() on an input.
-        ** However, the following assert() is checking for inputs
-        ** that are documented to result in undefined behavior. */
-        assert( zData==0
-             || nData<0
-             || nData>pVar->db->aLimit[SQLITE_LIMIT_LENGTH]
-             || ((u8*)zData)[nData]==0
-        );
-        rc = sqlite3VdbeMemSetText(pVar, zData, nData, xDel);
-        pVar->flags |= MEM_Term;
-      }else{
-        rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
-        if( encoding==0 ) pVar->enc = ENC(p->db);
-      }
-      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 ){
-    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
-    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 ){
-    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
-    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 ){
-    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
-    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 ){
-    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
-    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 && enc!=SQLITE_UTF8_ZT ){
-    if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
-    nData &= ~(u64)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 ){
-    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
-#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;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( p==0 ) return SQLITE_MISUSE_BKPT;
-#endif
-  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; i<pFrom->nVar; 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;
-}
-
-/*
-** Set the explain mode for a statement.
-*/
-SQLITE_API int sqlite3_stmt_explain(sqlite3_stmt *pStmt, int eMode){
-  Vdbe *v = (Vdbe*)pStmt;
-  int rc;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( pStmt==0 ) return SQLITE_MISUSE_BKPT;
-#endif
-  sqlite3_mutex_enter(v->db->mutex);
-  if( ((int)v->explain)==eMode ){
-    rc = SQLITE_OK;
-  }else if( eMode<0 || eMode>2 ){
-    rc = SQLITE_ERROR;
-  }else if( (v->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
-    rc = SQLITE_ERROR;
-  }else if( v->eVdbeState!=VDBE_READY_STATE ){
-    rc = SQLITE_BUSY;
-  }else if( v->nMem>=10 && (eMode!=2 || v->haveEqpOps) ){
-    /* No reprepare necessary */
-    v->explain = eMode;
-    rc = SQLITE_OK;
-  }else{
-    v->explain = eMode;
-    rc = sqlite3Reprepare(v);
-    v->haveEqpOps = eMode==2;
-  }
-  if( v->explain ){
-    v->nResColumn = 12 - 4*v->explain;
-  }else{
-    v->nResColumn = v->nResAlloc;
-  }
-  sqlite3_mutex_leave(v->db->mutex);
-  return rc;
-}
-
-/*
-** 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(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;
-  Mem *pMem;
-  int rc = SQLITE_OK;
-  int iStore = 0;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( db==0 || ppValue==0 ){
-    return SQLITE_MISUSE_BKPT;
-  }
-#endif
-  p = db->pPreUpdate;
-  /* 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 ){
-    iStore = sqlite3TableColumnToIndex(p->pPk, iIdx);
-  }else if( iIdx >= p->pTab->nCol ){
-    rc = SQLITE_MISUSE_BKPT;
-    goto preupdate_old_out;
-  }else{
-    iStore = sqlite3TableColumnToStorage(p->pTab, iIdx);
-  }
-  if( iStore>=p->pCsr->nField || iStore<0 ){
-    rc = SQLITE_RANGE;
-    goto preupdate_old_out;
-  }
-
-  if( iIdx==p->pTab->iPKey ){
-    *ppValue = pMem = &p->oldipk;
-    sqlite3VdbeMemSetInt64(pMem, p->iKey1);
-  }else{
-
-    /* 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->pKeyinfo, 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[iStore];
-    if( iStore>=p->pUnpacked->nField ){
-      /* This occurs when the table has been extended using ALTER TABLE
-      ** ADD COLUMN. The value to return is the default value of the column. */
-      Column *pCol = &p->pTab->aCol[iIdx];
-      if( pCol->iDflt>0 ){
-        if( p->apDflt==0 ){
-          int nByte;
-          assert( sizeof(sqlite3_value*)*UMXV(p->pTab->nCol) < 0x7fffffff );
-          nByte = sizeof(sqlite3_value*)*p->pTab->nCol;
-          p->apDflt = (sqlite3_value**)sqlite3DbMallocZero(db, nByte);
-          if( p->apDflt==0 ) goto preupdate_old_out;
-        }
-        if( p->apDflt[iIdx]==0 ){
-          sqlite3_value *pVal = 0;
-          Expr *pDflt;
-          assert( p->pTab!=0 && IsOrdinaryTable(p->pTab) );
-          pDflt = p->pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
-          rc = sqlite3ValueFromExpr(db, pDflt, ENC(db), pCol->affinity, &pVal);
-          if( rc==SQLITE_OK && pVal==0 ){
-            rc = SQLITE_CORRUPT_BKPT;
-          }
-          p->apDflt[iIdx] = pVal;
-        }
-        *ppValue = p->apDflt[iIdx];
-      }else{
-        *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;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  p = db!=0 ? db->pPreUpdate : 0;
-#else
-  p = db->pPreUpdate;
-#endif
-  return (p ? p->pKeyinfo->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;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  p = db!=0 ? db->pPreUpdate : 0;
-#else
-  p = db->pPreUpdate;
-#endif
-  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;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  p = db!=0 ? db->pPreUpdate : 0;
-#else
-  p = db->pPreUpdate;
-#endif
-  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;
-  int rc = SQLITE_OK;
-  Mem *pMem;
-  int iStore = 0;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( db==0 || ppValue==0 ){
-    return SQLITE_MISUSE_BKPT;
-  }
-#endif
-  p = db->pPreUpdate;
-  if( !p || p->op==SQLITE_DELETE ){
-    rc = SQLITE_MISUSE_BKPT;
-    goto preupdate_new_out;
-  }
-  if( p->pPk && p->op!=SQLITE_UPDATE ){
-    iStore = sqlite3TableColumnToIndex(p->pPk, iIdx);
-  }else if( iIdx >= p->pTab->nCol ){
-    return SQLITE_MISUSE_BKPT;
-  }else{
-    iStore = sqlite3TableColumnToStorage(p->pTab, iIdx);
-  }
-
-  if( iStore>=p->pCsr->nField || iStore<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->pKeyinfo, pData->n, pData->z);
-      if( !pUnpack ){
-        rc = SQLITE_NOMEM;
-        goto preupdate_new_out;
-      }
-      p->pNewUnpacked = pUnpack;
-    }
-    pMem = &pUnpack->aMem[iStore];
-    if( iIdx==p->pTab->iPKey ){
-      sqlite3VdbeMemSetInt64(pMem, p->iKey2);
-    }else if( iStore>=pUnpack->nField ){
-      pMem = (sqlite3_value *)columnNullValue();
-    }
-  }else{
-    /* For an UPDATE, memory cell (p->iNewReg+1+iStore) 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 ){
-      assert( sizeof(Mem)*UMXV(p->pCsr->nField) < 0x7fffffff );
-      p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem)*p->pCsr->nField);
-      if( !p->aNew ){
-        rc = SQLITE_NOMEM;
-        goto preupdate_new_out;
-      }
-    }
-    assert( iStore>=0 && iStore<p->pCsr->nField );
-    pMem = &p->aNew[iStore];
-    if( pMem->flags==0 ){
-      if( iIdx==p->pTab->iPKey ){
-        sqlite3VdbeMemSetInt64(pMem, p->iKey2);
-      }else{
-        rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iStore]);
-        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;
-  int nOp;
-  ScanStatus *pScan = 0;
-  int idx;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( p==0 || pOut==0
-      || iScanStatusOp<SQLITE_SCANSTAT_NLOOP
-      || iScanStatusOp>SQLITE_SCANSTAT_NCYCLE ){
-    return 1;
-  }
-#endif
-  aOp = p->aOp;
-  nOp = p->nOp;
-  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; ii<nOp; ii++){
-        res += aOp[ii].nCycle;
-      }
-      *(i64*)pOut = res;
-      return 0;
-    }
-    return 1;
-  }
-  if( flags & SQLITE_SCANSTAT_COMPLEX ){
-    idx = iScan;
-  }else{
-    /* If the COMPLEX flag is clear, then this function must ignore any
-    ** ScanStatus structures with ScanStatus.addrLoop set to 0. */
-    for(idx=0; idx<p->nScan; idx++){
-      pScan = &p->aScan[idx];
-      if( pScan->zName ){
-        iScan--;
-        if( iScan<0 ) break;
-      }
-    }
-  }
-  if( idx>=p->nScan ) return 1;
-  assert( pScan==0 || pScan==&p->aScan[idx] );
-  pScan = &p->aScan[idx];
-
-  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; ii<ArraySize(pScan->aAddrRange); 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; iOp<nOp; iOp++){
-              Op *pOp = &aOp[iOp];
-              if( pOp->p1!=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; p!=0 && ii<p->nOp; 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 i64 findNextHostParameter(const char *zSql, i64 *pnToken){
-  int tokenType;
-  i64 nTotal = 0;
-  i64 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 */
-  i64 n;                   /* Length of a token prefix */
-  i64 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( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; }
-        }
-#endif
-        sqlite3_str_appendf(&out, "'%.*q'", nOut, pVar->z);
-#ifdef SQLITE_TRACE_SIZE_LIMIT
-        if( nOut<pVar->n ){
-          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; i<nOut; i++){
-          sqlite3_str_appendf(&out, "%02x", pVar->z[i]&0xff);
-        }
-        sqlite3_str_append(&out, "'", 1);
-#ifdef SQLITE_TRACE_SIZE_LIMIT
-        if( nOut<pVar->n ){
-          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" */
-
-/*
-** High-resolution hardware timer used for debugging and testing only.
-*/
-#if defined(VDBE_PROFILE)  \
- || defined(SQLITE_PERFORMANCE_TRACE) \
- || defined(SQLITE_ENABLE_STMT_SCANSTATUS)
-/************** Include hwtime.h in the middle of vdbe.c *********************/
-/************** Begin file hwtime.h ******************************************/
-/*
-** 2008 May 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 inline asm code for retrieving "high-performance"
-** counters for x86 and x86_64 class CPUs.
-*/
-#ifndef SQLITE_HWTIME_H
-#define SQLITE_HWTIME_H
-
-#if defined(_MSC_VER) && defined(_WIN32)
-
-/*   #include "windows.h" */
-  #include <profileapi.h>
-
-  __inline sqlite3_uint64 sqlite3Hwtime(void){
-    LARGE_INTEGER tm;
-    QueryPerformanceCounter(&tm);
-    return (sqlite3_uint64)tm.QuadPart;
-  }
-
-#elif !defined(__STRICT_ANSI__) && defined(__GNUC__) && \
-    (defined(i386) || defined(__i386__) || defined(_M_IX86))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-     unsigned int lo, hi;
-     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
-     return (sqlite_uint64)hi << 32 | lo;
-  }
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-     unsigned int lo, hi;
-     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
-     return (sqlite_uint64)hi << 32 | lo;
-  }
-
-#elif !defined(__STRICT_ANSI__) && defined(__GNUC__) &&  defined(__aarch64__)
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-     sqlite3_uint64 cnt;
-     __asm__ __volatile__ ("mrs %0, cntvct_el0" : "=r" (cnt));
-     return cnt;
-  }
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long long retval;
-      unsigned long junk;
-      __asm__ __volatile__ ("\n\
-          1:      mftbu   %1\n\
-                  mftb    %L0\n\
-                  mftbu   %0\n\
-                  cmpw    %0,%1\n\
-                  bne     1b"
-                  : "=r" (retval), "=r" (junk));
-      return retval;
-  }
-
-#else
-
-  /*
-  ** asm() is needed for hardware timing support.  Without asm(),
-  ** disable the sqlite3Hwtime() routine.
-  **
-  ** sqlite3Hwtime() is only used for some obscure debugging
-  ** and analysis configurations, not in any deliverable, so this
-  ** should not be a great loss.
-  */
-SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
-
-#endif
-
-#endif /* !defined(SQLITE_HWTIME_H) */
-
-/************** End of hwtime.h **********************************************/
-/************** Continuing where we left off in vdbe.c ***********************/
-#endif
-
-/*
-** 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 u64 n = 0;
-  (void)pc;
-  (void)pOp;
-  (void)v;
-  n++;
-  if( n==LARGEST_UINT64 ) abort(); /* So that n is used, preventing a warning */
-}
-#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<M );   /* I can only be 2 if M is 3 or 4 */
-    /* Transform I from a integer [0,1,2] into a bitmask of [1,2,4] */
-    I = 1<<I;
-    /* The upper 8 bits of iSrcLine are flags.  The lower three bits of
-    ** the flags indicate directions that the branch can never go.  If
-    ** a branch really does go in one of those directions, assert right
-    ** away. */
-    mNever = iSrcLine >> 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;
-
-  i64 nByte;
-  VdbeCursor *pCx = 0;
-  nByte = SZ_VDBECURSOR(nField);
-  assert( ROUND8(nByte)==nByte );
-  if( eCurType==CURTYPE_BTREE ) nByte += sqlite3BtreeCursorSize();
-
-  assert( iCur>=0 && iCur<p->nCursor );
-  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->szMalloc<nByte ){
-    if( pMem->szMalloc>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 = (int)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 ){
-    assert( ROUND8(SZ_VDBECURSOR(nField))==SZ_VDBECURSOR(nField) );
-    pCx->uc.pCursor = (BtCursor*)&pMem->z[SZ_VDBECURSOR(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;
-  int rc;
-  assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str );
-  rc = sqlite3MemRealValueRC(pRec, &rValue);
-  if( rc<=0 ) return;
-  if( (rc&2)==0 && 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;
-    assert( pMem->db!=0 );
-    sqlite3_mutex_enter(pMem->db->mutex);
-    applyNumericAffinity(pMem, 0);
-    sqlite3_mutex_leave(pMem->db->mutex);
-    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 = sqlite3MemRealValueRC(pMem, &pMem->u.r);
-  if( rc<=0 ){
-    if( (rc&2)==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
-      pMem->u.i = ix;
-      return MEM_Int;
-    }else{
-      return MEM_Real;
-    }
-  }else if( (rc&2)==0 && 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 && i<pMem->n; i++){
-      sqlite3_str_appendf(pStr, "%02X", ((int)pMem->z[i] & 0xFF));
-    }
-    sqlite3_str_appendf(pStr, "|");
-    for(i=0; i<25 && i<pMem->n; 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 && j<pMem->n; j++){
-      c = pMem->z[j];
-      sqlite3_str_appendchar(pStr, 1, (c>=0x20&&c<=0x7f) ? c : '.');
-    }
-    sqlite3_str_appendf(pStr, "]%s", encnames[pMem->enc]);
-    if( f & MEM_Term ){
-      sqlite3_str_appendf(pStr, "(0-term)");
-    }
-  }
-}
-#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 ){
-    assert( p->pScopyFrom->bScopy );
-    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; i<v->nMem; 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; i<mx; i++){
-    const Mem *p = &aMem[i];
-    if( p->flags & (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;
-}
-
-
-/*
-** For OP_Column, factor out the case where content is loaded from
-** overflow pages, so that the code to implement this case is separate
-** the common case where all content fits on the page.  Factoring out
-** the code reduces register pressure and helps the common case
-** to run faster.
-*/
-static SQLITE_NOINLINE int vdbeColumnFromOverflow(
-  VdbeCursor *pC,       /* The BTree cursor from which we are reading */
-  int iCol,             /* The column to read */
-  u32 t,                /* The serial-type code for the column value */
-  i64 iOffset,          /* Offset to the start of the content value */
-  u32 cacheStatus,      /* Current Vdbe.cacheCtr value */
-  u32 colCacheCtr,      /* Current value of the column cache counter */
-  Mem *pDest            /* Store the value into this register. */
-){
-  int rc;
-  sqlite3 *db = pDest->db;
-  int encoding = pDest->enc;
-  int len = sqlite3VdbeSerialTypeLen(t);
-  assert( pC->eCurType==CURTYPE_BTREE );
-  if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) return SQLITE_TOOBIG;
-  if( len > 4000 && pC->pKeyInfo==0 ){
-    /* Cache large column values that are on overflow pages using
-    ** an RCStr (reference counted string) so that if they are reloaded,
-    ** that do not have to be copied a second time.  The overhead of
-    ** creating and managing the cache is such that this is only
-    ** profitable for larger TEXT and BLOB values.
-    **
-    ** Only do this on table-btrees so that writes to index-btrees do not
-    ** need to clear the cache.  This buys performance in the common case
-    ** in exchange for generality.
-    */
-    VdbeTxtBlbCache *pCache;
-    char *pBuf;
-    if( pC->colCache==0 ){
-      pC->pCache = sqlite3DbMallocZero(db, sizeof(VdbeTxtBlbCache) );
-      if( pC->pCache==0 ) return SQLITE_NOMEM;
-      pC->colCache = 1;
-    }
-    pCache = pC->pCache;
-    if( pCache->pCValue==0
-     || pCache->iCol!=iCol
-     || pCache->cacheStatus!=cacheStatus
-     || pCache->colCacheCtr!=colCacheCtr
-     || pCache->iOffset!=sqlite3BtreeOffset(pC->uc.pCursor)
-    ){
-      if( pCache->pCValue ) sqlite3RCStrUnref(pCache->pCValue);
-      pBuf = pCache->pCValue = sqlite3RCStrNew( len+3 );
-      if( pBuf==0 ) return SQLITE_NOMEM;
-      rc = sqlite3BtreePayload(pC->uc.pCursor, iOffset, len, pBuf);
-      if( rc ) return rc;
-      pBuf[len] = 0;
-      pBuf[len+1] = 0;
-      pBuf[len+2] = 0;
-      pCache->iCol = iCol;
-      pCache->cacheStatus = cacheStatus;
-      pCache->colCacheCtr = colCacheCtr;
-      pCache->iOffset = sqlite3BtreeOffset(pC->uc.pCursor);
-    }else{
-      pBuf = pCache->pCValue;
-    }
-    assert( t>=12 );
-    sqlite3RCStrRef(pBuf);
-    if( t&1 ){
-      rc = sqlite3VdbeMemSetStr(pDest, pBuf, len, encoding,
-                                sqlite3RCStrUnref);
-      pDest->flags |= MEM_Term;
-    }else{
-      rc = sqlite3VdbeMemSetStr(pDest, pBuf, len, 0,
-                                sqlite3RCStrUnref);
-    }
-  }else{
-    rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, iOffset, len, pDest);
-    if( rc ) return rc;
-    sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
-    if( (t&1)!=0 && encoding==SQLITE_UTF8 ){
-      pDest->z[len] = 0;
-      pDest->flags |= MEM_Term;
-    }
-  }
-  pDest->flags &= ~MEM_Ephem;
-  return rc;
-}
-
-/*
-** Send a "statement aborts" message to the error log.
-*/
-static SQLITE_NOINLINE void sqlite3VdbeLogAbort(
-  Vdbe *p,     /* The statement that is running at the time of failure */
-  int rc,      /* Error code */
-  Op *pOp,     /* Opcode that filed */
-  Op *aOp      /* All opcodes */
-){
-  const char *zSql = p->zSql;   /* Original SQL text */
-  const char *zPrefix = "";     /* Prefix added to SQL text */
-  int pc;                       /* Opcode address */
-  char zXtra[100];              /* Buffer space to store zPrefix */
-
-  if( p->pFrame ){
-    assert( aOp[0].opcode==OP_Init );
-    if( aOp[0].p4.z!=0 ){
-      assert( aOp[0].p4.z[0]=='-'
-           && aOp[0].p4.z[1]=='-'
-           && aOp[0].p4.z[2]==' ' );
-      sqlite3_snprintf(sizeof(zXtra), zXtra,"/* %s */ ",aOp[0].p4.z+3);
-      zPrefix = zXtra;
-    }else{
-      zPrefix = "/* unknown trigger */ ";
-    }
-  }
-  pc = (int)(pOp - aOp);
-  sqlite3_log(rc, "statement aborts at %d: %s; [%s%s]",
-                   pc, p->zErrMsg, zPrefix, zSql);
-}
-
-/*
-** 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 */
-  u32 colCacheCtr = 0;       /* Column cache counter */
-#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; i<p->nOp; i++){
-        sqlite3VdbePrintOp(stdout, i, &aOp[i]);
-      }
-    }
-    if( p->db->flags & SQLITE_VdbeEQP ){
-      for(i=0; i<p->nOp; 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 debugging mode, when the p5 flags is set on an OP_Goto, that
-  ** means we should really jump back to the preceding 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: {     /* jump0 */
-  assert( pOp->p1>0 &&  pOp->p1<=(p->nMem+1 - p->nCursor) );
-  assert( pOp->p2>=0 && pOp->p2<p->nOp );
-  assert( pOp->p3>=0 && pOp->p3<p->nOp );
-  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->p2<p->nOp );  /* 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, the value register P1 is left with a value
-** such that subsequent OP_Yields go back to the this same
-** OP_EndCoroutine instruction.
-**
-** 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.i<p->nOp );
-  pCaller = &aOp[pIn1->u.i];
-  assert( pCaller->opcode==OP_Yield );
-  assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
-  pIn1->u.i = (int)(pOp - p->aOp) - 1;
-  pOp = &aOp[pCaller->p2 - 1];
-  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, jump0 */
-  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 P3 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 P3 is not zero and P4 is NULL, then P3 is a register that holds the
-** text of an error message.
-**
-** If P3 is zero and P4 is not null then the error message string is held
-** in P4.
-**
-** P5 is a value between 1 and 4, inclusive, then the P4 error message
-** string is modified as follows:
-**
-**    1:  NOT NULL constraint failed: P4
-**    2:  UNIQUE constraint failed: P4
-**    3:  CHECK constraint failed: P4
-**    4:  FOREIGN KEY constraint failed: P4
-**
-** If P3 is zero and 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
-  assert( pOp->p4type==P4_NOTUSED
-       || pOp->p4type==P4_STATIC
-       || pOp->p4type==P4_DYNAMIC );
-
-  /* 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->p3>0 && pOp->p4type==P4_NOTUSED ){
-      const char *zErr;
-      assert( pOp->p3<=(p->nMem + 1 - p->nCursor) );
-      zErr = sqlite3ValueText(&aMem[pOp->p3], SQLITE_UTF8);
-      sqlite3VdbeError(p, "%s", zErr);
-    }else 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);
-    }
-    sqlite3VdbeLogAbort(p, pOp->p1, pOp, aOp);
-  }
-  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 * * *
-** Synopsis: r[P2]=parameter(P1)
-**
-** Transfer the values of bound parameter P1 into register P2
-*/
-case OP_Variable: {            /* out2 */
-  Mem *pVar;       /* Value being transferred */
-
-  assert( pOp->p1>0 && pOp->p1<=p->nVar );
-  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; i<p->nMem; i++){
-        if( aMem[i].pScopyFrom==pIn1 ){
-          assert( aMem[i].bScopy );
-          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;
-  pIn1->bScopy = 1;
-#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 = sqlite3VdbeCheckFkImmediate(p))!=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; i<pOp->p2; 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;
-  nByte += pIn2->n;
-  if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
-    goto too_big;
-  }
-#if SQLITE_MAX_LENGTH>2147483645
-  if( nByte>2147483645 ){ goto too_big; }
-#endif
-  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 left 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.
-*/
-/* Opcode: ShiftRight 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);
-  *(u64*)&pIn1->u.i += (u64)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: {            /* jump0, 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
-
-#if !defined(SQLITE_OMIT_CAST) || !defined(SQLITE_OMIT_ANALYZE)
-/* Opcode: Cast P1 P2 * * *
-** Synopsis: affinity(r[P1])
-**
-** Force the value in register P1 to be the type defined by P2.
-**
-** <ul>
-** <li> P2=='A' &rarr; BLOB
-** <li> P2=='B' &rarr; TEXT
-** <li> P2=='C' &rarr; NUMERIC
-** <li> P2=='D' &rarr; INTEGER
-** <li> P2=='E' &rarr; REAL
-** </ul>
-**
-** 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]
-**
-** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
-** jump to address P2.
-**
-** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
-** reg(P3) is NULL then the take the jump.  If the SQLITE_JUMPIFNULL
-** bit is clear then fall through if either operand is NULL.
-**
-** 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.
-**
-** This opcode saves the result of comparison for use by the new
-** OP_Jump opcode.
-*/
-/* Opcode: Le 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 less than or equal to the content of
-** register P1.  See the Lt opcode for additional information.
-*/
-/* Opcode: Gt 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 ){
-        pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
-      }else if( (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 ){
-        pIn3->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
-      }else if( (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 the 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 );
-  assert( pKeyInfo->aSortFlags!=0 );
-  p1 = pOp->p1;
-  p2 = pOp->p2;
-#ifdef SQLITE_DEBUG
-  if( aPermute ){
-    int k, mx = 0;
-    for(k=0; k<n; k++) if( aPermute[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; i<n; i++){
-    idx = aPermute ? aPermute[i] : (u32)i;
-    assert( memIsValid(&aMem[p1+idx]) );
-    assert( memIsValid(&aMem[p2+idx]) );
-    REGISTER_TRACE(p1+idx, &aMem[p1+idx]);
-    REGISTER_TRACE(p2+idx, &aMem[p2+idx]);
-    assert( i<pKeyInfo->nKeyField );
-    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:
-**
-** <ul>
-** <li> If P3==0 and P4==0  then  r[P2] := r[P1] IS TRUE
-** <li> If P3==1 and P4==1  then  r[P2] := r[P1] IS FALSE
-** <li> If P3==0 and P4==1  then  r[P2] := r[P1] IS NOT TRUE
-** <li> If P3==1 and P4==0  then  r[P2] := r[P1] IS NOT FALSE
-** </ul>
-*/
-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 P3 * *
-**
-** 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.
-**
-** The P3 operand is not used directly by this opcode.  However P3 is
-** used by the code generator as follows:  If this opcode is the start
-** of a subroutine and that subroutine uses a Bloom filter, then P3 will
-** be the register that holds that Bloom filter.  See tag-202407032019
-** in the source code for implementation details.
-*/
-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->p1<p->nCursor );
-  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->p3<pC->nHdrParsed ){
-      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 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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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->szRow<aOffset[0] ){      /*OPTIMIZATION-IF-FALSE*/
-      /* pC->aRow 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->iHdrOffset<aOffset[0] ){
-      /* Make sure zData points to enough of the record to cover the header. */
-      if( pC->aRow==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 );
-
-      /* The record is corrupt if any of the following are true:
-      ** (1) the bytes of the header extend past the declared header size
-      ** (2) the entire header was used but not all data was used
-      ** (3) the end of the data extends beyond the end of the record.
-      */
-      if( (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( p2<pC->nHdrParsed );
-  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{
-    u8 p5;
-    pDest->enc = encoding;
-    assert( pDest->db==db );
-    /* This branch happens only when content is on overflow pages */
-    if( ((p5 = (pOp->p5 & OPFLAG_BYTELENARG))!=0
-          && (p5==OPFLAG_TYPEOFARG
-              || (t>=12 && ((t&1)==0 || p5==OPFLAG_BYTELENARG))
-             )
-        )
-     || 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{
-      rc = vdbeColumnFromOverflow(pC, p2, t, aOffset[p2],
-                p->cacheCtr, colCacheCtr, pDest);
-      if( rc ){
-        if( rc==SQLITE_NOMEM ) goto no_mem;
-        if( rc==SQLITE_TOOBIG ) goto too_big;
-        goto abort_due_to_error;
-      }
-    }
-  }
-
-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.
-**
-** If P3==0, then omit checking of VIRTUAL columns.
-**
-** If P3==1, then omit checking of all generated column, both VIRTUAL
-** and STORED.
-**
-** If P3>=2, then only check column number P3-2 in the table (which will
-** be a VIRTUAL column) against the value in reg[P1].  In this case,
-** P2 will be 1.
-**
-** 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:
-**
-** <ul>
-** <li> P2 should be the number of non-virtual columns in the
-**      table of P4 unless P3>1, in which case P2 will be 1.
-** <li> Table P4 is a STRICT table.
-** </ul>
-**
-** If any precondition is false, an assertion fault occurs.
-*/
-case OP_TypeCheck: {
-  Table *pTab;
-  Column *aCol;
-  int i;
-  int nCol;
-
-  assert( pOp->p4type==P4_TABLE );
-  pTab = pOp->p4.pTab;
-  assert( pTab->tabFlags & TF_Strict );
-  assert( pOp->p3>=0 && pOp->p3<pTab->nCol+2 );
-  aCol = pTab->aCol;
-  pIn1 = &aMem[pOp->p1];
-  if( pOp->p3<2 ){
-    assert( pTab->nNVCol==pOp->p2 );
-    i = 0;
-    nCol = pTab->nCol;
-  }else{
-    i = pOp->p3-2;
-    nCol = i+1;
-    assert( i<pTab->nCol );
-    assert( aCol[i].colFlags & COLFLAG_VIRTUAL );
-    assert( pOp->p2==1 );
-  }
-  for(; i<nCol; i++){
-    if( (aCol[i].colFlags & COLFLAG_GENERATED)!=0 && pOp->p3<2 ){
-      if( (aCol[i].colFlags & COLFLAG_VIRTUAL)!=0 ) 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->p3<pOp->p1 || 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 += (u32)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( nVarint<sqlite3VarintLen(nHdr) ) nHdr++;
-  }
-  nByte = nHdr+nData;
-
-  /* Make sure the output register has a buffer large enough to store
-  ** the new record. The output register (pOp->p3) 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;
-        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 = sqlite3SmallTypeSizes[serial_type];
-        assert( len>=1 && len<=8 && len!=5 && len!=7 );
-        switch( len ){
-          default: zPayload[7] = (u8)(v&0xff); v >>= 8;
-                   zPayload[6] = (u8)(v&0xff); v >>= 8;
-                   /* no break */ deliberate_fall_through
-          case 6:  zPayload[5] = (u8)(v&0xff); v >>= 8;
-                   zPayload[4] = (u8)(v&0xff); v >>= 8;
-                   /* no break */ deliberate_fall_through
-          case 4:  zPayload[3] = (u8)(v&0xff); v >>= 8;
-                   /* no break */ deliberate_fall_through
-          case 3:  zPayload[2] = (u8)(v&0xff); v >>= 8;
-                   /* no break */ deliberate_fall_through
-          case 2:  zPayload[1] = (u8)(v&0xff); v >>= 8;
-                   /* no break */ deliberate_fall_through
-          case 1:  zPayload[0] = (u8)(v&0xff);
-        }
-        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 );
-        assert( pRec->z!=(const char*)sqlite3CtypeMap );
-        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 = sqlite3VdbeCheckFkDeferred(p))!=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; ii<db->nDb; 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; ii<db->nDb; 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 = sqlite3VdbeCheckFkDeferred(p))!=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->p1<db->nDb );
-  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<SQLITE_N_BTREE_META );
-  assert( iDb>=0 && iDb<db->nDb );
-  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->p2<SQLITE_N_BTREE_META );
-  assert( pOp->p1>=0 && pOp->p1<db->nDb );
-  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:
-** <ul>
-** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
-**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
-**       of OP_SeekLE/OP_IdxLT)
-** </ul>
-**
-** 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:
-** <ul>
-** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
-**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
-**       of OP_SeekLE/OP_IdxLT)
-** </ul>
-**
-** 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:
-** <ul>
-** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
-**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
-**       of OP_SeekLE/OP_IdxLT)
-** <li>  <b>0x08 OPFLAG_FORDELETE</b>: 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.
-** <li>  <b>0x10 OPFLAG_P2ISREG</b>: Use the content of register P2
-**       as the root page, not the value of P2 itself.
-** </ul>
-**
-** 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 && iDb<db->nDb );
-  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;
-    }
-    if( pOp->p5 & OPFLAG_P2ISREG ){
-      assert( p2>0 );
-      assert( p2<=(u32)(p->nMem+1 - p->nCursor) );
-      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 );
-    }
-  }else{
-    wrFlag = 0;
-    assert( (pOp->p5 & OPFLAG_P2ISREG)==0 );
-  }
-  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 ephemeral 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);
-      assert( p->apCsr[pOp->p1]==pCx );
-      if( rc ){
-        assert( !sqlite3BtreeClosesWithCursor(pCx->ub.pBtx, pCx->uc.pCursor) );
-        sqlite3BtreeClose(pCx->ub.pBtx);
-        p->apCsr[pOp->p1] = 0;  /* Not required; helps with static analysis */
-      }else{
-        assert( sqlite3BtreeClosesWithCursor(pCx->ub.pBtx, pCx->uc.pCursor) );
-      }
-    }
-  }
-  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->p1<p->nCursor );
-  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.  If P2 is 0 or negative then the pseudo-cursor
-** will return NULL for every column.
-*/
-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->p1<p->nCursor );
-  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:         /* jump0, in3, group, ncycle */
-case OP_SeekLE:         /* jump0, in3, group, ncycle */
-case OP_SeekGE:         /* jump0, in3, group, ncycle */
-case OP_SeekGT: {       /* jump0, 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->p1<p->nCursor );
-  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; i<r.nField; i++){
-        assert( memIsValid(&r.aMem[i]) );
-        if( i>0 ) 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 constraint.  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:<ol>
-**
-** <li> If the cursor is initially not pointed to any valid row, then
-**      fall through into the subsequent OP_SeekGE opcode.
-**
-** <li> 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.
-**
-** <li> 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..,
-**
-** <li> 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.
-**
-** <li> 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.
-** </ol>
-*/
-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; i<r.nField; i++){
-      assert( memIsValid(&r.aMem[i]) );
-      REGISTER_TRACE(pOp[1].p3+i, &aMem[pOp[1].p3+i]);
-    }
-  }
-#endif
-  res = 0;  /* Not needed.  Only used to silence a warning. */
-  while(1){
-    rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
-    if( rc ) goto abort_due_to_error;
-    if( res>0 && 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->p1<p->nCursor );
-  pC = p->apCsr[pOp->p1];
-  assert( pC!=0 );
-  assert( pOp->p3>=pOp->p2 );
-  if( pC->seekHit<pOp->p2 ){
-#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->p1<p->nCursor );
-  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 work
-** 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 skip 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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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
-    (void)sqlite3FaultSim(50);  /* For use by --counter in TH3 */
-    for(ii=0; ii<r.nField; ii++){
-      assert( memIsValid(&r.aMem[ii]) );
-      assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 );
-      if( ii ) REGISTER_TRACE(pOp->p3+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(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; ii<r.nField; ii++){
-        if( r.aMem[ii].flags & MEM_Null ){
-          VdbeBranchTaken(1,2);
-          goto jump_to_p2;
-        }
-      }
-    }
-    VdbeBranchTaken(0,2);
-    if( pOp->opcode==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: {        /* jump0, 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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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( v<pMem->u.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->p1<p->nCursor );
-  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;
-  colCacheCtr++;
-
-  /* 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 is 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 (0x01) flag of P2 (NB: P2 not P5) is set, then
-** the row change count is incremented (otherwise not).
-**
-** If the OPFLAG_ISNOOP (0x40) flag of P2 (not P5!) is set, then the
-** pre-update-hook for deletes is run, but the btree is otherwise unchanged.
-** This happens when the OP_Delete is to be shortly followed by an OP_Insert
-** with the same key, causing the btree entry to be overwritten.
-**
-** 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->p1<p->nCursor );
-  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;
-  colCacheCtr++;
-  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 used 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: {       /* ncycle */
-  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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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 were not the case, one 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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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: {              /* jump0, ncycle */
-  VdbeCursor *pC;
-  BtCursor *pCrsr;
-  int res;
-
-  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  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: IfSizeBetween P1 P2 P3 P4 *
-**
-** Let N be the approximate number of rows in the table or index
-** with cursor P1 and let X be 10*log2(N) if N is positive or -1
-** if N is zero.
-**
-** Jump to P2 if X is in between P3 and P4, inclusive.
-*/
-case OP_IfSizeBetween: {        /* jump */
-  VdbeCursor *pC;
-  BtCursor *pCrsr;
-  int res;
-  i64 sz;
-
-  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  assert( pOp->p4type==P4_INT32 );
-  assert( pOp->p3>=-1 && pOp->p3<=640*2 );
-  assert( pOp->p4.i>=-1 && pOp->p4.i<=640*2 );
-  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 = -1;  /* -Infinity encoding */
-  }else{
-    sz = sqlite3BtreeRowCountEst(pCrsr);
-    assert( sz>0 );
-    sz = sqlite3LogEst((u64)sz);
-  }
-  res = sz>=pOp->p3 && sz<=pOp->p4.i;
-  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 ncycle */
-case OP_Sort: {        /* jump ncycle */
-#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: {        /* jump0, ncycle */
-  VdbeCursor *pC;
-  BtCursor *pCrsr;
-  int res;
-
-  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  assert( pOp->p5==0 );
-  assert( pOp->p2>=0 && pOp->p2<p->nOp );
-
-  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: IfEmpty P1 P2 * * *
-** Synopsis: if( empty(P1) ) goto P2
-**
-** Check to see if the b-tree table that cursor P1 references is empty
-** and jump to P2 if it is.
-*/
-case OP_IfEmpty: {        /* jump */
-  VdbeCursor *pC;
-  BtCursor *pCrsr;
-  int res;
-
-  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  assert( pOp->p2>=0 && pOp->p2<p->nOp );
-
-  pC = p->apCsr[pOp->p1];
-  assert( pC!=0 );
-  assert( pC->eCurType==CURTYPE_BTREE );
-  pCrsr = pC->uc.pCursor;
-  assert( pCrsr );
-  rc = sqlite3BtreeIsEmpty(pCrsr, &res);
-  if( rc ) goto abort_due_to_error;
-  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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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 P4 *
-** 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.
-**
-** P4 is a pointer to an Index structure.
-**
-** Raise an SQLITE_CORRUPT_INDEX error if no matching index entry is found
-** and not 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->p1<p->nCursor );
-  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 = sqlite3VdbeFindIndexKey(pCrsr, pOp->p4.pIdx, &r, &res, 0);
-    if( rc!=SQLITE_OK ) goto abort_due_to_error;
-    if( res!=0 ){
-      if( !sqlite3WritableSchema(db) ){
-        rc = sqlite3ReportError(
-            SQLITE_CORRUPT_INDEX, __LINE__, "index corruption");
-        goto abort_due_to_error;
-      }
-      pC->cacheStatus = CACHE_STALE;
-      pC->seekResult = 0;
-      break;
-    }
-  }
-  rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE);
-  if( rc ) 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->p1<p->nCursor );
-  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->p3<p->nCursor );
-      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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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->opcode<OP_IdxLT ){
-    assert( pOp->opcode==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; i<r.nField; i++){
-      assert( memIsValid(&r.aMem[i]) );
-      REGISTER_TRACE(pOp->p3+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 destroyed 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 cleared is in the main database file if P2==0.  If
-** P2==1 then the table to be cleared 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->p1<p->nCursor );
-  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->p1<db->nDb );
-  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 P1 P2 * P4 *
-**
-** Run the SQL statement or statements specified in the P4 string.
-**
-** The P1 parameter is a bitmask of options:
-**
-**    0x0001     Disable Auth and Trace callbacks while the statements
-**               in P4 are running.
-**
-**    0x0002     Set db->nAnalysisLimit to P2 while the statements in
-**               P4 are running.
-**
-*/
-case OP_SqlExec: {
-  char *zErr;
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  sqlite3_xauth xAuth;
-#endif
-  u8 mTrace;
-  int savedAnalysisLimit;
-
-  sqlite3VdbeIncrWriteCounter(p, 0);
-  db->nSqlExec++;
-  zErr = 0;
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  xAuth = db->xAuth;
-#endif
-  mTrace = db->mTrace;
-  savedAnalysisLimit = db->nAnalysisLimit;
-  if( pOp->p1 & 0x0001 ){
-#ifndef SQLITE_OMIT_AUTHORIZATION
-    db->xAuth = 0;
-#endif
-    db->mTrace = 0;
-  }
-  if( pOp->p1 & 0x0002 ){
-    db->nAnalysisLimit = pOp->p2;
-  }
-  rc = sqlite3_exec(db, pOp->p4.z, 0, 0, &zErr);
-  db->nSqlExec--;
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  db->xAuth = xAuth;
-#endif
-  db->mTrace = mTrace;
-  db->nAnalysisLimit = savedAnalysisLimit;
-  if( zErr || rc ){
-    sqlite3VdbeError(p, "%s", zErr);
-    sqlite3_free(zErr);
-    if( rc==SQLITE_NOMEM ) goto no_mem;
-    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; iDb<db->nDb; iDb++){
-    assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
-  }
-#endif
-
-  iDb = pOp->p1;
-  assert( iDb>=0 && iDb<db->nDb );
-  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->p1<db->nDb );
-  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+1) the text of an error message describing any problems.
-** If no problems are found, store a NULL in register (P1+1).
-**
-** The register (P1) contains one less than the maximum number of allowed
-** errors.  At most reg(P1) 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 );
-  assert( pOp->p4type==P4_INTARRAY );
-  nRoot = pOp->p2;
-  aRoot = pOp->p4.ai;
-  assert( nRoot>0 );
-  assert( aRoot!=0 );
-  assert( aRoot[0]==(Pgno)nRoot );
-  assert( pOp->p1>0 && (pOp->p1+1)<=(p->nMem+1 - p->nCursor) );
-  pnErr = &aMem[pOp->p1];
-  assert( (pnErr->flags & MEM_Int)!=0 );
-  assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
-  pIn1 = &aMem[pOp->p1+1];
-  assert( pOp->p5<db->nDb );
-  assert( DbMaskTest(p->btreeMask, pOp->p5) );
-  rc = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1],
-      &aMem[pOp->p3], 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;
-}
-
-/* Opcode: IFindKey P1 P2 P3 P4 *
-**
-** This instruction always follows an OP_Found with the same P1, P2 and P3
-** values as this instruction and a non-zero P4 value. The P4 value to
-** this opcode is of type P4_INDEX and contains a pointer to the Index
-** object of for the index being searched.
-**
-** This opcode uses sqlite3VdbeFindIndexKey() to search around the current
-** cursor location for an index key that exactly matches all fields that
-** are not indexed expressions or references to VIRTUAL generated columns,
-** and either exactly match or are real numbers that are within 2 ULPs of
-** each other if the don't match.
-**
-** To put it another way, this opcode looks for nearby index entries that
-** are very close to the search key, but which might have small differences
-** in floating-point values that come via an expression.
-**
-** If no nearby alternative entry is found in cursor P1, then jump to P2.
-** But if a close match is found, fall through.
-**
-** This opcode is used by PRAGMA integrity_check to help distinguish
-** between truely corrupt indexes and expression indexes that are holding
-** floating-point values that are off by one or two ULPs.
-*/
-case OP_IFindKey: {     /* jump, in3 */
-  VdbeCursor *pC;
-  int res;
-  UnpackedRecord r;
-
-  assert( pOp[-1].opcode==OP_Found );
-  assert( pOp[-1].p1==pOp->p1 );
-  assert( pOp[-1].p3==pOp->p3 );
-  pC = p->apCsr[pOp->p1];
-  assert( pOp->p4type==P4_INDEX );
-  assert( pC->eCurType==CURTYPE_BTREE );
-  assert( pC->uc.pCursor!=0 );
-  assert( pC->isTable==0 );
-
-  memset(&r, 0, sizeof(r));
-  r.aMem = &aMem[pOp->p3];
-  r.nField = pOp->p4.pIdx->nColumn;
-  r.pKeyInfo = pC->pKeyInfo;
-
-  rc = sqlite3VdbeFindIndexKey(pC->uc.pCursor, pOp->p4.pIdx, &r, &res, 1);
-  if( rc || res!=0 ){
-    rc = SQLITE_OK;
-    goto jump_to_p2;
-  }
-  pC->nullRow = 0;
-  break;
-};
-#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. P2 might be zero, if there is
-** no possibility that an IGNORE exception will be raised.
-** 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: {        /* jump0 */
-  int nMem;               /* Number of memory registers for sub-program */
-  i64 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*)
-              + (7 + (i64)pProgram->nOp)/8;
-    pFrame = sqlite3DbMallocZero(db, nByte);
-    if( !pFrame ){
-      goto no_mem;
-    }
-    sqlite3VdbeMemRelease(pRt);
-    pRt->flags = MEM_Blob|MEM_Dyn;
-    pRt->z = (char*)pFrame;
-    pRt->n = (int)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; i<p->nMem; 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( pOp->p1 ){
-    db->nDeferredCons += pOp->p2;
-  }else{
-    if( db->flags & SQLITE_DeferFKs ){
-      db->nDeferredImmCons += 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.i<pIn2->u.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;
-  u64 nAlloc;
-
-  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->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
-
-  /* Allocate space for (a) the context object and (n-1) extra pointers
-  ** to append to the sqlite3_context.argv[1] array, and (b) a memory
-  ** cell in which to store the accumulation. Be careful that the memory
-  ** cell is 8-byte aligned, even on platforms where a pointer is 32-bits.
-  **
-  ** Note: We could avoid this by using a regular memory cell from aMem[] for
-  ** the accumulator, instead of allocating one here. */
-  nAlloc = ROUND8P( SZ_CONTEXT(n) );
-  pCtx = sqlite3DbMallocRawNN(db, nAlloc + sizeof(Mem));
-  if( pCtx==0 ) goto no_mem;
-  pCtx->pOut = (Mem*)((u8*)pCtx + nAlloc);
-  assert( EIGHT_BYTE_ALIGNMENT(pCtx->pOut) );
-
-  sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
-  pCtx->pMem = 0;
-  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 relevant 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; i<pCtx->argc; 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
-       || pOp->p2==SQLITE_CHECKPOINT_NOOP
-  );
-  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->p1<db->nDb );
-  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->p1<db->nDb );
-  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->p1<p->nCursor );
-  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->p1<p->nCursor );
-  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 && p1<db->nDb );
-    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 = p->apCsr[pOp->p1];
-  if( pCur!=0
-   && ALWAYS( pCur->eCurType==CURTYPE_VTAB )
-   && ALWAYS( pCur->uc.pVCur->pVtab==pOp->p4.pVtab->pVtab )
-  ){
-    /* This opcode is a no-op if the cursor is already open */
-    break;
-  }
-  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: VCheck P1 P2 P3 P4 *
-**
-** P4 is a pointer to a Table object that is a virtual table in schema P1
-** that supports the xIntegrity() method.  This opcode runs the xIntegrity()
-** method for that virtual table, using P3 as the integer argument.  If
-** an error is reported back, the table name is prepended to the error
-** message and that message is stored in P2.  If no errors are seen,
-** register P2 is set to NULL.
-*/
-case OP_VCheck: {             /* out2 */
-  Table *pTab;
-  sqlite3_vtab *pVtab;
-  const sqlite3_module *pModule;
-  char *zErr = 0;
-
-  pOut = &aMem[pOp->p2];
-  sqlite3VdbeMemSetNull(pOut);  /* Innocent until proven guilty */
-  assert( pOp->p4type==P4_TABLEREF );
-  pTab = pOp->p4.pTab;
-  assert( pTab!=0 );
-  assert( pTab->nTabRef>0 );
-  assert( IsVirtual(pTab) );
-  if( pTab->u.vtab.p==0 ) break;
-  pVtab = pTab->u.vtab.p->pVtab;
-  assert( pVtab!=0 );
-  pModule = pVtab->pModule;
-  assert( pModule!=0 );
-  assert( pModule->iVersion>=4 );
-  assert( pModule->xIntegrity!=0 );
-  sqlite3VtabLock(pTab->u.vtab.p);
-  assert( pOp->p1>=0 && pOp->p1<db->nDb );
-  rc = pModule->xIntegrity(pVtab, db->aDb[pOp->p1].zDbSName, pTab->zName,
-                           pOp->p3, &zErr);
-  sqlite3VtabUnlock(pTab->u.vtab.p);
-  if( rc ){
-    sqlite3_free(zErr);
-    goto abort_due_to_error;
-  }
-  if( zErr ){
-    sqlite3VdbeMemSetStr(pOut, zErr, -1, SQLITE_UTF8, sqlite3_free);
-  }
-  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;
-  assert( nArg<=p->napArg );
-  for(i = 0; i<nArg; i++){
-    apArg[i] = &pArgc[i+1];
-  }
-  rc = pModule->xFilter(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;
-  FuncDef nullFunc;
-
-  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;
-  nullFunc.pUserData = 0;
-  nullFunc.funcFlags = SQLITE_RESULT_SUBTYPE;
-  sContext.pFunc = &nullFunc;
-  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];
-    assert( nArg<=p->napArg );
-    for(i=0; i<nArg; i++){
-      assert( memIsValid(pX) );
-      memAboutToChange(p, pX);
-      apArg[i] = pX;
-      pX++;
-    }
-    db->vtabOnConflict = 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 deterministic 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 relevant 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; i<pCtx->argc; 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: GetSubtype P1 P2 * * *
-** Synopsis:  r[P2] = r[P1].subtype
-**
-** Extract the subtype value from register P1 and write that subtype
-** into register P2.  If P1 has no subtype, then P1 gets a NULL.
-*/
-case OP_GetSubtype: {   /* in1 out2 */
-  pIn1 = &aMem[pOp->p1];
-  pOut = &aMem[pOp->p2];
-  if( pIn1->flags & MEM_Subtype ){
-    sqlite3VdbeMemSetInt64(pOut, pIn1->eSubtype);
-  }else{
-    sqlite3VdbeMemSetNull(pOut);
-  }
-  break;
-}
-
-/* Opcode: SetSubtype P1 P2 * * *
-** Synopsis:  r[P2].subtype = r[P1]
-**
-** Set the subtype value of register P2 to the integer from register P1.
-** If P1 is NULL, clear the subtype from p2.
-*/
-case OP_SetSubtype: {   /* in1 out2 */
-  pIn1 = &aMem[pOp->p1];
-  pOut = &aMem[pOp->p2];
-  if( pIn1->flags & MEM_Null ){
-    pOut->flags &= ~MEM_Subtype;
-  }else{
-    assert( pIn1->flags & MEM_Int );
-    pOut->flags |= MEM_Subtype;
-    pOut->eSubtype = (u8)(pIn1->u.i & 0xff);
-  }
-  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; ii<pOp->p3+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*8);
-  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; ii<pOp->p3+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*8);
-  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: {          /* jump0 */
-  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; j<db->nDb; 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; i<p->nOp; 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->p1<p->nCursor );
-  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; i<pOp->p2; 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.  Continue downward to the next opcode.
-*/
-/* Opcode: Explain P1 P2 P3 P4 *
-**
-** This is the same as OP_Noop during normal query execution.  The
-** purpose of this opcode is to hold information about the query
-** plan for the purpose of EXPLAIN QUERY PLAN output.
-**
-** The P4 value is human-readable text that describes the query plan
-** element.  Something like "SCAN t1" or "SEARCH t2 USING INDEX t2x1".
-**
-** The P1 value is the ID of the current element and P2 is the parent
-** element for the case of nested query plan elements.  If P2 is zero
-** then this element is a top-level element.
-**
-** For loop elements, P3 is the estimated code of each invocation of this
-** element.
-**
-** As with all opcodes, the meanings of the parameters for OP_Explain
-** are subject to change from one release to the next.  Applications
-** should not attempt to interpret or use any of the information
-** contained in the OP_Explain opcode.  The information provided by this
-** opcode is intended for testing and debugging use only.
-*/
-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 about 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 );
-  sqlite3VdbeLogAbort(p, rc, pOp, aOp);
-  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
-  */
-  sqlite3VdbeMemSetInt64(&v->aMem[1], 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;
-  int iDb;
-  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 || zColumn==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);
-    }
-    if( pTab && (pTab->tabFlags&TF_HasGenerated)!=0 ){
-      pTab = 0;
-      sqlite3ErrorMsg(&sParse, "cannot open table with generated columns: %s",
-                      zTable);
-    }
-#ifndef SQLITE_OMIT_VIEW
-    if( pTab && IsView(pTab) ){
-      pTab = 0;
-      sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable);
-    }
-#endif
-    if( pTab==0
-     || ((iDb = sqlite3SchemaToIndex(db, pTab->pSchema))==1 &&
-         sqlite3OpenTempDatabase(&sParse))
-    ){
-      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[iDb].zDbSName;
-
-    /* Now search pTab for the exact column. */
-    iCol = sqlite3ColumnIndex(pTab, zColumn);
-    if( iCol<0 ){
-      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; j<pFKey->nCol; j++){
-            if( pFKey->aCol[j].iFrom==iCol ){
-              zFault = "foreign key";
-            }
-          }
-        }
-      }
-#endif
-      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
-        int j;
-        for(j=0; j<pIdx->nKeyCol; 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;
-      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 = SQLITE_OK;
-  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.
-      */
-      if( sqlite3BtreeCursorIsValidNN(p->pCsr)==0 ){
-        /* If the cursor is not currently valid, try to reseek it. This
-        ** always either fails or finds the correct row - the cursor will
-        ** have been marked permanently CURSOR_INVALID if the open row has
-        ** been deleted.  */
-        int bDiff = 0;
-        rc = sqlite3BtreeCursorRestore(p->pCsr, &bDiff);
-        assert( bDiff==0 || sqlite3BtreeCursorIsValidNN(p->pCsr)==0 );
-      }
-      if( sqlite3BtreeCursorIsValidNN(p->pCsr) ){
-        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
-        );
-      }
-    }
-    if( rc==SQLITE_OK ){
-      rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
-    }
-#else
-    rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
-#endif
-
-    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" multiplied 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 retrieved 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 */
-  i64 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 (Banana<Durian),
-** so the value written into element 1 of the array is 0. As follows:
-**
-**     aTree[] = { X, 0   0, 6    0, 3, 5, 6 }
-**
-** In other words, each time we advance to the next sorter element, log2(N)
-** key comparison operations are required, where N is the number of segments
-** being merged (rounded up to the next power of 2).
-*/
-struct MergeEngine {
-  int nTree;                 /* Used size of aTree/aReadr (power of 2) */
-  SortSubtask *pTask;        /* Used by this thread only */
-  int *aTree;                /* Current state of incremental merge */
-  PmaReader *aReadr;         /* Array of PmaReaders to merge data from */
-};
-
-/*
-** This object represents a single thread of control in a sort operation.
-** Exactly VdbeSorter.nTask instances of this object are allocated
-** as part of each VdbeSorter object. Instances are never allocated any
-** other way. VdbeSorter.nTask is set to the number of worker threads allowed
-** (see SQLITE_CONFIG_WORKER_THREADS) plus one (the main thread).  Thus for
-** single-threaded operation, there is exactly one instance of this object
-** and for multi-threaded operation there are two or more instances.
-**
-** Essentially, this structure contains all those fields of the VdbeSorter
-** structure for which each thread requires a separate instance. For example,
-** each thread requeries its own UnpackedRecord object to unpack records in
-** as part of comparison operations.
-**
-** Before a background thread is launched, variable bDone is set to 0. Then,
-** right before it exits, the thread itself sets bDone to 1. This is used for
-** two purposes:
-**
-**   1. When flushing the contents of memory to a level-0 PMA on disk, to
-**      attempt to select a SortSubtask for which there is not already an
-**      active background thread (since doing so causes the main thread
-**      to block until it finishes).
-**
-**   2. If SQLITE_DEBUG_SORTER_THREADS is defined, to determine if a call
-**      to sqlite3ThreadJoin() is likely to block. Cases that are likely to
-**      block provoke debugging output.
-**
-** In both cases, the effects of the main thread seeing (bDone==0) even
-** after the thread has finished are not dire. So we don't worry about
-** memory barriers and such here.
-*/
-typedef int (*SorterCompare)(SortSubtask*,int*,const void*,int,const void*,int);
-struct SortSubtask {
-  SQLiteThread *pThread;          /* Background thread, if any */
-  int bDone;                      /* Set if thread is finished but not joined */
-  int nPMA;                       /* Number of PMAs currently in file */
-  VdbeSorter *pSorter;            /* Sorter that owns this sub-task */
-  UnpackedRecord *pUnpacked;      /* Space to unpack a record */
-  SorterList list;                /* List for thread to write to a PMA */
-  SorterCompare xCompare;         /* Compare function to use */
-  SorterFile file;                /* Temp file for level-0 PMAs */
-  SorterFile file2;               /* Space for other PMAs */
-  u64 nSpill;                     /* Total bytes written by this task */
-};
-
-
-/*
-** Main sorter structure. A single instance of this is allocated for each
-** sorter cursor created by the VDBE.
-**
-** mxKeysize:
-**   As records are added to the sorter by calls to sqlite3VdbeSorterWrite(),
-**   this variable is updated so as to be set to the size on disk of the
-**   largest record in the sorter.
-*/
-struct VdbeSorter {
-  int mnPmaSize;                  /* Minimum PMA size, in bytes */
-  int mxPmaSize;                  /* Maximum PMA size, in bytes.  0==no limit */
-  int mxKeysize;                  /* Largest serialized key seen so far */
-  int pgsz;                       /* Main database page size */
-  PmaReader *pReader;             /* Readr data from here after Rewind() */
-  MergeEngine *pMerger;           /* Or here, if bUseThreads==0 */
-  sqlite3 *db;                    /* Database connection */
-  KeyInfo *pKeyInfo;              /* How to compare records */
-  UnpackedRecord *pUnpacked;      /* Used by VdbeSorterCompare() */
-  SorterList list;                /* List of in-memory records */
-  int iMemory;                    /* Offset of free space in list.aMemory */
-  int nMemory;                    /* Size of list.aMemory allocation in bytes */
-  u8 bUsePMA;                     /* True if one or more PMAs created */
-  u8 bUseThreads;                 /* True to use background threads */
-  u8 iPrev;                       /* Previous thread used to flush PMA */
-  u8 nTask;                       /* Size of aTask[] array */
-  u8 typeMask;
-  SortSubtask aTask[FLEXARRAY];   /* One or more subtasks */
-};
-
-/* Size (in bytes) of a VdbeSorter object that works with N or fewer subtasks */
-#define SZ_VDBESORTER(N)  (offsetof(VdbeSorter,aTask)+(N)*sizeof(SortSubtask))
-
-#define SORTER_TYPE_INTEGER 0x01
-#define SORTER_TYPE_TEXT    0x02
-
-/*
-** An instance of the following object is used to read records out of a
-** PMA, in sorted order.  The next key to be read is cached in nKey/aKey.
-** aKey might point into aMap or into aBuffer.  If neither of those locations
-** contain a contiguous representation of the key, then aAlloc is allocated
-** and the key is copied into aAlloc and aKey is made to point to aAlloc.
-**
-** pFd==0 at EOF.
-*/
-struct PmaReader {
-  i64 iReadOff;               /* Current read offset */
-  i64 iEof;                   /* 1 byte past EOF for this PmaReader */
-  int nAlloc;                 /* Bytes of space at aAlloc */
-  int nKey;                   /* Number of bytes in key */
-  sqlite3_file *pFd;          /* File handle we are reading from */
-  u8 *aAlloc;                 /* Space for aKey if aBuffer and pMap wont work */
-  u8 *aKey;                   /* Pointer to current key */
-  u8 *aBuffer;                /* Current read buffer */
-  int nBuffer;                /* Size of read buffer in bytes */
-  u8 *aMap;                   /* Pointer to mapping of entire file */
-  IncrMerger *pIncr;          /* Incremental merger */
-};
-
-/*
-** Normally, a PmaReader object iterates through an existing PMA stored
-** within a temp file. However, if the PmaReader.pIncr variable points to
-** an object of the following type, it may be used to iterate/merge through
-** multiple PMAs simultaneously.
-**
-** There are two types of IncrMerger object - single (bUseThread==0) and
-** multi-threaded (bUseThread==1).
-**
-** A multi-threaded IncrMerger object uses two temporary files - aFile[0]
-** and aFile[1]. Neither file is allowed to grow to more than mxSz bytes in
-** size. When the IncrMerger is initialized, it reads enough data from
-** pMerger to populate aFile[0]. It then sets variables within the
-** corresponding PmaReader object to read from that file and kicks off
-** a background thread to populate aFile[1] with the next mxSz bytes of
-** sorted record data from pMerger.
-**
-** When the PmaReader reaches the end of aFile[0], it blocks until the
-** background thread has finished populating aFile[1]. It then exchanges
-** the contents of the aFile[0] and aFile[1] variables within this structure,
-** sets the PmaReader fields to read from the new aFile[0] and kicks off
-** another background thread to populate the new aFile[1]. And so on, until
-** the contents of pMerger are exhausted.
-**
-** A single-threaded IncrMerger does not open any temporary files of its
-** own. Instead, it has exclusive access to mxSz bytes of space beginning
-** at offset iStartOff of file pTask->file2. 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 */
-  u64 nPmaSpill;                  /* Total number of bytes written */
-};
-
-/*
-** 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->nAlloc<nByte ){
-      u8 *aNew;
-      sqlite3_int64 nNew = MAX(128, 2*(sqlite3_int64)p->nAlloc);
-      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 = 0;              /* 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 );
-      assert( aNext!=0 );
-      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(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(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 );
-    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; i<n; i++){
-      if( (res = v1[i] - v2[i])!=0 ){
-        if( ((v1[0] ^ v2[0]) & 0x80)!=0 ){
-          res = v1[0] & 0x80 ? -1 : +1;
-        }
-        break;
-      }
-    }
-  }else if( s1>7 && 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;
-    }
-  }
-
-  assert( pTask->pSorter->pKeyInfo->aSortFlags!=0 );
-  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 */
-  i64 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 );
-  assert( sizeof(KeyInfo) + UMXV(pCsr->pKeyInfo->nKeyField)*sizeof(CollSeq*)
-               < 0x7fffffff );
-  assert( pCsr->pKeyInfo->nKeyField<=pCsr->pKeyInfo->nAllField );
-  szKeyInfo = SZ_KEYINFO(pCsr->pKeyInfo->nAllField);
-  sz = SZ_VDBESORTER(nWorker+1);
-
-  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;
-      assert( nField<=pCsr->pKeyInfo->nAllField );
-    }
-    /* It is OK that pKeyInfo reuses the aSortFlags field from pCsr->pKeyInfo,
-    ** since the pCsr->pKeyInfo->aSortFlags[] array is invariant and lives
-    ** longer that pSorter. */
-    assert( pKeyInfo->aSortFlags==pCsr->pKeyInfo->aSortFlags );
-    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; i<pSorter->nTask; 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 */
-  i64 nByte;                      /* Total bytes of space to allocate */
-  MergeEngine *pNew;              /* Pointer to allocated object to return */
-
-  assert( nReader<=SORTER_MAX_MERGE_COUNT );
-
-  while( N<nReader ) N += N;
-  nByte = sizeof(MergeEngine) + N * (sizeof(int) + sizeof(PmaReader));
-
-  pNew = sqlite3FaultSim(100) ? 0 : (MergeEngine*)sqlite3MallocZero(nByte);
-  if( pNew ){
-    pNew->nTree = 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; i<pMerger->nTree; 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; i<pSorter->nTask; 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 ){
-    /* Increment db->nSpill by the total number of bytes of data written
-    ** to temp files by this sort operation.  */
-    int ii;
-    for(ii=0; ii<pSorter->nTask; ii++){
-      db->nSpill += pSorter->aTask[ii].nSpill;
-    }
-    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.iNext<sqlite3MallocSize(pList->aMemory) );
-        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]);
-      /* ,--Each aSlot[] holds twice as much as the previous. So we cannot use
-      ** |  up all 64 aSlots[] with only a 64-bit address space.
-      ** v                                                                */
-      assert( i<ArraySize(aSlot) );
-      aSlot[i] = 0;
-    }
-    aSlot[i] = p;
-    p = pNext;
-  }
-
-  p = 0;
-  for(i=0; i<ArraySize(aSlot); i++){
-    if( aSlot[i]==0 ) continue;
-    p = p ? vdbeSorterMerge(pTask, p, aSlot[i]) : aSlot[i];
-  }
-  pList->pList = 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->nPmaSpill += (p->iBufEnd - p->iBufStart);
-      p->iBufStart = p->iBufEnd = 0;
-      p->iWriteOff += p->nBuffer;
-    }
-    assert( p->iBufEnd<p->nBuffer );
-
-    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. Also, increment (*pnSpill) by the total
-** number of bytes written to the file.
-*/
-static int vdbePmaWriterFinish(PmaWriter *p, i64 *piEof, u64 *pnSpill){
-  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
-    );
-    p->nPmaSpill += (p->iBufEnd - p->iBufStart);
-  }
-  *piEof = (p->iWriteOff + p->iBufEnd);
-  *pnSpill += p->nPmaSpill;
-  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, &pTask->nSpill);
-  }
-
-  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 (pReadr1<pReadr2).  */
-      if( iRes<0 || (iRes==0 && pReadr1<pReadr2) ){
-        pMerger->aTree[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 preferred as they use background threads - the final
-  ** sub-task uses the main thread. */
-  for(i=0; i<nWorker; i++){
-    int iTest = (pSorter->iPrev + 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 */
-  i64 nReq;                       /* Bytes of memory required */
-  i64 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, &pTask->nSpill);
-  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( iOut<pMerger->nTree && 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; i<nTree; i++){
-    if( SQLITE_MAX_WORKER_THREADS>0 && 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-threaded 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; i<nPMA && rc==SQLITE_OK; i++){
-    i64 nDummy = 0;
-    PmaReader *pReadr = &pNew->aReadr[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; i<nDepth; i++){
-    nDiv = nDiv * SORTER_MAX_MERGE_COUNT;
-  }
-
-  for(i=1; i<nDepth && rc==SQLITE_OK; i++){
-    int iIter = (iSeq / nDiv) % SORTER_MAX_MERGE_COUNT;
-    PmaReader *pReadr = &p->aReadr[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 && iTask<pSorter->nTask; 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; i<pTask->nPMA && 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; i<pSorter->nTask; 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 && iTask<pSorter->nTask; 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(nKey, pKey, r2);
-  for(i=0; i<nKeyCol; i++){
-    if( r2->aMem[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,"
-      "nexec INT,"
-      "ncycle INT,"
-      "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 += 20;
-    }
-  }
-  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;
-    }
-
-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
-    case 9:     /* nexec */
-      sqlite3_result_int64(ctx, pOp->nExec);
-      break;
-    case 10:    /* ncycle */
-      sqlite3_result_int64(ctx, pOp->nCycle);
-      break;
-#else
-    case 9:     /* nexec */
-    case 10:    /* ncycle */
-      sqlite3_result_int(ctx, 0);
-      break;
-#endif
-
-    case 20:  /* tables_used.type */
-      sqlite3_result_text(ctx, pCur->zType, -1, SQLITE_STATIC);
-      break;
-    case 21:  /* tables_used.schema */
-      sqlite3_result_text(ctx, pCur->zSchema, -1, SQLITE_STATIC);
-      break;
-    case 22:  /* tables_used.name */
-      sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC);
-      break;
-    case 23:  /* 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 : 10;
-  pIdxInfo->estimatedCost = (double)100;
-  pIdxInfo->estimatedRows = 100;
-  pIdxInfo->idxNum = 0;
-  for(i=0, p=pIdxInfo->aConstraint; i<pIdxInfo->nConstraint; 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,
-  /* xIntegrity  */ 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( size<p->endpoint.iOffset ){
-    FileChunk *pIter = 0;
-    if( size==0 ){
-      memjrnlFreeChunks(p->pFirst);
-      p->pFirst = 0;
-    }else{
-      i64 iOff = p->nChunkSize;
-      for(pIter=p->pFirst; ALWAYS(pIter) && iOff<size; pIter=pIter->pNext){
-        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 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 <stdlib.h> */
-/* #include <string.h> */
-
-
-#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.
-*/
-SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3WalkExprNN(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 && sqlite3WalkExprNN(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 ? sqlite3WalkExprNN(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->fg.isSubquery
-       && sqlite3WalkSelect(pWalker, pItem->u4.pSubq->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
-** decrease 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 && iCol<pEList->nExpr );
-  pOrig = pEList->a[iCol].pExpr;
-  assert( pOrig!=0 );
-  assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
-  if( pExpr->pAggInfo ) return;
-  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 store the original database, table and column names for their
-** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN",
-** and mark the expression-list item by setting ExprList.a[].fg.eEName
-** to ENAME_TAB.
-**
-** Check to see if the zSpan/eEName of the expression-list item passed to this
-** routine matches the zDb, zTab, and zCol.  If any of zDb, zTab, and zCol are
-** NULL then those fields will match anything. Return true if there is a match,
-** or false otherwise.
-**
-** SF_NestedFrom subqueries also store an entry for the implicit rowid (or
-** _rowid_, or oid) column by setting ExprList.a[].fg.eEName to ENAME_ROWID,
-** and setting zSpan to "DATABASE.TABLE.<rowid-alias>". This type of pItem
-** argument matches if zCol is a rowid alias. If it is not NULL, (*pbRowid)
-** is set to 1 if there is this kind of match.
-*/
-SQLITE_PRIVATE int sqlite3MatchEName(
-  const struct ExprList_item *pItem,
-  const char *zCol,
-  const char *zTab,
-  const char *zDb,
-  int *pbRowid
-){
-  int n;
-  const char *zSpan;
-  int eEName = pItem->fg.eEName;
-  if( eEName!=ENAME_TAB && (eEName!=ENAME_ROWID || NEVER(pbRowid==0)) ){
-    return 0;
-  }
-  assert( pbRowid==0 || *pbRowid==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 ){
-    if( eEName==ENAME_TAB && sqlite3StrICmp(zSpan, zCol)!=0 ) return 0;
-    if( eEName==ENAME_ROWID && sqlite3IsRowid(zCol)==0 ) return 0;
-  }
-  if( eEName==ENAME_ROWID ) *pbRowid = 1;
-  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 );
-  assert( n < pExTab->nCol );
-  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)<<n;
-  }
-}
-
-/*
-** Create a new expression term for the column specified by pMatch and
-** iColumn.  Append this new expression term to the FULL JOIN Match set
-** in *ppList.  Create a new *ppList if this is the first term in the
-** set.
-*/
-static void extendFJMatch(
-  Parse *pParse,          /* Parsing context */
-  ExprList **ppList,      /* ExprList to extend */
-  SrcItem *pMatch,        /* Source table containing the column */
-  i16 iColumn             /* The column number */
-){
-  Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0);
-  if( pNew ){
-    pNew->iTable = pMatch->iCursor;
-    pNew->iColumn = iColumn;
-    pNew->y.pTab = pMatch->pSTab;
-    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 */
-  const char *zDb           /* 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( zDb==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 Expr *pRight,  /* 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 potential "rowid" matches */
-  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 */
-  ExprList *pFJMatch = 0;           /* Matches for FULL JOIN .. USING */
-  const char *zCol = pRight->u.zToken;
-
-  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; i<db->nDb; 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; i<pSrcList->nSrc; i++, pItem++){
-        pTab = pItem->pSTab;
-        assert( pTab!=0 && pTab->zName!=0 );
-        assert( pTab->nCol>0 || pParse->nErr );
-        assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem));
-        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;
-          Select *pSel;
-          assert( pItem->fg.isSubquery );
-          assert( pItem->u4.pSubq!=0 );
-          pSel = pItem->u4.pSubq->pSelect;
-          assert( pSel!=0 );
-          pEList = pSel->pEList;
-          assert( pEList!=0 );
-          assert( pEList->nExpr==pTab->nCol );
-          for(j=0; j<pEList->nExpr; j++){
-            int bRowid = 0;       /* True if possible rowid match */
-            if( !sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb, &bRowid) ){
-              continue;
-            }
-            if( bRowid==0 ){
-              if( cnt>0 ){
-                if( pItem->fg.isUsing==0
-                 || sqlite3IdListIndex(pItem->u3.pUsing, zCol)<0
-                 || pMatch==pItem
-                ){
-                  /* Two or more tables have the same column name which is
-                  ** not joined by USING. Or, a single table has two columns
-                  ** that match a USING term (if pMatch==pItem). These are both
-                  ** "ambiguous column name" errors. 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++;
-              hit = 1;
-            }else if( cnt>0 ){
-              /* This is a potential rowid match, but there has already been
-              ** a real match found. So this can be ignored.  */
-              continue;
-            }
-            cntTab++;
-            pMatch = pItem;
-            pExpr->iColumn = j;
-            pEList->a[j].fg.bUsed = 1;
-
-            /* rowid cannot be part of a USING clause - assert() this. */
-            assert( bRowid==0 || pEList->a[j].fg.bUsingTerm==0 );
-            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, zDb) ) continue;
-          }
-          assert( ExprUseYTab(pExpr) );
-          if( IN_RENAME_OBJECT && pItem->zAlias ){
-            sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
-          }
-        }
-        j = sqlite3ColumnIndex(pTab, zCol);
-        if( j>=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);
-          }
-        }
-        if( 0==cnt && VisibleRowid(pTab) ){
-          /* pTab is a potential ROWID match.  Keep track of it and match
-          ** the ROWID later if that seems appropriate.  (Search for "cntTab"
-          ** to find related code.)  Only allow a ROWID match if there is
-          ** a single ROWID match candidate.
-          */
-#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
-          /* In SQLITE_ALLOW_ROWID_IN_VIEW mode, allow a ROWID match
-          ** if there is a single VIEW candidate or if there is a single
-          ** non-VIEW candidate plus multiple VIEW candidates.  In other
-          ** words non-VIEW candidate terms take precedence over VIEWs.
-          */
-          if( cntTab==0
-           || (cntTab==1
-               && pMatch!=0
-               && ALWAYS(pMatch->pSTab!=0)
-               && (pMatch->pSTab->tabFlags & TF_Ephemeral)!=0
-               && (pTab->tabFlags & TF_Ephemeral)==0)
-          ){
-            cntTab = 1;
-            pMatch = pItem;
-          }else{
-            cntTab++;
-          }
-#else
-          /* The (much more common) non-SQLITE_ALLOW_ROWID_IN_VIEW case is
-          ** simpler since we require exactly one candidate, which will
-          ** always be a non-VIEW
-          */
-          cntTab++;
-          pMatch = pItem;
-#endif
-        }
-      }
-      if( pMatch ){
-        pExpr->iTable = pMatch->iCursor;
-        assert( ExprUseYTab(pExpr) );
-        pExpr->y.pTab = pMatch->pSTab;
-        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
-                     || isValidSchemaTableName(zTab, pParse->pTriggerTab, 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].pSTab;
-          pExpr->iTable = EXCLUDED_TABLE_NUMBER;
-        }
-      }
-#endif /* SQLITE_OMIT_UPSERT */
-
-      if( pTab ){
-        int iCol;
-        pSchema = pTab->pSchema;
-        cntTab++;
-        iCol = sqlite3ColumnIndex(pTab, zCol);
-        if( iCol>=0 ){
-          if( pTab->iPKey==iCol ) iCol = -1;
-        }else{
-          if( sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
-            iCol = -1;
-          }else{
-            iCol = pTab->nCol;
-          }
-        }
-        if( iCol<pTab->nCol ){
-          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)<<iCol));
-              }else{
-                testcase( iCol==31 );
-                testcase( iCol==32 );
-                pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
-              }
-#endif /* SQLITE_OMIT_TRIGGER */
-            }
-          }
-        }
-      }
-    }
-#endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */
-
-    /*
-    ** Perhaps the name is a reference to the ROWID
-    */
-    if( cnt==0
-     && cntTab>=1
-     && pMatch
-     && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0
-     && sqlite3IsRowid(zCol)
-     && ALWAYS(VisibleRowid(pMatch->pSTab) || pMatch->fg.isNestedFrom)
-    ){
-      cnt = cntTab;
-#if SQLITE_ALLOW_ROWID_IN_VIEW+0==2
-      if( pMatch->pSTab!=0 && IsView(pMatch->pSTab) ){
-        eNewExprOp = TK_NULL;
-      }
-#endif
-      if( pMatch->fg.isNestedFrom==0 ) 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; j<pEList->nExpr; 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 if( cnt==0 && ExprHasProperty(pRight,EP_DblQuoted) ){
-      sqlite3ErrorMsg(pParse, "%s: \"%s\" - should this be a"
-                              " string literal in single-quotes?",
-                              zErr, zCol);
-    }else{
-      sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
-    }
-    sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
-    pParse->checkSchema = 1;
-    pTopNC->nNcErr++;
-    eNewExprOp = TK_NULL;
-  }
-  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( pMatch ){
-    if( pExpr->iColumn>=0 ){
-      pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
-    }else{
-      pMatch->fg.rowidUsed = 1;
-    }
-  }
-
-  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->pSTab;
-    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 134,217,728 (2^27) 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);
-  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; i<pNC->pSrcList->nSrc; i++){
-      assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
-    }
-  }
-#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->pSTab;
-      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.
-    **
-    ** 2024-03-28: Beware of aggregates.  A bare column of aggregated table
-    ** can still evaluate to NULL even though it is marked as NOT NULL.
-    ** Example:
-    **
-    **       CREATE TABLE t1(a INT NOT NULL);
-    **       SELECT a, a IS NULL, a IS NOT NULL, count(*) FROM t1;
-    **
-    ** The "a IS NULL" and "a IS NOT NULL" expressions cannot be optimized
-    ** here because at the time this case is hit, we do not yet know whether
-    ** or not t1 is being aggregated.  We have to assume the worst and omit
-    ** the optimization.  The only time it is safe to apply this optimization
-    ** is within the WHERE clause.
-    */
-    case TK_NOTNULL:
-    case TK_ISNULL: {
-      int anRef[8];
-      NameContext *p;
-      int i;
-      for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
-        anRef[i] = p->nRef;
-      }
-      sqlite3WalkExpr(pWalker, pExpr->pLeft);
-      if( IN_RENAME_OBJECT ) return WRC_Prune;
-      if( sqlite3ExprCanBeNull(pExpr->pLeft) ){
-        /* The expression can be NULL.  So the optimization does not apply */
-        return WRC_Prune;
-      }
-
-      for(i=0, p=pNC; p; p=p->pNext, i++){
-        if( (p->ncFlags & NC_Where)==0 ){
-          return WRC_Prune;  /* Not in a WHERE clause.  Unsafe to optimize. */
-        }
-      }
-      testcase( ExprHasProperty(pExpr, EP_OuterON) );
-      assert( !ExprHasProperty(pExpr, EP_IntValue) );
-#if TREETRACE_ENABLED
-      if( sqlite3TreeTrace & 0x80000 ){
-        sqlite3DebugPrintf(
-           "NOT NULL strength reduction converts the following to %d:\n",
-           pExpr->op==TK_NOTNULL
-        );
-        sqlite3ShowExpr(pExpr);
-      }
-#endif /* TREETRACE_ENABLED */
-      pExpr->u.iValue = (pExpr->op==TK_NOTNULL);
-      pExpr->flags |= EP_IntValue;
-      pExpr->op = TK_INTEGER;
-      for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, 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 *zTable;
-      const char *zDb;
-      Expr *pRight;
-
-      if( pExpr->op==TK_ID ){
-        zDb = 0;
-        zTable = 0;
-        assert( !ExprHasProperty(pExpr, EP_IntValue) );
-        pRight = pExpr;
-      }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;
-        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, pRight, pNC, pExpr);
-    }
-
-    /* Resolve function names
-    */
-    case TK_FUNCTION: {
-      ExprList *pList;            /* The argument list */
-      int n;                      /* 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) );
-      assert( pExpr->pLeft==0 || pExpr->pLeft->op==TK_ORDER );
-      pList = pExpr->x.pList;
-      n = pList ? pList->nExpr : 0;
-      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 the function may call sqlite3_value_subtype(), then set the
-        ** EP_SubtArg flag on all of its argument expressions. This prevents
-        ** where.c from replacing the expression with a value read from an
-        ** index on the same expression, which will not have the correct
-        ** subtype. Also set the flag if the function expression itself is
-        ** an EP_SubtArg expression. In this case subtypes are required as
-        ** the function may return a value with a subtype back to its
-        ** caller using sqlite3_result_value().  */
-        if( (pDef->funcFlags & SQLITE_SUBTYPE)
-         || ExprHasProperty(pExpr, EP_SubtArg)
-        ){
-          int ii;
-          for(ii=0; ii<n; ii++){
-            ExprSetProperty(pList->a[ii].pExpr, EP_SubtArg);
-          }
-        }
-
-        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
-          ** allow 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( (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
-        ){
-          if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
-          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
-        else if( is_agg==0 && pExpr->pLeft ){
-          sqlite3ExprOrderByAggregateError(pParse, pExpr);
-          pNC->nNcErr++;
-        }
-        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
-        }
-      }
-      else if( ExprHasProperty(pExpr, EP_WinFunc) || pExpr->pLeft ){
-        is_agg = 1;
-      }
-      sqlite3WalkExprList(pWalker, pList);
-      if( is_agg ){
-        if( pExpr->pLeft ){
-          assert( pExpr->pLeft->op==TK_ORDER );
-          assert( ExprUseXList(pExpr->pLeft) );
-          sqlite3WalkExprList(pWalker, pExpr->pLeft->x.pList);
-        }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-        if( pWin && pParse->nErr==0 ){
-          Select *pSel = pNC->pWinSelect;
-          assert( 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 += (1 + pNC2->nNestedSelect);
-            pNC2 = pNC2->pNext;
-          }
-          assert( pDef!=0 || IN_RENAME_OBJECT );
-          if( pNC2 && pDef ){
-            pExpr->op2 += pNC2->nNestedSelect;
-            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_EXISTS:
-    case TK_SELECT:
-#endif
-    case TK_IN: {
-      testcase( pExpr->op==TK_IN );
-      testcase( pExpr->op==TK_EXISTS );
-      testcase( pExpr->op==TK_SELECT );
-      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 );
-        assert( pExpr->x.pSelect );
-        if( pExpr->op==TK_EXISTS )  pParse->bHasExists = 1;
-        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);
-          pExpr->x.pSelect->selFlags |= SF_Correlated;
-        }
-        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; i<pEList->nExpr; 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)==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; i<pEList->nExpr; 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; i<pOrderBy->nExpr; 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; i<pOrderBy->nExpr; 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, 0) ){
-        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 = sqlite3ExprInt32(db, iCol);
-          if( pNew==0 ) return 1;
-          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; i<pOrderBy->nExpr; 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; i<pOrderBy->nExpr; 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; i<pOrderBy->nExpr; 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, 0) ){
-      /* 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; j<pSelect->pEList->nExpr; j++){
-      if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
-        /* Since this expression 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 );
-    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;
-      assert( p->pSrc->a[0].fg.isSubquery );
-      assert( p->pSrc->a[0].u4.pSubq!=0 );
-      pSub = p->pSrc->a[0].u4.pSubq->pSelect;
-      assert( pSub!=0 );
-      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
-    */
-    if( pOuterNC ) pOuterNC->nNestedSelect++;
-    for(i=0; i<p->pSrc->nSrc; i++){
-      SrcItem *pItem = &p->pSrc->a[i];
-      assert( pItem->zName!=0
-              || pItem->fg.isSubquery );  /* Test of tag-20240424-1*/
-      if( pItem->fg.isSubquery
-       && (pItem->u4.pSubq->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->u4.pSubq->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);
-        }
-      }
-    }
-    if( pOuterNC && ALWAYS(pOuterNC->nNestedSelect>0) ){
-      pOuterNC->nNestedSelect--;
-    }
-
-    /* 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;
-    }
-    sNC.ncFlags |= NC_Where;
-    if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
-    sNC.ncFlags &= ~NC_Where;
-
-    /* Resolve names in table-valued-function arguments */
-    for(i=0; i<p->pSrc->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
-
-    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;
-      assert( p->pSrc->a[0].fg.isSubquery );
-      pSub = p->pSrc->a[0].u4.pSubq->pSelect;
-      assert( pSub!=0 );
-      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; i<pGroupBy->nExpr; 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;
-    }
-
-    /* If the SELECT statement contains ON clauses that were moved into
-    ** the WHERE clause, go through and verify that none of the terms
-    ** in the ON clauses reference tables to the right of the ON clause. */
-    if( (p->selFlags & SF_OnToWhere) ){
-      sqlite3SelectCheckOnClauses(pParse, p);
-      if( pParse->nErr ) 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
-  assert( pExpr!=0 );
-  sqlite3WalkExprNN(&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.
-**
-** The return value is SQLITE_OK (0) for success or SQLITE_ERROR (1) for a
-** failure.
-*/
-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 SQLITE_OK;
-  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; i<pList->nExpr; 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 SQLITE_ERROR;
-    }
-#endif
-    sqlite3WalkExprNN(&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 SQLITE_ERROR;
-  }
-  pNC->ncFlags |= savedHasAgg;
-  return SQLITE_OK;
-}
-
-/*
-** Resolve all names in all expressions of a SELECT and in all
-** descendants 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 *pSrc;                  /* Fake SrcList for pParse->pNewTable */
-  NameContext sNC;                /* Name context for pParse->pNewTable */
-  int rc;
-  union {
-    SrcList sSrc;
-    u8 srcSpace[SZ_SRCLIST_1];     /* Memory space for the fake SrcList */
-  } uSrc;
-
-  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(&uSrc, 0, sizeof(uSrc));
-  pSrc = &uSrc.sSrc;
-  if( pTab ){
-    pSrc->nSrc = 1;
-    pSrc->a[0].zName = pTab->zName;
-    pSrc->a[0].pSTab = pTab;
-    pSrc->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 = pSrc;
-  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->iColumn >= 0 );
-      assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );
-      return sqlite3ExprAffinity(
-          pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
-      );
-    }
-    if( op==TK_VECTOR
-     || (op==TK_FUNCTION && pExpr->affExpr==SQLITE_AFF_DEFER)
-    ){
-      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 ) break;
-    op = pExpr->op2;
-    if( NEVER( op==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; ii<pList->nExpr; 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 if( pExpr->op==TK_COLLATE ){
-      pExpr = pExpr->pLeft;
-    }else{
-      break;
-    }
-  }
-  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
-     || (op==TK_FUNCTION && p->affExpr==SQLITE_AFF_DEFER)
-    ){
-      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; i<p->x.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
-** default 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( aff<SQLITE_AFF_TEXT ){
-    return 1;
-  }
-  if( aff==SQLITE_AFF_TEXT ){
-    return idx_affinity==SQLITE_AFF_TEXT;
-  }
-  return sqlite3IsNumericAffinity(idx_affinity);
-}
-
-/*
-** Return the P5 value that should be used for a binary comparison
-** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
-*/
-static u8 binaryCompareP5(
-  const Expr *pExpr1,   /* Left operand */
-  const Expr *pExpr2,   /* Right operand */
-  int jumpIfNull        /* Extra flags added to P5 */
-){
-  u8 aff = (char)sqlite3ExprAffinity(pExpr2);
-  aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull;
-  return aff;
-}
-
-/*
-** Return a pointer to the collation sequence that should be used by
-** a binary comparison operator comparing pLeft and pRight.
-**
-** If the left hand expression has a collating sequence type, then it is
-** used. Otherwise the collation sequence for the right hand expression
-** is used, or the default (BINARY) if neither expression has a collating
-** type.
-**
-** Argument pRight (but not pLeft) may be a null pointer. In this case,
-** it is not considered.
-*/
-SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq(
-  Parse *pParse,
-  const Expr *pLeft,
-  const Expr *pRight
-){
-  CollSeq *pColl;
-  assert( pLeft );
-  if( pLeft->flags & 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;
-}
-
-/* Expression 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, (u16)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( i<sqlite3ExprVectorSize(pVector) || pVector->op==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 ){
-      ExprSetProperty(pRet, EP_FullSize);
-      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 && i<nLeft );
-    if( addrCmp ) sqlite3VdbeJumpHere(v, addrCmp);
-    r1 = exprVectorRegister(pParse, pLeft, i, regLeft, &pL, &regFree1);
-    r2 = exprVectorRegister(pParse, pRight, i, regRight, &pR, &regFree2);
-    addrCmp = sqlite3VdbeCurrentAddr(v);
-    codeCompare(pParse, pL, pR, opx, r1, r2, addrDone, p5, isCommuted);
-    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);
-    testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
-    testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
-    testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
-    sqlite3ReleaseTempReg(pParse, regFree1);
-    sqlite3ReleaseTempReg(pParse, regFree2);
-    if( (opx==TK_LT || opx==TK_GT) && i<nLeft-1 ){
-      addrCmp = sqlite3VdbeAddOp0(v, OP_ElseEq);
-      testcase(opx==TK_LT); VdbeCoverageIf(v,opx==TK_LT);
-      testcase(opx==TK_GT); VdbeCoverageIf(v,opx==TK_GT);
-    }
-    if( p5==SQLITE_NULLEQ ){
-      sqlite3VdbeAddOp2(v, OP_Integer, 0, dest);
-    }else{
-      sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, dest, r2);
-    }
-    if( i==nLeft-1 ){
-      break;
-    }
-    if( opx==TK_EQ ){
-      sqlite3VdbeAddOp2(v, OP_NotNull, dest, addrDone); VdbeCoverage(v);
-    }else{
-      assert( op==TK_LT || op==TK_GT || op==TK_LE || op==TK_GE );
-      sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone);
-      if( i==nLeft-2 ) opx = op;
-    }
-  }
-  sqlite3VdbeJumpHere(v, addrCmp);
-  sqlite3VdbeResolveLabel(v, addrDone);
-  if( op==TK_NE ){
-    sqlite3VdbeAddOp2(v, OP_Not, dest, dest);
-  }
-}
-
-#if SQLITE_MAX_EXPR_DEPTH>0
-/*
-** 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; i<p->nExpr; 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 */
-
-/*
-** Set the error offset for an Expr node, if possible.
-*/
-SQLITE_PRIVATE void sqlite3ExprSetErrorOffset(Expr *pExpr, int iOfst){
-  if( pExpr==0 ) return;
-  if( NEVER(ExprUseWJoin(pExpr)) ) return;
-  pExpr->w.iOfst = iOfst;
-}
-
-/*
-** 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 (tag-20240227-a):  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.
-** See also tag-20240227-b.
-*/
-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 = pToken ? pToken->n+1 : 0;
-
-  assert( db!=0 );
-  pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra);
-  if( pNew ){
-    memset(pNew, 0, sizeof(Expr));
-    pNew->op = (u8)op;
-    pNew->iAgg = -1;
-    if( nExtra ){
-      assert( pToken!=0 );
-      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);
-}
-
-/*
-** Allocate an expression for a 32-bit signed integer literal.
-*/
-SQLITE_PRIVATE Expr *sqlite3ExprInt32(sqlite3 *db, int iVal){
-  Expr *pNew = sqlite3DbMallocRawNN(db, sizeof(Expr));
-  if( pNew ){
-    memset(pNew, 0, sizeof(Expr));
-    pNew->op = TK_INTEGER;
-    pNew->iAgg = -1;
-    pNew->flags = EP_IntValue|EP_Leaf|(iVal?EP_IsTrue:EP_IsFalse);
-    pNew->u.iValue = iVal;
-#if SQLITE_MAX_EXPR_DEPTH>0
-    pNew->nHeight = 1;
-#endif
-  }
-  return pNew;
-}
-
-/*
-** 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; ii<pEList->nExpr; 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_HasFunc))==EP_IsFalse
-     && !IN_RENAME_OBJECT
-    ){
-      sqlite3ExprDeferredDelete(pParse, pLeft);
-      sqlite3ExprDeferredDelete(pParse, pRight);
-      return sqlite3ExprInt32(db, 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;
-}
-
-/*
-** Report an error when attempting to use an ORDER BY clause within
-** the arguments of a non-aggregate function.
-*/
-SQLITE_PRIVATE void sqlite3ExprOrderByAggregateError(Parse *pParse, Expr *p){
-  sqlite3ErrorMsg(pParse,
-     "ORDER BY may not be used with non-aggregate %#T()", p
-  );
-}
-
-/*
-** Attach an ORDER BY clause to a function call.
-**
-**     functionname( arguments ORDER BY sortlist )
-**     \_____________________/          \______/
-**             pExpr                    pOrderBy
-**
-** The ORDER BY clause is inserted into a new Expr node of type TK_ORDER
-** and added to the Expr.pLeft field of the parent TK_FUNCTION node.
-*/
-SQLITE_PRIVATE void sqlite3ExprAddFunctionOrderBy(
-  Parse *pParse,        /* Parsing context */
-  Expr *pExpr,          /* The function call to which ORDER BY is to be added */
-  ExprList *pOrderBy    /* The ORDER BY clause to add */
-){
-  Expr *pOB;
-  sqlite3 *db = pParse->db;
-  if( NEVER(pOrderBy==0) ){
-    assert( db->mallocFailed );
-    return;
-  }
-  if( pExpr==0 ){
-    assert( db->mallocFailed );
-    sqlite3ExprListDelete(db, pOrderBy);
-    return;
-  }
-  assert( pExpr->op==TK_FUNCTION );
-  assert( pExpr->pLeft==0 );
-  assert( ExprUseXList(pExpr) );
-  if( pExpr->x.pList==0 || NEVER(pExpr->x.pList->nExpr==0) ){
-    /* Ignore ORDER BY on zero-argument aggregates */
-    sqlite3ParserAddCleanup(pParse, sqlite3ExprListDeleteGeneric, pOrderBy);
-    return;
-  }
-  if( IsWindowFunc(pExpr) ){
-    sqlite3ExprOrderByAggregateError(pParse, pExpr);
-    sqlite3ExprListDelete(db, pOrderBy);
-    return;
-  }
-  if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
-    sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
-    sqlite3ExprListDelete(db, pOrderBy);
-    return;
-  }
-
-  pOB = sqlite3ExprAlloc(db, TK_ORDER, 0, 0);
-  if( pOB==0 ){
-    sqlite3ExprListDelete(db, pOrderBy);
-    return;
-  }
-  pOB->x.pList = pOrderBy;
-  assert( ExprUseXList(pOB) );
-  pExpr->pLeft = pOB;
-  ExprSetProperty(pOB, EP_FullSize);
-}
-
-/*
-** 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)
-   || pParse->prepFlags & SQLITE_PREPARE_FROM_DDL
-  ){
-    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 );
-exprDeleteRestart:
-  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->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( p->pLeft && p->op!=TK_SELECT_COLUMN ){
-      Expr *pLeft = p->pLeft;
-      if( !ExprHasProperty(p, EP_Static)
-       && !ExprHasProperty(pLeft, EP_Static)
-      ){
-        /* Avoid unnecessary recursion on unary operators */
-        sqlite3DbNNFreeNN(db, p);
-        p = pLeft;
-        goto exprDeleteRestart;
-      }else{
-        sqlite3ExprDeleteNN(db, pLeft);
-      }
-    }
-  }
-  if( !ExprHasProperty(p, EP_Static) ){
-    sqlite3DbNNFreeNN(db, p);
-  }
-}
-SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){
-  if( p ) sqlite3ExprDeleteNN(db, p);
-}
-SQLITE_PRIVATE void sqlite3ExprDeleteGeneric(sqlite3 *db, void *p){
-  if( ALWAYS(p) ) sqlite3ExprDeleteNN(db, (Expr*)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 until the pParse is deleted.
-**
-** The pExpr might be deleted immediately on an OOM error.
-**
-** Return 0 if the delete was successfully deferred.  Return non-zero
-** if the delete happened immediately because of an OOM.
-*/
-SQLITE_PRIVATE int sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
-  return 0==sqlite3ParserAddCleanup(pParse, sqlite3ExprDeleteGeneric, 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 || ExprHasProperty(p, EP_FullSize) ){
-    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 value returned includes space to create a copy of the Expr struct
-** itself and the buffer referred to by Expr.u.zToken, if any.
-**
-** The return value includes space to duplicate all Expr nodes in the
-** tree formed by Expr.pLeft and Expr.pRight, but not any other
-** substructure such as Expr.x.pList, Expr.x.pSelect, and Expr.y.pWin.
-*/
-static int dupedExprSize(const Expr *p){
-  int nByte;
-  assert( p!=0 );
-  nByte = dupedExprNodeSize(p, EXPRDUP_REDUCE);
-  if( p->pLeft ) nByte += dupedExprSize(p->pLeft);
-  if( p->pRight ) nByte += dupedExprSize(p->pRight);
-  assert( nByte==ROUND8(nByte) );
-  return nByte;
-}
-
-/*
-** An EdupBuf is a memory allocation used to stored multiple Expr objects
-** together with their Expr.zToken content.  This is used to help implement
-** compression while doing sqlite3ExprDup().  The top-level Expr does the
-** allocation for itself and many of its decendents, then passes an instance
-** of the structure down into exprDup() so that they decendents can have
-** access to that memory.
-*/
-typedef struct EdupBuf EdupBuf;
-struct EdupBuf {
-  u8 *zAlloc;          /* Memory space available for storage */
-#ifdef SQLITE_DEBUG
-  u8 *zEnd;            /* First byte past the end of memory */
-#endif
-};
-
-/*
-** This function is similar to sqlite3ExprDup(), except that if pEdupBuf
-** is not NULL then it points to memory that can be used to store a copy
-** of the input Expr p together with its p->u.zToken (if any).  pEdupBuf
-** is updated with the new buffer tail prior to returning.
-*/
-static Expr *exprDup(
-  sqlite3 *db,          /* Database connection (for memory allocation) */
-  const Expr *p,        /* Expr tree to be duplicated */
-  int dupFlags,         /* EXPRDUP_REDUCE for compression.  0 if not */
-  EdupBuf *pEdupBuf     /* Preallocated storage space, or NULL */
-){
-  Expr *pNew;           /* Value to return */
-  EdupBuf sEdupBuf;     /* Memory space from which to build Expr object */
-  u32 staticFlag;       /* EP_Static if space not obtained from malloc */
-  int nToken = -1;       /* Space needed for p->u.zToken.  -1 means unknown */
-
-  assert( db!=0 );
-  assert( p );
-  assert( dupFlags==0 || dupFlags==EXPRDUP_REDUCE );
-  assert( pEdupBuf==0 || dupFlags==EXPRDUP_REDUCE );
-
-  /* Figure out where to write the new Expr structure. */
-  if( pEdupBuf ){
-    sEdupBuf.zAlloc = pEdupBuf->zAlloc;
-#ifdef SQLITE_DEBUG
-    sEdupBuf.zEnd = pEdupBuf->zEnd;
-#endif
-    staticFlag = EP_Static;
-    assert( sEdupBuf.zAlloc!=0 );
-    assert( dupFlags==EXPRDUP_REDUCE );
-  }else{
-    int nAlloc;
-    if( dupFlags ){
-      nAlloc = dupedExprSize(p);
-    }else if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
-      nToken = sqlite3Strlen30NN(p->u.zToken)+1;
-      nAlloc = ROUND8(EXPR_FULLSIZE + nToken);
-    }else{
-      nToken = 0;
-      nAlloc = ROUND8(EXPR_FULLSIZE);
-    }
-    assert( nAlloc==ROUND8(nAlloc) );
-    sEdupBuf.zAlloc = sqlite3DbMallocRawNN(db, nAlloc);
-#ifdef SQLITE_DEBUG
-    sEdupBuf.zEnd = sEdupBuf.zAlloc ? sEdupBuf.zAlloc+nAlloc : 0;
-#endif
-
-    staticFlag = 0;
-  }
-  pNew = (Expr *)sEdupBuf.zAlloc;
-  assert( EIGHT_BYTE_ALIGNMENT(pNew) );
-
-  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);
-    int nNewSize = nStructSize & 0xfff;
-    if( nToken<0 ){
-      if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
-        nToken = sqlite3Strlen30(p->u.zToken) + 1;
-      }else{
-        nToken = 0;
-      }
-    }
-    if( dupFlags ){
-      assert( (int)(sEdupBuf.zEnd - sEdupBuf.zAlloc) >= nNewSize+nToken );
-      assert( ExprHasProperty(p, EP_Reduced)==0 );
-      memcpy(sEdupBuf.zAlloc, p, nNewSize);
-    }else{
-      u32 nSize = (u32)exprStructSize(p);
-      assert( (int)(sEdupBuf.zEnd - sEdupBuf.zAlloc) >=
-                                                   (int)EXPR_FULLSIZE+nToken );
-      memcpy(sEdupBuf.zAlloc, p, nSize);
-      if( nSize<EXPR_FULLSIZE ){
-        memset(&sEdupBuf.zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
-      }
-      nNewSize = EXPR_FULLSIZE;
-    }
-
-    /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
-    pNew->flags &= ~(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. */
-    assert( nToken>=0 );
-    if( nToken>0 ){
-      char *zToken = pNew->u.zToken = (char*)&sEdupBuf.zAlloc[nNewSize];
-      memcpy(zToken, p->u.zToken, nToken);
-      nNewSize += nToken;
-    }
-    sEdupBuf.zAlloc += ROUND8(nNewSize);
-
-    if( ((p->flags|pNew->flags)&(EP_TokenOnly|EP_Leaf))==0 ){
-
-      /* 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,
-                           p->op!=TK_ORDER ? dupFlags : 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 */
-
-      /* Fill in pNew->pLeft and pNew->pRight. */
-      if( dupFlags ){
-        if( p->op==TK_SELECT_COLUMN ){
-          pNew->pLeft = p->pLeft;
-          assert( p->pRight==0
-               || p->pRight==p->pLeft
-               || ExprHasProperty(p->pLeft, EP_Subquery) );
-        }else{
-          pNew->pLeft = p->pLeft ?
-                      exprDup(db, p->pLeft, EXPRDUP_REDUCE, &sEdupBuf) : 0;
-        }
-        pNew->pRight = p->pRight ?
-                       exprDup(db, p->pRight, EXPRDUP_REDUCE, &sEdupBuf) : 0;
-      }else{
-        if( p->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);
-      }
-    }
-  }
-  if( pEdupBuf ) memcpy(pEdupBuf, &sEdupBuf, sizeof(sEdupBuf));
-  assert( sEdupBuf.zAlloc <= sEdupBuf.zEnd );
-  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 = SZ_WITH(p->nCte);
-    pRet = sqlite3DbMallocZero(db, nByte);
-    if( pRet ){
-      int i;
-      pRet->nCte = p->nCte;
-      for(i=0; i<p->nCte; 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; i<p->nExpr; 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->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;
-  assert( db!=0 );
-  if( p==0 ) return 0;
-  pNew = sqlite3DbMallocRawNN(db, SZ_SRCLIST(p->nSrc) );
-  if( pNew==0 ) return 0;
-  pNew->nSrc = pNew->nAlloc = p->nSrc;
-  for(i=0; i<p->nSrc; i++){
-    SrcItem *pNewItem = &pNew->a[i];
-    const SrcItem *pOldItem = &p->a[i];
-    Table *pTab;
-    pNewItem->fg = pOldItem->fg;
-    if( pOldItem->fg.isSubquery ){
-      Subquery *pNewSubq = sqlite3DbMallocRaw(db, sizeof(Subquery));
-      if( pNewSubq==0 ){
-        assert( db->mallocFailed );
-        pNewItem->fg.isSubquery = 0;
-      }else{
-        memcpy(pNewSubq, pOldItem->u4.pSubq, sizeof(*pNewSubq));
-        pNewSubq->pSelect = sqlite3SelectDup(db, pNewSubq->pSelect, flags);
-        if( pNewSubq->pSelect==0 ){
-          sqlite3DbFree(db, pNewSubq);
-          pNewSubq = 0;
-          pNewItem->fg.isSubquery = 0;
-        }
-      }
-      pNewItem->u4.pSubq = pNewSubq;
-    }else if( pOldItem->fg.fixedSchema ){
-      pNewItem->u4.pSchema = pOldItem->u4.pSchema;
-    }else{
-      pNewItem->u4.zDatabase = sqlite3DbStrDup(db, pOldItem->u4.zDatabase);
-    }
-    pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
-    pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
-    pNewItem->iCursor = pOldItem->iCursor;
-    if( pNewItem->fg.isIndexedBy ){
-      pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy);
-    }else if( pNewItem->fg.isTabFunc ){
-      pNewItem->u1.pFuncArg =
-          sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags);
-    }else{
-      pNewItem->u1.nRow = pOldItem->u1.nRow;
-    }
-    pNewItem->u2 = pOldItem->u2;
-    if( pNewItem->fg.isCte ){
-      pNewItem->u2.pCteUse->nUse++;
-    }
-    pTab = pNewItem->pSTab = pOldItem->pSTab;
-    if( pTab ){
-      pTab->nTabRef++;
-    }
-    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;
-  pNew = sqlite3DbMallocRawNN(db, SZ_IDLIST(p->nId));
-  if( pNew==0 ) return 0;
-  pNew->nId = p->nId;
-  for(i=0; i<p->nId; i++){
-    struct IdList_item *pNewItem = &pNew->a[i];
-    const struct IdList_item *pOldItem = &p->a[i];
-    pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
-  }
-  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;
-    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().
-**
-** 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, SZ_EXPRLIST(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, SZ_EXPRLIST(pList->nAlloc));
-  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->nAlloc<pList->nExpr+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; i<pColumns->nId; 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);
-}
-SQLITE_PRIVATE void sqlite3ExprListDeleteGeneric(sqlite3 *db, void *pList){
-  if( ALWAYS(pList) ) exprListDeleteNN(db, (ExprList*)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; i<pList->nExpr; 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 = sqlite3ExprSkipCollateAndLikely((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;
-}
-
-/*
-** Return true if it might be advantageous to compute the right operand
-** of expression pExpr first, before the left operand.
-**
-** Normally the left operand is computed before the right operand.  But if
-** the left operand contains a subquery and the right does not, then it
-** might be more efficient to compute the right operand first.
-*/
-static int exprEvalRhsFirst(Expr *pExpr){
-  if( ExprHasProperty(pExpr->pLeft, EP_Subquery)
-   && !ExprHasProperty(pExpr->pRight, EP_Subquery)
-  ){
-    return 1;
-  }else{
-    return 0;
-  }
-}
-
-/*
-** Compute the two operands of a binary operator.
-**
-** If either operand contains a subquery, then the code strives to
-** compute the operand containing the subquery second.  If the other
-** operand evalutes to NULL, then a jump is made.  The address of the
-** IsNull operand that does this jump is returned.  The caller can use
-** this to optimize the computation so as to avoid doing the potentially
-** expensive subquery.
-**
-** If no optimization opportunities exist, return 0.
-*/
-static int exprComputeOperands(
-  Parse *pParse,     /* Parsing context */
-  Expr *pExpr,       /* The comparison expression */
-  int *pR1,          /* OUT: Register holding the left operand */
-  int *pR2,          /* OUT: Register holding the right operand */
-  int *pFree1,       /* OUT: Temp register to free if not zero */
-  int *pFree2        /* OUT: Another temp register to free if not zero */
-){
-  int addrIsNull;
-  int r1, r2;
-  Vdbe *v = pParse->pVdbe;
-
-  assert( v!=0 );
-  /*
-  ** If the left operand contains a (possibly expensive) subquery and the
-  ** right operand does not and the right operation might be NULL,
-  ** then compute the right operand first and do an IsNull jump if the
-  ** right operand evalutes to NULL.
-  */
-  if( exprEvalRhsFirst(pExpr) && sqlite3ExprCanBeNull(pExpr->pRight) ){
-    r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, pFree2);
-    addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, r2);
-    VdbeComment((v, "skip left operand"));
-    VdbeCoverage(v);
-  }else{
-    r2 = 0; /* Silence a false-positive uninit-var warning in MSVC */
-    addrIsNull = 0;
-  }
-  r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, pFree1);
-  if( addrIsNull==0 ){
-    /*
-    ** If the right operand contains a subquery and the left operand does not
-    ** and the left operand might be NULL, then do an IsNull check
-    ** check on the left operand before computing the right operand.
-    */
-    if( ExprHasProperty(pExpr->pRight, EP_Subquery)
-     && sqlite3ExprCanBeNull(pExpr->pLeft)
-    ){
-      addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, r1);
-      VdbeComment((v, "skip right operand"));
-      VdbeCoverage(v);
-    }
-    r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, pFree2);
-  }
-  *pR1 = r1;
-  *pR2 = r2;
-  return addrIsNull;
-}
-
-/*
-** pExpr is a TK_FUNCTION node.  Try to determine whether or not the
-** function is a constant function.  A function is constant if all of
-** the following are true:
-**
-**    (1)  It is a scalar function (not an aggregate or window function)
-**    (2)  It has either the SQLITE_FUNC_CONSTANT or SQLITE_FUNC_SLOCHNG
-**         property.
-**    (3)  All of its arguments are constants
-**
-** This routine sets pWalker->eCode to 0 if pExpr is not a constant.
-** It makes no changes to pWalker->eCode if pExpr is constant.  In
-** every case, it returns WRC_Abort.
-**
-** Called as a service subroutine from exprNodeIsConstant().
-*/
-static SQLITE_NOINLINE int exprNodeIsConstantFunction(
-  Walker *pWalker,
-  Expr *pExpr
-){
-  int n;             /* Number of arguments */
-  ExprList *pList;   /* List of arguments */
-  FuncDef *pDef;     /* The function */
-  sqlite3 *db;       /* The database */
-
-  assert( pExpr->op==TK_FUNCTION );
-  if( ExprHasProperty(pExpr, EP_TokenOnly)
-   || (pList = pExpr->x.pList)==0
-  ){;
-    n = 0;
-  }else{
-    n = pList->nExpr;
-    sqlite3WalkExprList(pWalker, pList);
-    if( pWalker->eCode==0 ) return WRC_Abort;
-  }
-  db = pWalker->pParse->db;
-  pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
-  if( pDef==0
-   || pDef->xFinalize!=0
-   || (pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0
-   || ExprHasProperty(pExpr, EP_WinFunc)
-  ){
-    pWalker->eCode = 0;
-    return WRC_Abort;
-  }
-  return WRC_Prune;
-}
-
-
-/*
-** 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){
-  assert( pWalker->eCode>0 );
-
-  /* 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 if( pWalker->pParse ){
-        return exprNodeIsConstantFunction(pWalker, pExpr);
-      }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:
-    case TK_RAISE:
-      testcase( pExpr->op==TK_REGISTER );
-      testcase( pExpr->op==TK_IF_NULL_ROW );
-      testcase( pExpr->op==TK_DOT );
-      testcase( pExpr->op==TK_RAISE );
-      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(Parse *pParse, Expr *p, int initFlag){
-  Walker w;
-  w.eCode = initFlag;
-  w.pParse = pParse;
-  w.xExprCallback = exprNodeIsConstant;
-  w.xSelectCallback = sqlite3SelectWalkFail;
-#ifdef SQLITE_DEBUG
-  w.xSelectCallback2 = sqlite3SelectWalkAssert2;
-#endif
-  sqlite3WalkExpr(&w, p);
-  return w.eCode;
-}
-
-/*
-** Walk an expression tree.  Return non-zero if the expression is constant
-** or return zero if the expression 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.
-**
-** The pParse parameter may be NULL.  But if it is NULL, there is no way
-** to determine if function calls are constant or not, and hence all
-** function calls will be considered to be non-constant.  If pParse is
-** not NULL, then a function call might be constant, depending on the
-** function and on its parameters.
-*/
-SQLITE_PRIVATE int sqlite3ExprIsConstant(Parse *pParse, Expr *p){
-  return exprIsConst(pParse, p, 1);
-}
-
-/*
-** 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().
-*/
-static int sqlite3ExprIsConstantNotJoin(Parse *pParse, Expr *p){
-  return exprIsConst(pParse, p, 2);
-}
-
-/*
-** This routine examines sub-SELECT statements as an expression is being
-** walked as part of sqlite3ExprIsTableConstant().  Sub-SELECTs are considered
-** constant as long as they are uncorrelated - meaning that they do not
-** contain any terms from outer contexts.
-*/
-static int exprSelectWalkTableConstant(Walker *pWalker, Select *pSelect){
-  assert( pSelect!=0 );
-  assert( pWalker->eCode==3 || pWalker->eCode==0 );
-  if( (pSelect->selFlags & SF_Correlated)!=0 ){
-    pWalker->eCode = 0;
-    return WRC_Abort;
-  }
-  return WRC_Prune;
-}
-
-/*
-** 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.
-**
-** Consider uncorrelated subqueries to be constants if the bAllowSubq
-** parameter is true.
-*/
-static int sqlite3ExprIsTableConstant(Expr *p, int iCur, int bAllowSubq){
-  Walker w;
-  w.eCode = 3;
-  w.pParse = 0;
-  w.xExprCallback = exprNodeIsConstant;
-  if( bAllowSubq ){
-    w.xSelectCallback = exprSelectWalkTableConstant;
-  }else{
-    w.xSelectCallback = sqlite3SelectWalkFail;
-#ifdef SQLITE_DEBUG
-    w.xSelectCallback2 = sqlite3SelectWalkAssert2;
-#endif
-  }
-  w.u.iCur = iCur;
-  sqlite3WalkExpr(&w, p);
-  return w.eCode;
-}
-
-/*
-** 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.
-**
-**   (2a) pExpr cannot use subqueries unless the bAllowSubq parameter is
-**        true and the subquery is non-correlated
-**
-**   (2b) pExpr cannot use 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 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 */
-  int bAllowSubq               /* Allow non-correlated subqueries */
-){
-  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; jj<iSrc; jj++){
-      if( pExpr->w.iJoin==pSrcList->a[jj].iCursor ){
-        if( (pSrcList->a[jj].fg.jointype & JT_LTORJ)!=0 ){
-          return 0;  /* restriction (6) */
-        }
-        break;
-      }
-    }
-  }
-  /* Rules (1), (2a), and (2b) handled by the following: */
-  return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor, bAllowSubq);
-}
-
-
-/*
-** 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; i<pGroupBy->nExpr; 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(0, p, 4+isInit);
-}
-
-#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.
-**
-** If the pParse pointer is provided, then allow the expression p to be
-** a parameter (TK_VARIABLE) that is bound to an integer.
-** But if pParse is NULL, then p must be a pure integer literal.
-*/
-SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr *p, int *pValue, Parse *pParse){
-  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, 0);
-      break;
-    }
-    case TK_UMINUS: {
-      int v = 0;
-      if( sqlite3ExprIsInteger(p->pLeft, &v, 0) ){
-        assert( ((unsigned int)v)!=0x80000000 );
-        *pValue = -v;
-        rc = 1;
-      }
-      break;
-    }
-    case TK_VARIABLE: {
-      sqlite3_value *pVal;
-      if( pParse==0 ) break;
-      if( NEVER(pParse->pVdbe==0) ) break;
-      if( (pParse->db->flags & SQLITE_EnableQPSG)!=0 ) break;
-      sqlite3VdbeSetVarmask(pParse->pVdbe, p->iColumn);
-      pVal = sqlite3VdbeGetBoundValue(pParse->pReprepare, p->iColumn,
-                                      SQLITE_AFF_BLOB);
-      if( pVal ){
-        if( sqlite3_value_type(pVal)==SQLITE_INTEGER ){
-          sqlite3_int64 vv = sqlite3_value_int64(pVal);
-          if( vv == (vv & 0x7fffffff) ){ /* non-negative numbers only */
-            *pValue = (int)vv;
-            rc = 1;
-          }
-        }
-        sqlite3ValueFree(pVal);
-      }
-      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)
-          || NEVER(p->y.pTab==0) /* Reference to column of index on expr */
-#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
-          || (p->iColumn==XN_ROWID && IsView(p->y.pTab))
-#endif
-          || (p->iColumn>=0
-              && p->y.pTab->aCol!=0 /* Possible due to prior error */
-              && ALWAYS(p->iColumn<p->y.pTab->nCol)
-              && 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;
-}
-
-/*
-** Return a pointer to a buffer containing a usable rowid alias for table
-** pTab. An alias is usable if there is not an explicit user-defined column
-** of the same name.
-*/
-SQLITE_PRIVATE const char *sqlite3RowidAlias(Table *pTab){
-  const char *azOpt[] = {"_ROWID_", "ROWID", "OID"};
-  int ii;
-  assert( VisibleRowid(pTab) );
-  for(ii=0; ii<ArraySize(azOpt); ii++){
-    if( sqlite3ColumnIndex(pTab, azOpt[ii])<0 ) return azOpt[ii];
-  }
-  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].fg.isSubquery) return 0;/* FROM is not a subquery or view */
-  pTab = pSrc->a[0].pSTab;
-  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; i<pEList->nExpr; 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(Parse *pParse, Expr *pIn){
-  Expr *pLHS;
-  int res;
-  assert( !ExprHasProperty(pIn, EP_xIsSelect) );
-  pLHS = pIn->pLeft;
-  pIn->pLeft = 0;
-  res = sqlite3ExprIsConstant(pParse, 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 ephemeral 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 <column1>, <column2>... FROM <table>
-**
-** 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
-** ephemeral 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 ephemeral 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 ephemeral table must
-** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
-** index can be found with the specified <columns> 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; i<pEList->nExpr; 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 <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].pSTab;
-
-    /* Code an OP_Transaction and OP_TableLock for <table>. */
-    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-    assert( iDb>=0 && iDb<SQLITE_MAX_DB );
-    sqlite3CodeVerifySchema(pParse, iDb);
-    sqlite3TableLock(pParse, iDb, pTab->tnum, 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; i<nExpr && affinity_ok; i++){
-        Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, 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->nColumn<nExpr ) continue;
-          if( pIdx->pPartIdxWhere!=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; i<nExpr; i++){
-            Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i);
-            Expr *pRhs = pEList->a[i].pExpr;
-            CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs);
-            int j;
-
-            for(j=0; j<nExpr; j++){
-              if( pIdx->aiColumn[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( nExpr>0 && nExpr<BMS );
-          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<<nExpr)-1;
-              sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed,
-                  iTab, 0, 0, (u8*)&mask, P4_INT64);
-#endif
-              *prRhsHasNull = ++pParse->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(pParse,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;
-    int bloomOk = (inFlags & IN_INDEX_MEMBERSHIP)!=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 );
-    if( !bloomOk
-     && ExprUseXSelect(pX)
-     && (pX->x.pSelect->selFlags & SF_ClonedRhsIn)!=0
-    ){
-      bloomOk = 1;
-    }
-    sqlite3CodeRhsOfIN(pParse, pX, iTab, bloomOk);
-    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; i<n; i++) aiMap[i] = i;
-  }
-  *piTab = iTab;
-  return eType;
-}
-#endif
-
-#ifndef SQLITE_OMIT_SUBQUERY
-/*
-** Argument pExpr is an (?, ?...) IN(...) expression. This
-** function allocates and returns a nul-terminated string containing
-** the affinities to be used for each column of the comparison.
-**
-** It is the responsibility of the caller to ensure that the returned
-** string is eventually freed using sqlite3DbFree().
-*/
-static char *exprINAffinity(Parse *pParse, const Expr *pExpr){
-  Expr *pLeft = pExpr->pLeft;
-  int nVal = sqlite3ExprVectorSize(pLeft);
-  Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0;
-  char *zRet;
-
-  assert( pExpr->op==TK_IN );
-  zRet = sqlite3DbMallocRaw(pParse->db, 1+(i64)nVal);
-  if( zRet ){
-    int i;
-    for(i=0; i<nVal; i++){
-      Expr *pA = sqlite3VectorFieldSubexpr(pLeft, i);
-      char a = sqlite3ExprAffinity(pA);
-      if( pSelect ){
-        zRet[i] = sqlite3CompareAffinity(pSelect->pEList->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
-/*
-** Scan all previously generated bytecode looking for an OP_BeginSubrtn
-** that is compatible with pExpr.  If found, add the y.sub values
-** to pExpr and return true.  If not found, return false.
-*/
-static int findCompatibleInRhsSubrtn(
-  Parse *pParse,          /* Parsing context */
-  Expr *pExpr,            /* IN operator with RHS that we want to reuse */
-  SubrtnSig *pNewSig      /* Signature for the IN operator */
-){
-  VdbeOp *pOp, *pEnd;
-  SubrtnSig *pSig;
-  Vdbe *v;
-
-  if( pNewSig==0 ) return 0;
-  if( (pParse->mSubrtnSig & (1<<(pNewSig->selId&7)))==0 ) return 0;
-  assert( pExpr->op==TK_IN );
-  assert( !ExprUseYSub(pExpr) );
-  assert( ExprUseXSelect(pExpr) );
-  assert( pExpr->x.pSelect!=0 );
-  assert( (pExpr->x.pSelect->selFlags & SF_All)==0 );
-  v = pParse->pVdbe;
-  assert( v!=0 );
-  pOp = sqlite3VdbeGetOp(v, 1);
-  pEnd = sqlite3VdbeGetLastOp(v);
-  for(; pOp<pEnd; pOp++){
-    if( pOp->p4type!=P4_SUBRTNSIG ) continue;
-    assert( pOp->opcode==OP_BeginSubrtn );
-    pSig = pOp->p4.pSubrtnSig;
-    assert( pSig!=0 );
-    if( !pSig->bComplete ) continue;
-    if( pNewSig->selId!=pSig->selId ) continue;
-    if( strcmp(pNewSig->zAff,pSig->zAff)!=0 ) continue;
-    pExpr->y.sub.iAddr = pSig->iAddr;
-    pExpr->y.sub.regReturn = pSig->regReturn;
-    pExpr->iTable = pSig->iTable;
-    ExprSetProperty(pExpr, EP_Subrtn);
-    return 1;
-  }
-  return 0;
-}
-#endif /* SQLITE_OMIT_SUBQUERY */
-
-#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 ephemeral 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 allowBloom          /* True to allow the use of a Bloom filter */
-){
-  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 */
-  SubrtnSig *pSig = 0;        /* Signature for this subroutine */
-
-  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
-    **
-    ** Compute a signature for the RHS of the IN operator to facility
-    ** finding and reusing prior instances of the same IN operator.
-    */
-    assert( !ExprUseXSelect(pExpr) || pExpr->x.pSelect!=0 );
-    if( ExprUseXSelect(pExpr) && (pExpr->x.pSelect->selFlags & SF_All)==0 ){
-      pSig = sqlite3DbMallocRawNN(pParse->db, sizeof(pSig[0]));
-      if( pSig ){
-        pSig->selId = pExpr->x.pSelect->selId;
-        pSig->zAff = exprINAffinity(pParse, pExpr);
-      }
-    }
-
-    /* Check to see if there is a prior materialization of the RHS of
-    ** this IN operator.  If there is, then make use of that prior
-    ** materialization rather than recomputing it.
-    */
-    if( ExprHasProperty(pExpr, EP_Subrtn)
-     || findCompatibleInRhsSubrtn(pParse, pExpr, pSig)
-    ){
-      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);
-      if( pSig ){
-        sqlite3DbFree(pParse->db, pSig->zAff);
-        sqlite3DbFree(pParse->db, pSig);
-      }
-      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;
-    if( pSig ){
-      pSig->bComplete = 0;
-      pSig->iAddr = pExpr->y.sub.iAddr;
-      pSig->regReturn = pExpr->y.sub.regReturn;
-      pSig->iTable = iTab;
-      pParse->mSubrtnSig = 1 << (pSig->selId&7);
-      sqlite3VdbeChangeP4(v, -1, (const char*)pSig, P4_SUBRTNSIG);
-    }
-    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;
-      int addrBloom = 0;
-      sqlite3SelectDestInit(&dest, SRT_Set, iTab);
-      dest.zAffSdst = exprINAffinity(pParse, pExpr);
-      pSelect->iLimit = 0;
-      if( addrOnce
-       && allowBloom
-       && OptimizationEnabled(pParse->db, SQLITE_BloomFilter)
-      ){
-        int regBloom = ++pParse->nMem;
-        addrBloom = sqlite3VdbeAddOp2(v, OP_Blob, 10000, regBloom);
-        VdbeComment((v, "Bloom filter"));
-        dest.iSDParm2 = regBloom;
-      }
-      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( addrBloom ){
-        /* Remember that location of the Bloom filter in the P3 operand
-        ** of the OP_Once that began this subroutine. tag-202407032019 */
-        sqlite3VdbeGetOp(v, addrOnce)->p3 = dest.iSDParm2;
-        if( dest.iSDParm2==0 ){
-          /* If the Bloom filter won't actually be used, keep it small */
-          sqlite3VdbeGetOp(v, addrBloom)->p1 = 10;
-        }
-      }
-      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; i<nVal; i++){
-        Expr *p = sqlite3VectorFieldSubexpr(pLeft, i);
-        pKeyInfo->aColl[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 <expr> is a column, then use
-    ** that columns affinity when building index keys. If <expr> 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 <exprlist>. */
-    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(pParse, 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( pSig ) pSig->bComplete = 1;
-  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;
-    if( (pSel->selFlags&SF_Distinct) && pSel->pLimit && pSel->pLimit->pRight ){
-      /* If there is both a DISTINCT and an OFFSET clause, then allocate
-      ** a separate dest.iSdst array for sqlite3Select() and other
-      ** routines to populate. In this case results will be copied over
-      ** into the dest.iSDParm array only after OFFSET processing. This
-      ** ensures that in the case where OFFSET excludes all rows, the
-      ** dest.iSDParm array is not left populated with the contents of the
-      ** last row visited - it should be all NULLs if all rows were
-      ** excluded by OFFSET.  */
-      dest.iSdst = pParse->nMem+1;
-      pParse->nMem += nReg;
-    }else{
-      dest.iSdst = dest.iSDParm;
-    }
-    dest.nSdst = nReg;
-    sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, pParse->nMem);
-    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 X is
-    ** not already integer value 1 or 0, then make the new limit X<>0 so that
-    ** the new limit is either 1 or 0 */
-    Expr *pLeft = pSel->pLimit->pLeft;
-    if( ExprHasProperty(pLeft, EP_IntValue)==0
-     || (pLeft->u.iValue!=1 && pLeft->u.iValue!=0)
-    ){
-      sqlite3 *db = pParse->db;
-      pLimit = sqlite3ExprInt32(db, 0);
-      if( pLimit ){
-        pLimit->affExpr = SQLITE_AFF_NUMERIC;
-        pLimit = sqlite3PExpr(pParse, TK_NE,
-            sqlite3ExprDup(db, pLeft, 0), pLimit);
-      }
-      sqlite3ExprDeferredDelete(pParse, pLeft);
-      pSel->pLimit->pLeft = pLimit;
-    }
-  }else{
-    /* If there is no pre-existing limit add a limit of 1 */
-    pLimit = sqlite3ExprInt32(pParse->db, 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 */
-  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));
-  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<nVector; i++){
-    int j, cnt;
-    for(cnt=j=0; j<nVector; j++) if( aiMap[j]==i ) cnt++;
-    assert( cnt==1 );
-  }
-#endif
-
-  /* Code the LHS, the <expr> from "<expr> 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;
-  rLhs = exprCodeVector(pParse, pLeft, &iDummy);
-  pParse->okConstFactor = okConstFactor;
-
-  /* If sqlite3FindInIndex() did not find or create an index that is
-  ** suitable for evaluating the IN operator, then evaluate using a
-  ** sequence of comparisons.
-  **
-  ** This is step (1) in the in-operator.md optimized algorithm.
-  */
-  if( eType==IN_INDEX_NOOP ){
-    ExprList *pList;
-    CollSeq *pColl;
-    int labelOk = sqlite3VdbeMakeLabel(pParse);
-    int r2, regToFree;
-    int regCkNull = 0;
-    int ii;
-    assert( nVector==1 );
-    assert( ExprUseXList(pExpr) );
-    pList = pExpr->x.pList;
-    pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
-    if( destIfNull!=destIfFalse ){
-      regCkNull = sqlite3GetTempReg(pParse);
-      sqlite3VdbeAddOp3(v, OP_BitAnd, rLhs, rLhs, regCkNull);
-    }
-    for(ii=0; ii<pList->nExpr; ii++){
-      r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, &regToFree);
-      if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
-        sqlite3VdbeAddOp3(v, OP_BitAnd, regCkNull, r2, regCkNull);
-      }
-      sqlite3ReleaseTempReg(pParse, regToFree);
-      if( ii<pList->nExpr-1 || destIfNull!=destIfFalse ){
-        int op = rLhs!=r2 ? OP_Eq : OP_NotNull;
-        sqlite3VdbeAddOp4(v, op, rLhs, labelOk, r2,
-                          (void*)pColl, P4_COLLSEQ);
-        VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_Eq);
-        VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_Eq);
-        VdbeCoverageIf(v, ii<pList->nExpr-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;
-  }
-
-  if( eType!=IN_INDEX_ROWID ){
-    /* If this IN operator will use an index, then the order of columns in the
-    ** vector might be different from the order in the index.  In that case,
-    ** we need to reorder the LHS values to be in index order.  Run Affinity
-    ** before reordering the columns, so that the affinity is correct.
-    */
-    sqlite3VdbeAddOp4(v, OP_Affinity, rLhs, nVector, 0, zAff, nVector);
-    for(i=0; i<nVector && aiMap[i]==i; i++){} /* Are LHS fields reordered? */
-    if( i!=nVector ){
-      /* Need to reorder the LHS fields according to aiMap */
-      int rLhsOrig = rLhs;
-      rLhs = sqlite3GetTempRange(pParse, nVector);
-      for(i=0; i<nVector; i++){
-        sqlite3VdbeAddOp3(v, OP_Copy, rLhsOrig+i, rLhs+aiMap[i], 0);
-      }
-      sqlite3ReleaseTempReg(pParse, rLhsOrig);
-    }
-  }
-
-
-  /* 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; i<nVector; i++){
-    Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, 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. */
-    assert( nVector==1 );
-    sqlite3VdbeAddOp3(v, OP_SeekRowid, iTab, destIfFalse, rLhs);
-    VdbeCoverage(v);
-    addrTruthOp = sqlite3VdbeAddOp0(v, OP_Goto);  /* Return True */
-  }else{
-    if( destIfFalse==destIfNull ){
-      /* Combine Step 3 and Step 5 into a single opcode */
-      if( ExprHasProperty(pExpr, EP_Subrtn) ){
-        const VdbeOp *pOp = sqlite3VdbeGetOp(v, pExpr->y.sub.iAddr);
-        assert( pOp->opcode==OP_Once || pParse->nErr );
-        if( pOp->p3>0 ){  /* tag-202407032019 */
-          assert( OptimizationEnabled(pParse->db, SQLITE_BloomFilter)
-                 || pParse->nErr );
-          sqlite3VdbeAddOp4Int(v, OP_Filter, pOp->p3, destIfFalse,
-                               rLhs, nVector); VdbeCoverage(v);
-        }
-      }
-      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; i<nVector; i++){
-    Expr *p;
-    CollSeq *pColl;
-    int r3 = sqlite3GetTempReg(pParse);
-    p = sqlite3VectorFieldSubexpr(pLeft, i);
-    pColl = sqlite3ExprCollSeq(pParse, p);
-    sqlite3VdbeAddOp3(v, OP_Column, iTab, i, r3);
-    sqlite3VdbeAddOp4(v, OP_Ne, rLhs+i, destNotNull, r3,
-                      (void*)pColl, P4_COLLSEQ);
-    VdbeCoverage(v);
-    sqlite3ReleaseTempReg(pParse, r3);
-  }
-  sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
-  if( nVector>1 ){
-    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:
-  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);
-    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->colFlags & COLFLAG_VIRTUAL)!=0
-   && (pTab->tabFlags & TF_Strict)!=0
-  ){
-    int p3 = 2+(int)(pCol - pTab->aCol);
-    sqlite3VdbeAddOp4(v, OP_TypeCheck, regOut, 1, p3, (char*)pTab, P4_TABLE);
-  }else 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 );
-  assert( (p5 & (OPFLAG_NOCHNG|OPFLAG_TYPEOFARG|OPFLAG_LENGTHARG))==p5 );
-  assert( IsVirtual(pTab) || (p5 & OPFLAG_NOCHNG)==0 );
-  sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg);
-  if( p5 ){
-    VdbeOp *pOp = sqlite3VdbeGetLastOp(pParse->pVdbe);
-    if( pOp->opcode==OP_Column ) pOp->p5 = p5;
-    if( pOp->opcode==OP_VColumn ) pOp->p5 = (p5 & OPFLAG_NOCHNG);
-  }
-  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.
-*/
-SQLITE_PRIVATE void sqlite3ExprToRegister(Expr *pExpr, int iReg){
-  Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
-  if( NEVER(p==0) ) return;
-  if( p->op==TK_REGISTER ){
-    assert( p->iTable==iReg );
-  }else{
-    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 contiguous 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; i<nResult; i++){
-        sqlite3ExprCodeFactorable(pParse, p->x.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 mergeable */
-  }
-}
-
-/*
-** 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; i<nFarg; i++){
-        sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
-        VdbeCoverage(v);
-        sqlite3ExprCode(pParse, pFarg->a[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,1),
-           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;
-}
-
-/*
-** Expression Node callback for sqlite3ExprCanReturnSubtype().
-**
-** Only a function call is able to return a subtype.  So if the node
-** is not a function call, return WRC_Prune immediately.
-**
-** A function call is able to return a subtype if it has the
-** SQLITE_RESULT_SUBTYPE property.
-**
-** Assume that every function is able to pass-through a subtype from
-** one of its argument (using sqlite3_result_value()).  Most functions
-** are not this way, but we don't have a mechanism to distinguish those
-** that are from those that are not, so assume they all work this way.
-** That means that if one of its arguments is another function and that
-** other function is able to return a subtype, then this function is
-** able to return a subtype.
-*/
-static int exprNodeCanReturnSubtype(Walker *pWalker, Expr *pExpr){
-  int n;
-  FuncDef *pDef;
-  sqlite3 *db;
-  if( pExpr->op!=TK_FUNCTION ){
-    return WRC_Prune;
-  }
-  assert( ExprUseXList(pExpr) );
-  db = pWalker->pParse->db;
-  n = ALWAYS(pExpr->x.pList) ? pExpr->x.pList->nExpr : 0;
-  pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
-  if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_RESULT_SUBTYPE)!=0 ){
-    pWalker->eCode = 1;
-    return WRC_Prune;
-  }
-  return WRC_Continue;
-}
-
-/*
-** Return TRUE if expression pExpr is able to return a subtype.
-**
-** A TRUE return does not guarantee that a subtype will be returned.
-** It only indicates that a subtype return is possible.  False positives
-** are acceptable as they only disable an optimization.  False negatives,
-** on the other hand, can lead to incorrect answers.
-*/
-static int sqlite3ExprCanReturnSubtype(Parse *pParse, Expr *pExpr){
-  Walker w;
-  memset(&w, 0, sizeof(w));
-  w.pParse = pParse;
-  w.xExprCallback = exprNodeCanReturnSubtype;
-  sqlite3WalkExpr(&w, pExpr);
-  return w.eCode;
-}
-
-
-/*
-** 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;
-    }
-
-
-    /* Functions that might set a subtype should not be replaced by the
-    ** value taken from an expression index if they are themselves an
-    ** argument to another scalar function or aggregate.
-    ** https://sqlite.org/forum/forumpost/68d284c86b082c3e */
-    if( ExprHasProperty(pExpr, EP_SubtArg)
-     && sqlite3ExprCanReturnSubtype(pParse, pExpr)
-    ){
-      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 */
-}
-
-
-/*
-** Expression pExpr is guaranteed to be a TK_COLUMN or equivalent. This
-** function checks the Parse.pIdxPartExpr list to see if this column
-** can be replaced with a constant value. If so, it generates code to
-** put the constant value in a register (ideally, but not necessarily,
-** register iTarget) and returns the register number.
-**
-** Or, if the TK_COLUMN cannot be replaced by a constant, zero is
-** returned.
-*/
-static int exprPartidxExprLookup(Parse *pParse, Expr *pExpr, int iTarget){
-  IndexedExpr *p;
-  for(p=pParse->pIdxPartExpr; p; p=p->pIENext){
-    if( pExpr->iColumn==p->iIdxCol && pExpr->iTable==p->iDataCur ){
-      Vdbe *v = pParse->pVdbe;
-      int addr = 0;
-      int ret;
-
-      if( p->bMaybeNullRow ){
-        addr = sqlite3VdbeAddOp1(v, OP_IfNullRow, p->iIdxCur);
-      }
-      ret = sqlite3ExprCodeTarget(pParse, p->pExpr, iTarget);
-      sqlite3VdbeAddOp4(pParse->pVdbe, OP_Affinity, ret, 1, 0,
-                        (const char*)&p->aff, 1);
-      if( addr ){
-        sqlite3VdbeJumpHere(v, addr);
-        sqlite3VdbeChangeP3(v, addr, ret);
-      }
-      return ret;
-    }
-  }
-  return 0;
-}
-
-/*
-** Generate code that evaluates an AND or OR operator leaving a
-** boolean result in a register.  pExpr is the AND/OR expression.
-** Store the result in the "target" register.  Use short-circuit
-** evaluation to avoid computing both operands, if possible.
-**
-** The code generated might require the use of a temporary register.
-** If it does, then write the number of that temporary register
-** into *pTmpReg.  If not, leave *pTmpReg unchanged.
-*/
-static SQLITE_NOINLINE int exprCodeTargetAndOr(
-  Parse *pParse,     /* Parsing context */
-  Expr *pExpr,       /* AND or OR expression to be coded */
-  int target,        /* Put result in this register, guaranteed */
-  int *pTmpReg       /* Write a temporary register here */
-){
-  int op;            /* The opcode.  TK_AND or TK_OR */
-  int skipOp;        /* Opcode for the branch that skips one operand */
-  int addrSkip;      /* Branch instruction that skips one of the operands */
-  int regSS = 0;     /* Register holding computed operand when other omitted */
-  int r1, r2;        /* Registers for left and right operands, respectively */
-  Expr *pAlt;        /* Alternative, simplified expression */
-  Vdbe *v;           /* statement being coded */
-
-  assert( pExpr!=0 );
-  op = pExpr->op;
-  assert( op==TK_AND || op==TK_OR );
-  assert( TK_AND==OP_And );            testcase( op==TK_AND );
-  assert( TK_OR==OP_Or );              testcase( op==TK_OR );
-  assert( pParse->pVdbe!=0 );
-  v = pParse->pVdbe;
-  pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
-  if( pAlt!=pExpr ){
-    r1 = sqlite3ExprCodeTarget(pParse, pAlt, target);
-    sqlite3VdbeAddOp3(v, OP_And, r1, r1, target);
-    return target;
-  }
-  skipOp = op==TK_AND ? OP_IfNot : OP_If;
-  if( exprEvalRhsFirst(pExpr) ){
-    /* Compute the right operand first.  Skip the computation of the left
-    ** operand if the right operand fully determines the result */
-    r2 = regSS = sqlite3ExprCodeTarget(pParse, pExpr->pRight, target);
-    addrSkip = sqlite3VdbeAddOp1(v, skipOp, r2);
-    VdbeComment((v, "skip left operand"));
-    VdbeCoverage(v);
-    r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, pTmpReg);
-  }else{
-    /* Compute the left operand first */
-    r1 = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
-    if( ExprHasProperty(pExpr->pRight, EP_Subquery) ){
-      /* Skip over the computation of the right operand if the right
-      ** operand is a subquery and the left operand completely determines
-      ** the result */
-      regSS = r1;
-      addrSkip = sqlite3VdbeAddOp1(v, skipOp, r1);
-      VdbeComment((v, "skip right operand"));
-      VdbeCoverage(v);
-    }else{
-      addrSkip = regSS = 0;
-    }
-    r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, pTmpReg);
-  }
-  sqlite3VdbeAddOp3(v, op, r2, r1, target);
-  testcase( (*pTmpReg)==0 );
-  if( addrSkip ){
-    sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+2);
-    sqlite3VdbeJumpHere(v, addrSkip);
-    sqlite3VdbeAddOp3(v, OP_Or, regSS, regSS, target);
-    VdbeComment((v, "short-circut value"));
-  }
-  return target;
-}
-
-
-
-/*
-** 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;
-  }
-  assert( op!=TK_ORDER );
-  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 */
-        sqlite3VdbeAddOp3(v, OP_NotNull, target, 1, 20230325);
-        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
-        ** expression.  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( iCol<pTab->nCol );
-          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;
-        }
-      }
-      else if( pParse->pIdxPartExpr
-       && 0!=(r1 = exprPartidxExprLookup(pParse, pExpr, target))
-      ){
-        return r1;
-      }
-      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;
-    }
-    case TK_NULLS: {
-      /* Set a range of registers to NULL.  pExpr->y.nReg registers starting
-      ** with target */
-      sqlite3VdbeAddOp3(v, OP_Null, 0, target, target + pExpr->y.nReg - 1);
-      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);
-      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;
-      /* no break */ deliberate_fall_through
-    case TK_LT:
-    case TK_LE:
-    case TK_GT:
-    case TK_GE:
-    case TK_NE:
-    case TK_EQ: {
-      Expr *pLeft = pExpr->pLeft;
-      int addrIsNull = 0;
-      if( sqlite3ExprIsVector(pLeft) ){
-        codeVectorCompare(pParse, pExpr, target, op, p5);
-      }else{
-        if( ExprHasProperty(pExpr, EP_Subquery) && p5!=SQLITE_NULLEQ ){
-          addrIsNull = exprComputeOperands(pParse, pExpr,
-                                     &r1, &r2, &regFree1, &regFree2);
-        }else{
-          r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
-          r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
-        }
-        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);
-          if( addrIsNull ){
-            sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+2);
-            sqlite3VdbeJumpHere(v, addrIsNull);
-            sqlite3VdbeAddOp2(v, OP_Null, 0, inReg);
-          }
-        }
-        testcase( regFree1==0 );
-        testcase( regFree2==0 );
-      }
-      break;
-    }
-    case TK_AND:
-    case TK_OR: {
-      inReg = exprCodeTargetAndOr(pParse, pExpr, target, &regFree1);
-      break;
-    }
-    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: {
-      int addrIsNull;
-      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 );
-      if( ExprHasProperty(pExpr, EP_Subquery) ){
-        addrIsNull = exprComputeOperands(pParse, pExpr,
-                                   &r1, &r2, &regFree1, &regFree2);
-      }else{
-        r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
-        r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
-        addrIsNull = 0;
-      }
-      sqlite3VdbeAddOp3(v, op, r2, r1, target);
-      testcase( regFree1==0 );
-      testcase( regFree2==0 );
-      if( addrIsNull ){
-        sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+2);
-        sqlite3VdbeJumpHere(v, addrIsNull);
-        sqlite3VdbeAddOp2(v, OP_Null, 0, target);
-        VdbeComment((v, "short-circut value"));
-      }
-      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, &regFree1);
-        r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
-        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, &regFree1);
-      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, &regFree1);
-      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, &regFree1);
-      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(pParse,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)!=0 && ALWAYS(pFarg!=0) ){
-        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; i<nFarg; i++){
-        if( i<32 && sqlite3ExprIsConstant(pParse, pFarg->a[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() and octet_length() functions,
-        ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
-        ** or OPFLAG_TYPEOFARG or OPFLAG_BYTELENARG 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 );
-            assert( SQLITE_FUNC_BYTELEN==OPFLAG_BYTELENARG );
-            assert( (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG)==OPFLAG_BYTELENARG );
-            testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_LENGTHARG );
-            testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_TYPEOFARG );
-            testcase( (pDef->funcFlags & OPFLAG_BYTELENARG)==OPFLAG_BYTELENARG);
-            pFarg->a[0].pExpr->op2 = pDef->funcFlags & OPFLAG_BYTELENARG;
-          }
-        }
-
-        sqlite3ExprCodeExprList(pParse, pFarg, r1, 0, 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 WHERE-clause 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 && iCol<pTab->nCol );
-      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->iAgg<pAggInfo->nColumn );
-        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 );
-        sqlite3ExprToRegister(pDel, exprCodeVector(pParse, pDel, &regFree1));
-        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; i<nExpr-1; i=i+2){
-        if( pX ){
-          assert( pTest!=0 );
-          opCompare.pRight = aListelem[i].pExpr;
-        }else{
-          pTest = aListelem[i].pExpr;
-        }
-        nextCase = sqlite3VdbeMakeLabel(pParse);
-        testcase( pTest->op==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 ){
-        sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, OE_Ignore);
-        VdbeCoverage(v);
-      }else{
-        r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
-        sqlite3VdbeAddOp3(v, OP_Halt,
-             pParse->pTriggerTab ? SQLITE_CONSTRAINT_TRIGGER : SQLITE_ERROR,
-             pExpr->affExpr, r1);
-      }
-      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 wherever 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) );
-  assert( regDest!=0 );
-  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;
-}
-
-/*
-** Make arrangements to invoke OP_Null on a range of registers
-** during initialization.
-*/
-SQLITE_PRIVATE SQLITE_NOINLINE void sqlite3ExprNullRegisterRange(
-  Parse *pParse,   /* Parsing context */
-  int iReg,        /* First register to set to NULL */
-  int nReg         /* Number of sequential registers to NULL out */
-){
-  u8 okConstFactor = pParse->okConstFactor;
-  Expr t;
-  memset(&t, 0, sizeof(t));
-  t.op = TK_NULLS;
-  t.y.nReg = nReg;
-  pParse->okConstFactor = 1;
-  sqlite3ExprCodeRunJustOnce(pParse, &t, iReg);
-  pParse->okConstFactor = okConstFactor;
-}
-
-/*
-** 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(pParse, 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;
-    Expr *pX = sqlite3ExprSkipCollateAndLikely(pExpr);
-    testcase( pX!=pExpr );
-    if( ALWAYS(pX)
-     && (ExprHasProperty(pX,EP_Subquery) || pX->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(pParse,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; i<n; i++, pItem++){
-    Expr *pExpr = pItem->pExpr;
-#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(pParse,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;
-    sqlite3ExprToRegister(pDel, exprCodeVector(pParse, pDel, &regFree1));
-    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{
-        Expr *pFirst, *pSecond;
-        if( exprEvalRhsFirst(pExpr) ){
-          pFirst = pExpr->pRight;
-          pSecond = pExpr->pLeft;
-        }else{
-          pFirst = pExpr->pLeft;
-          pSecond = pExpr->pRight;
-        }
-        if( op==TK_AND ){
-          int d2 = sqlite3VdbeMakeLabel(pParse);
-          testcase( jumpIfNull==0 );
-          sqlite3ExprIfFalse(pParse, pFirst, d2,
-                             jumpIfNull^SQLITE_JUMPIFNULL);
-          sqlite3ExprIfTrue(pParse, pSecond, dest, jumpIfNull);
-          sqlite3VdbeResolveLabel(v, d2);
-        }else{
-          testcase( jumpIfNull==0 );
-          sqlite3ExprIfTrue(pParse, pFirst, dest, jumpIfNull);
-          sqlite3ExprIfTrue(pParse, pSecond, 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: {
-      int addrIsNull;
-      if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
-      if( ExprHasProperty(pExpr, EP_Subquery) && jumpIfNull!=SQLITE_NULLEQ ){
-        addrIsNull = exprComputeOperands(pParse, pExpr,
-                                   &r1, &r2, &regFree1, &regFree2);
-      }else{
-        r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
-        r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
-        addrIsNull = 0;
-      }
-      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 );
-      if( addrIsNull ){
-        if( jumpIfNull ){
-          sqlite3VdbeChangeP2(v, addrIsNull, dest);
-        }else{
-          sqlite3VdbeJumpHere(v, addrIsNull);
-        }
-      }
-      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, &regFree1);
-      assert( regFree1==0 || regFree1==r1 );
-      if( regFree1 ) sqlite3VdbeTypeofColumn(v, r1);
-      sqlite3VdbeAddOp2(v, op, r1, dest);
-      VdbeCoverageIf(v, op==TK_ISNULL);
-      VdbeCoverageIf(v, op==TK_NOTNULL);
-      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, &regFree1);
-        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{
-        Expr *pFirst, *pSecond;
-        if( exprEvalRhsFirst(pExpr) ){
-          pFirst = pExpr->pRight;
-          pSecond = pExpr->pLeft;
-        }else{
-          pFirst = pExpr->pLeft;
-          pSecond = pExpr->pRight;
-        }
-        if( pExpr->op==TK_AND ){
-          testcase( jumpIfNull==0 );
-          sqlite3ExprIfFalse(pParse, pFirst, dest, jumpIfNull);
-          sqlite3ExprIfFalse(pParse, pSecond, dest, jumpIfNull);
-        }else{
-          int d2 = sqlite3VdbeMakeLabel(pParse);
-          testcase( jumpIfNull==0 );
-          sqlite3ExprIfTrue(pParse, pFirst, d2,
-                            jumpIfNull^SQLITE_JUMPIFNULL);
-          sqlite3ExprIfFalse(pParse, pSecond, 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: {
-      int addrIsNull;
-      if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
-      if( ExprHasProperty(pExpr, EP_Subquery) && jumpIfNull!=SQLITE_NULLEQ ){
-        addrIsNull = exprComputeOperands(pParse, pExpr,
-                                   &r1, &r2, &regFree1, &regFree2);
-      }else{
-        r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
-        r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
-        addrIsNull = 0;
-      }
-      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 );
-      if( addrIsNull ){
-        if( jumpIfNull ){
-          sqlite3VdbeChangeP2(v, addrIsNull, dest);
-        }else{
-          sqlite3VdbeJumpHere(v, addrIsNull);
-        }
-      }
-      break;
-    }
-    case TK_ISNULL:
-    case TK_NOTNULL: {
-      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
-      assert( regFree1==0 || regFree1==r1 );
-      if( regFree1 ) 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);
-      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, &regFree1);
-        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.
-**
-** If the SQLITE_EnableQPSG flag is set on the database connection, then
-** this routine always returns false.
-*/
-static SQLITE_NOINLINE int exprCompareVariable(
-  const Parse *pParse,
-  const Expr *pVar,
-  const Expr *pExpr
-){
-  int res = 2;
-  int iVar;
-  sqlite3_value *pL, *pR = 0;
-
-  if( pExpr->op==TK_VARIABLE && pVar->iColumn==pExpr->iColumn ){
-    return 0;
-  }
-  if( (pParse->db->flags & SQLITE_EnableQPSG)!=0 ) return 2;
-  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 = sqlite3MemCompare(pL, pR, 0) ? 2 : 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 and SQLITE_EnableQPSG is off 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.
-*/
-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 ){
-    return exprCompareVariable(pParse, pA, pB);
-  }
-  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; i<pA->nExpr; 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,
-             sqlite3ExprSkipCollate(pA),
-             sqlite3ExprSkipCollate(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 the boolean value of the expression is always either
-** FALSE or NULL.
-*/
-static int sqlite3ExprIsNotTrue(Expr *pExpr){
-  int v;
-  if( pExpr->op==TK_NULL ) return 1;
-  if( pExpr->op==TK_TRUEFALSE && sqlite3ExprTruthValue(pExpr)==0 ) return 1;
-  v = 1;
-  if( sqlite3ExprIsInteger(pExpr, &v, 0) && v==0 ) return 1;
-  return 0;
-}
-
-/*
-** Return true if the expression is one of the following:
-**
-**    CASE WHEN x THEN y END
-**    CASE WHEN x THEN y ELSE NULL END
-**    CASE WHEN x THEN y ELSE false END
-**    iif(x,y)
-**    iif(x,y,NULL)
-**    iif(x,y,false)
-*/
-static int sqlite3ExprIsIIF(sqlite3 *db, const Expr *pExpr){
-  ExprList *pList;
-  if( pExpr->op==TK_FUNCTION ){
-    const char *z = pExpr->u.zToken;
-    FuncDef *pDef;
-    if( (z[0]!='i' && z[0]!='I') ) return 0;
-    if( pExpr->x.pList==0 ) return 0;
-    pDef = sqlite3FindFunction(db, z, pExpr->x.pList->nExpr, ENC(db), 0);
-#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
-    if( pDef==0 ) return 0;
-#else
-    if( NEVER(pDef==0) ) return 0;
-#endif
-    if( (pDef->funcFlags & SQLITE_FUNC_INLINE)==0 ) return 0;
-    if( SQLITE_PTR_TO_INT(pDef->pUserData)!=INLINEFUNC_iif ) return 0;
-  }else if( pExpr->op==TK_CASE ){
-    if( pExpr->pLeft!=0 ) return 0;
-  }else{
-    return 0;
-  }
-  pList = pExpr->x.pList;
-  assert( pList!=0 );
-  if( pList->nExpr==2 ) return 1;
-  if( pList->nExpr==3 && sqlite3ExprIsNotTrue(pList->a[2].pExpr) ) return 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    Result: false
-**     pE1: iif(x,y)    pE2: x                Result: true
-**     PE1: iif(x,y,0)  pE2: x                Result: true
-**
-** 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;
-  }
-  if( sqlite3ExprIsIIF(pParse->db, pE1) ){
-    return sqlite3ExprImpliesExpr(pParse,pE1->x.pList->a[0].pExpr,pE2,iTab);
-  }
-  return 0;
-}
-
-/* This is a helper function to impliesNotNullRow().  In this routine,
-** set pWalker->eCode to one only if *both* of the input expressions
-** separately have the implies-not-null-row property.
-*/
-static void bothImplyNotNullRow(Walker *pWalker, Expr *pE1, Expr *pE2){
-  if( pWalker->eCode==0 ){
-    sqlite3WalkExpr(pWalker, pE1);
-    if( pWalker->eCode ){
-      pWalker->eCode = 0;
-      sqlite3WalkExpr(pWalker, pE2);
-    }
-  }
-}
-
-/*
-** 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.
-**
-** pWalker->mWFlags is non-zero if this inquiry is being undertaking on
-** behalf of a RIGHT JOIN (or FULL JOIN).  That makes a difference when
-** evaluating terms in the ON clause of an inner join.
-**
-** 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;
-  if( ExprHasProperty(pExpr, EP_InnerON) && pWalker->mWFlags ){
-    /* If iCur is used in an inner-join ON clause to the left of a
-    ** RIGHT JOIN, that does *not* mean that the table must be non-null.
-    ** But it is difficult to check for that condition precisely.
-    ** To keep things simple, any use of iCur from any inner-join is
-    ** ignored while attempting to simplify a RIGHT JOIN. */
-    return WRC_Prune;
-  }
-  switch( pExpr->op ){
-    case TK_ISNOT:
-    case TK_ISNULL:
-    case TK_NOTNULL:
-    case TK_IS:
-    case TK_VECTOR:
-    case TK_FUNCTION:
-    case TK_TRUTH:
-    case TK_CASE:
-      testcase( pExpr->op==TK_ISNOT );
-      testcase( pExpr->op==TK_ISNULL );
-      testcase( pExpr->op==TK_NOTNULL );
-      testcase( pExpr->op==TK_IS );
-      testcase( pExpr->op==TK_VECTOR );
-      testcase( pExpr->op==TK_FUNCTION );
-      testcase( pExpr->op==TK_TRUTH );
-      testcase( pExpr->op==TK_CASE );
-      return WRC_Prune;
-
-    case TK_COLUMN:
-      if( pWalker->u.iCur==pExpr->iTable ){
-        pWalker->eCode = 1;
-        return WRC_Abort;
-      }
-      return WRC_Prune;
-
-    case TK_OR:
-    case TK_AND:
-      /* Both sides of an AND or OR must separately imply non-null-row.
-      ** Consider these cases:
-      **    1.  NOT (x AND y)
-      **    2.  x OR y
-      ** If only one of x or y is non-null-row, then the overall expression
-      ** can be true if the other arm is false (case 1) or true (case 2).
-      */
-      testcase( pExpr->op==TK_OR );
-      testcase( pExpr->op==TK_AND );
-      bothImplyNotNullRow(pWalker, pExpr->pLeft, pExpr->pRight);
-      return WRC_Prune;
-
-    case TK_IN:
-      /* Beware of "x NOT IN ()" and "x NOT IN (SELECT 1 WHERE false)",
-      ** both of which can be true.  But apart from these cases, if
-      ** the left-hand side of the IN is NULL then the IN itself will be
-      ** NULL. */
-      if( ExprUseXList(pExpr) && ALWAYS(pExpr->x.pList->nExpr>0) ){
-        sqlite3WalkExpr(pWalker, pExpr->pLeft);
-      }
-      return WRC_Prune;
-
-    case TK_BETWEEN:
-      /* In "x NOT BETWEEN y AND z" either x must be non-null-row or else
-      ** both y and z must be non-null row */
-      assert( ExprUseXList(pExpr) );
-      assert( pExpr->x.pList->nExpr==2 );
-      sqlite3WalkExpr(pWalker, pExpr->pLeft);
-      bothImplyNotNullRow(pWalker, pExpr->x.pList->a[0].pExpr,
-                                   pExpr->x.pList->a[1].pExpr);
-      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, int isRJ){
-  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, isRJ) ) return 1;
-      p = p->pRight;
-    }
-  }
-  w.xExprCallback = impliesNotNullRow;
-  w.xSelectCallback = 0;
-  w.xSelectCallback2 = 0;
-  w.eCode = 0;
-  w.mWFlags = isRJ!=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 throughout 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; i<pSrc->nSrc; 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; i<nSrc; i++){
-      if( pExpr->iTable==pSrc->a[i].iCursor ){
-        pWalker->eCode |= 1;
-        return WRC_Continue;
-      }
-    }
-    for(i=0; i<p->nExclude && 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);
-  if( pExpr->pLeft ){
-    assert( pExpr->pLeft->op==TK_ORDER );
-    assert( ExprUseXList(pExpr->pLeft) );
-    assert( pExpr->pLeft->x.pList!=0 );
-    sqlite3WalkExprList(&w, pExpr->pLeft->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( iAgg<pAggInfo->nColumn
-       && pAggInfo->aCol[iAgg].pCExpr==pExpr
-      ){
-        pExpr = sqlite3ExprDup(db, pExpr, 0);
-        if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
-          pAggInfo->aCol[iAgg].pCExpr = pExpr;
-        }
-      }
-    }else{
-      assert( pExpr->op==TK_AGG_FUNCTION );
-      if( ALWAYS(iAgg<pAggInfo->nFunc)
-       && pAggInfo->aFunc[iAgg].pFExpr==pExpr
-      ){
-        pExpr = sqlite3ExprDup(db, pExpr, 0);
-        if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
-          pAggInfo->aFunc[iAgg].pFExpr = 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 index 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;
-  int mxTerm = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
-
-  assert( mxTerm <= SMXV(i16) );
-  assert( pAggInfo->iFirstReg==0 );
-  pCol = pAggInfo->aCol;
-  for(k=0; k<pAggInfo->nColumn; k++, pCol++){
-    if( pCol->pCExpr==pExpr ) return;
-    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;
-  }
-  if( k>mxTerm ){
-    sqlite3ErrorMsg(pParse, "more than %d aggregate terms", mxTerm);
-    k = mxTerm;
-  }
-  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; j<n; j++, pTerm++){
-      Expr *pE = pTerm->pExpr;
-      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;
-  }
-  assert( k <= SMXV(pExpr->iAgg) );
-  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; i<pSrcList->nSrc; i++){
-         if( pSrcList->a[i].iCursor==pIEpr->iDataCur ){
-           testcase( i>0 );
-           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.iAgg<pAggInfo->nColumn );
-      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; i<pSrcList->nSrc; 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
-       && pExpr->pAggInfo==0
-      ){
-        /* 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;
-        int mxTerm = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
-        assert( mxTerm <= SMXV(i16) );
-        for(i=0; i<pAggInfo->nFunc; i++, pItem++){
-          if( NEVER(pItem->pFExpr==pExpr) ) break;
-          if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
-            break;
-          }
-        }
-        if( i>mxTerm ){
-          sqlite3ErrorMsg(pParse, "more than %d aggregate terms", mxTerm);
-          i = mxTerm;
-          assert( i<pAggInfo->nFunc );
-        }else 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 ){
-            int nArg;
-            assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
-            pItem = &pAggInfo->aFunc[i];
-            pItem->pFExpr = pExpr;
-            assert( ExprUseUToken(pExpr) );
-            nArg = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
-            pItem->pFunc = sqlite3FindFunction(pParse->db,
-                                         pExpr->u.zToken, nArg, enc, 0);
-            assert( pItem->bOBUnique==0 );
-            if( pExpr->pLeft
-             && (pItem->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)==0
-            ){
-              /* The NEEDCOLL test above causes any ORDER BY clause on
-              ** aggregate min() or max() to be ignored. */
-              ExprList *pOBList;
-              assert( nArg>0 );
-              assert( pExpr->pLeft->op==TK_ORDER );
-              assert( ExprUseXList(pExpr->pLeft) );
-              pItem->iOBTab = pParse->nTab++;
-              pOBList = pExpr->pLeft->x.pList;
-              assert( pOBList->nExpr>0 );
-              assert( pItem->bOBUnique==0 );
-              if( pOBList->nExpr==1
-               && nArg==1
-               && sqlite3ExprCompare(0,pOBList->a[0].pExpr,
-                               pExpr->x.pList->a[0].pExpr,0)==0
-              ){
-                pItem->bOBPayload = 0;
-                pItem->bOBUnique = ExprHasProperty(pExpr, EP_Distinct);
-              }else{
-                pItem->bOBPayload = 1;
-              }
-              pItem->bUseSubtype =
-                    (pItem->pFunc->funcFlags & SQLITE_SUBTYPE)!=0;
-            }else{
-              pItem->iOBTab = -1;
-            }
-            if( ExprHasProperty(pExpr, EP_Distinct) && !pItem->bOBUnique ){
-              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);
-        assert( i <= SMXV(pExpr->iAgg) );
-        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; i<pList->nExpr; 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->nTempReg<ArraySize(pParse->aTempReg) ){
-      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->nMem<iReg ) pParse->nMem = 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; i<pList->nExpr; 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; i<pParse->nTempReg; i++){
-    if( pParse->aTempReg[i]>=iFirst && pParse->aTempReg[i]<=iLast ){
-      return 0;
-    }
-  }
-  if( pParse->pConstExpr ){
-    ExprList *pList = pParse->pConstExpr;
-    for(i=0; i<pList->nExpr; 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)
-     || (pTab->tabFlags & TF_Strict)!=0
-    ){
-      sqlite3NestedParse(pParse,
-        "SELECT CASE WHEN quick_check GLOB 'CHECK*'"
-        " THEN raise(ABORT,'CHECK constraint failed')"
-        " WHEN quick_check GLOB 'non-* value in*'"
-        " THEN raise(ABORT,'type mismatch on DEFAULT')"
-        " ELSE raise(ABORT,'NOT NULL constraint failed')"
-        " END"
-        "  FROM pragma_quick_check(%Q,%Q)"
-        " WHERE quick_check GLOB 'CHECK*'"
-        " OR quick_check GLOB 'NULL*'"
-        " OR quick_check GLOB 'non-* value in*'",
-        zTab, zDb
-      );
-    }
-  }
-}
-
-/*
-** This function is called by the parser after the table-name in
-** an "ALTER TABLE <table-name> 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( NEVER(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)*(u32)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)*(size_t)pNew->nCol);
-  for(i=0; i<pNew->nCol; 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;
-  assert( 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 iOp){
-  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 ){
-    const char *azMsg[] = {
-      "rename columns of", "drop column from", "edit constraints of"
-    };
-    assert( iOp>=0 && iOp<ArraySize(azMsg) );
-    sqlite3ErrorMsg(pParse, "cannot %s %s \"%s\"",
-        azMsg[iOp], 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;
-  iCol = sqlite3ColumnIndex(pTab, zOld);
-  if( iCol<0 ){
-    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; i<pWith->nCte; 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; ii<pIdList->nId; 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; i<pList->nExpr; 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; i<pSrc->nSrc; 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; i<pEList->nExpr; 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;
-}
-
-/*
-** Set the error message of the context passed as the first argument to
-** the result of formatting zFmt using printf() style formatting.
-*/
-static void errorMPrintf(sqlite3_context *pCtx, const char *zFmt, ...){
-  sqlite3 *db = sqlite3_context_db_handle(pCtx);
-  char *zErr = 0;
-  va_list ap;
-  va_start(ap, zFmt);
-  zErr = sqlite3VMPrintf(db, zFmt, ap);
-  va_end(ap);
-  if( zErr ){
-    sqlite3_result_error(pCtx, zErr, -1);
-    sqlite3DbFree(db, zErr);
-  }else{
-    sqlite3_result_error_nomem(pCtx);
-  }
-}
-
-/*
-** An error occurred 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; i<pEList->nExpr; 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; i<pIdList->nId; 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;
-  u64 flags;
-
-  sqlite3ParseObjectInit(p, db);
-  if( zSql==0 ){
-    return SQLITE_NOMEM;
-  }
-  if( sqlite3StrNICmp(zSql,"CREATE ",7)!=0 ){
-    return SQLITE_CORRUPT_BKPT;
-  }
-  if( bTemp ){
-    db->init.iDb = 1;
-  }else{
-    int iDb = sqlite3FindDbName(db, zDb);
-    assert( iDb>=0 && iDb<=0xff );
-    db->init.iDb = (u8)iDb;
-  }
-  p->eParseMode = PARSE_MODE_RENAME;
-  p->db = db;
-  p->nQueryLoop = 1;
-  flags = db->flags;
-  testcase( (db->flags & SQLITE_Comments)==0 && strstr(zSql," /* ")!=0 );
-  db->flags |= SQLITE_Comments;
-  rc = sqlite3RunParser(p, zSql);
-  db->flags = flags;
-  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 && nSql>=0 && nNew>=0 );
-    zOut = sqlite3DbMallocZero(db, (u64)nSql + pRename->nList*(u64)nQuot + 1);
-  }else{
-    assert( nSql>0 );
-    zOut = (char*)sqlite3DbMallocZero(db, (2*(u64)nSql + 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 ){
-    i64 nOut = nSql;
-    assert( nSql>0 );
-    memcpy(zOut, zSql, (size_t)nSql);
-    while( pRename->pList ){
-      int iOff;                   /* Offset of token to replace in zOut */
-      i64 nReplace;
-      const char *zReplace;
-      RenameToken *pBest = renameColumnTokenNext(pRename);
-
-      if( zNew ){
-        if( bQuote==0 && sqlite3IsIdChar(*(u8*)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);
-        assert( nSql < 0x15555554 /* otherwise malloc would have failed */ );
-        sqlite3_snprintf((int)(nSql*2), zBuf2, "%Q%s", zBuf1,
-            pBest->t.z[pBest->t.n]=='\'' ? " " : ""
-        );
-        zReplace = zBuf2;
-        nReplace = sqlite3Strlen30(zReplace);
-      }
-
-      iOff = (int)(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){
-  assert( val==ENAME_NAME || val==ENAME_TAB || val==ENAME_SPAN );
-  if( pEList ){
-    int i;
-    for(i=0; i<pEList->nExpr; i++){
-      assert( val==ENAME_NAME || pEList->a[i].fg.eEName==ENAME_NAME );
-      pEList->a[i].fg.eEName = val&0x3;
-    }
-  }
-}
-
-/*
-** 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)!=0;
-  }
-
-  /* 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->pSrc ){
-      SrcList *pSrc = sqlite3SrcListDup(db, pStep->pSrc, 0);
-      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
-          ** "<col> = <expr>" 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( ALWAYS(pStep->pSrc) ){
-          int i;
-          for(i=0; i<pStep->pSrc->nSrc && rc==SQLITE_OK; i++){
-            SrcItem *p = &pStep->pSrc->a[i];
-            if( p->fg.isSubquery ){
-              assert( p->u4.pSubq!=0 );
-              sqlite3SelectPrep(pParse, p->u4.pSubq->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->pSrc ){
-      int i;
-      SrcList *pSrc = pStep->pSrc;
-      for(i=0; i<pSrc->nSrc; i++){
-        if( pSrc->a[i].fg.isSubquery ){
-          assert( pSrc->a[i].u4.pSubq!=0 );
-          sqlite3WalkSelect(pWalker, pSrc->a[i].u4.pSubq->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 &= ~(u32)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( iCol<sParse.pNewTable->nCol ){
-          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; i<sParse.pNewTable->nCol; 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; i<pFKey->nCol; 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->pSrc ){
-        Table *pTarget = sqlite3LocateTableItem(&sParse, 0, &pStep->pSrc->a[0]);
-        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; i<pSrc->nSrc; i++){
-    SrcItem *pItem = &pSrc->a[i];
-    if( pItem->pSTab==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 &= ~(u32)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->pSrc ){
-                int i;
-                for(i=0; i<pStep->pSrc->nSrc; i++){
-                  SrcItem *pItem = &pStep->pSrc->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 &= ~(u32)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; i<sParse.pNewTable->nCol; 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;
-    u64 flags = db->flags;
-    if( bNoDQS ) db->flags &= ~(SQLITE_DqsDML|SQLITE_DqsDDL);
-    rc = renameParseSql(&sParse, zDb, db, zInput, bTemp);
-    db->flags = flags;
-    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
-}
-
-
-/*
-** Return the number of bytes until the end of the next non-whitespace and
-** non-comment token.  For the purpose of this function, a "(" token includes
-** all of the bytes through and including the matching ")", or until the
-** first illegal token, whichever comes first.
-**
-** Write the token type into *piToken.
-**
-** The value returned is the number of bytes in the token itself plus
-** the number of bytes of leading whitespace and comments skipped plus
-** all bytes through the next matching ")" if the token is TK_LP.
-**
-** Example:    (Note: '.' used in place of '*' in the example z[] text)
-**
-**                                    ,--------- *piToken := TK_RP
-**                                    v
-**    z[] = " /.comment./ --comment\n (two three four) five"
-**          |                                        |
-**          |<-------------------------------------->|
-**                              |
-**                              `--- return value
-*/
-static int getConstraintToken(const u8 *z, int *piToken){
-  int iOff = 0;
-  int t = 0;
-  do {
-    iOff += sqlite3GetToken(&z[iOff], &t);
-  }while( t==TK_SPACE || t==TK_COMMENT );
-
-  *piToken = t;
-
-  if( t==TK_LP ){
-    int nNest = 1;
-    while( nNest>0 ){
-      iOff += sqlite3GetToken(&z[iOff], &t);
-      if( t==TK_LP ){
-        nNest++;
-      }else if( t==TK_RP ){
-        t = TK_LP;
-        nNest--;
-      }else if( t==TK_ILLEGAL ){
-        break;
-      }
-    }
-  }
-
-  *piToken = t;
-  return iOff;
-}
-
-/*
-** 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;
-  }
-
-  if( iCol<pTab->nCol-1 ){
-    RenameToken *pEnd;
-    pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName);
-    pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName);
-    zEnd = (const char*)pEnd->t.z;
-  }else{
-    int eTok;
-    assert( IsOrdinaryTable(pTab) );
-    assert( iCol!=0 );
-    /* Point pCol->t.z at the "," immediately preceding the definition of
-    ** the column being dropped. To do this, start at the name of the
-    ** previous column, and tokenize until the next ",".  */
-    pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol-1].zCnName);
-    do {
-      pCol->t.z += getConstraintToken((const u8*)pCol->t.z, &eTok);
-    }while( eTok!=TK_COMMA );
-    pCol->t.z--;
-    zEnd = (const char*)&zSql[pTab->u.tab.addColOffset];
-  }
-
-  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; i<pPk->nKeyCol; i++){
-        sqlite3VdbeAddOp3(v, OP_Column, iCur, i, reg+i+1);
-      }
-      nField = pPk->nKeyCol;
-    }
-    regRec = ++pParse->nMem;
-    for(i=0; i<pTab->nCol; 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( iPos<pPk->nKeyCol ) continue;
-          regOut = reg+1+iPos-(iPos>iColPos);
-        }else{
-          regOut = reg+1+nField;
-        }
-        if( i==pTab->iPKey ){
-          sqlite3VdbeAddOp2(v, OP_Null, 0, regOut);
-        }else{
-          char aff = pTab->aCol[i].affinity;
-          if( aff==SQLITE_AFF_REAL ){
-            pTab->aCol[i].affinity = SQLITE_AFF_NUMERIC;
-          }
-          sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut);
-          pTab->aCol[i].affinity = aff;
-        }
-        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);
-}
-
-/*
-** Return the number of bytes of leading whitespace/comments in string z[].
-*/
-static int getWhitespace(const u8 *z){
-  int nRet = 0;
-  while( 1 ){
-    int t = 0;
-    int n = sqlite3GetToken(&z[nRet], &t);
-    if( t!=TK_SPACE && t!=TK_COMMENT ) break;
-    nRet += n;
-  }
-  return nRet;
-}
-
-
-/*
-** Argument z points into the body of a constraint - specifically the
-** second token of the constraint definition.  For a named constraint,
-** z points to the first token past the CONSTRAINT keyword.  For an
-** unnamed NOT NULL constraint, z points to the first byte past the NOT
-** keyword.
-**
-** Return the number of bytes until the end of the constraint.
-*/
-static int getConstraint(const u8 *z){
-  int iOff = 0;
-  int t = 0;
-
-  /* Now, the current constraint proceeds until the next occurence of one
-  ** of the following tokens:
-  **
-  **   CONSTRAINT, PRIMARY, NOT, UNIQUE, CHECK, DEFAULT,
-  **   COLLATE, REFERENCES, FOREIGN, GENERATED, AS, RP, or COMMA
-  **
-  ** Also exit the loop if ILLEGAL turns up.
-  */
-  while( 1 ){
-    int n = getConstraintToken(&z[iOff], &t);
-    if( t==TK_CONSTRAINT || t==TK_PRIMARY || t==TK_NOT || t==TK_UNIQUE
-     || t==TK_CHECK || t==TK_DEFAULT || t==TK_COLLATE || t==TK_REFERENCES
-     || t==TK_FOREIGN || t==TK_RP || t==TK_COMMA || t==TK_ILLEGAL
-     || t==TK_AS || t==TK_GENERATED
-    ){
-      break;
-    }
-    iOff += n;
-  }
-
-  return iOff;
-}
-
-/*
-** Compare two constraint names.
-**
-** Summary:   *pRes := zQuote != zCmp
-**
-** Details:
-** Compare the (possibly quoted) constraint name zQuote[0..nQuote-1]
-** against zCmp[].  Write zero into *pRes if they are the same and
-** non-zero if they differ.  Normally return SQLITE_OK, except if there
-** is an OOM, set the OOM error condition on ctx and return SQLITE_NOMEM.
-*/
-static int quotedCompare(
-  sqlite3_context *ctx,  /* Function context on which to report errors */
-  int t,                 /* Token type */
-  const u8 *zQuote,      /* Possibly quoted text.  Not zero-terminated. */
-  int nQuote,            /* Length of zQuote in bytes */
-  const u8 *zCmp,        /* Zero-terminated, unquoted name to compare against */
-  int *pRes              /* OUT: Set to 0 if equal, non-zero if unequal */
-){
-  char *zCopy = 0;       /* De-quoted, zero-terminated copy of zQuote[] */
-
-  if( t==TK_ILLEGAL ){
-    *pRes = 1;
-    return SQLITE_OK;
-  }
-  zCopy = sqlite3MallocZero(nQuote+1);
-  if( zCopy==0 ){
-    sqlite3_result_error_nomem(ctx);
-    return SQLITE_NOMEM_BKPT;
-  }
-  memcpy(zCopy, zQuote, nQuote);
-  sqlite3Dequote(zCopy);
-  *pRes = sqlite3_stricmp((const char*)zCopy, (const char*)zCmp);
-  sqlite3_free(zCopy);
-  return SQLITE_OK;
-}
-
-/*
-** zSql[] is a CREATE TABLE statement, supposedly.  Find the offset
-** into zSql[] of the first character past the first "(" and write
-** that offset into *piOff and return SQLITE_OK.  Or, if not found,
-** set the SQLITE_CORRUPT error code and return SQLITE_ERROR.
-*/
-static int skipCreateTable(sqlite3_context *ctx, const u8 *zSql, int *piOff){
-  int iOff = 0;
-
-  if( zSql==0 ) return SQLITE_ERROR;
-
-  /* Jump past the "CREATE TABLE" bit. */
-  while( 1 ){
-    int t = 0;
-    iOff += sqlite3GetToken(&zSql[iOff], &t);
-    if( t==TK_LP ) break;
-    if( t==TK_ILLEGAL ){
-      sqlite3_result_error_code(ctx, SQLITE_CORRUPT_BKPT);
-      return SQLITE_ERROR;
-    }
-  }
-
-  *piOff = iOff;
-  return SQLITE_OK;
-}
-
-/*
-** Internal SQL function sqlite3_drop_constraint():  Given an input
-** CREATE TABLE statement, return a revised CREATE TABLE statement
-** with a constraint removed.  Two forms, depending on the datatype
-** of argv[2]:
-**
-**   sqlite_drop_constraint(SQL, INT)  -- Omit NOT NULL from the INT-th column
-**   sqlite_drop_constraint(SQL, TEXT) -- OMIT constraint with name TEXT
-**
-** In the first case, the left-most column is 0.
-*/
-static void dropConstraintFunc(
-  sqlite3_context *ctx,
-  int NotUsed,
-  sqlite3_value **argv
-){
-  const u8 *zSql = sqlite3_value_text(argv[0]);
-  const u8 *zCons = 0;
-  int iNotNull = -1;
-  int ii;
-  int iOff = 0;
-  int iStart = 0;
-  int iEnd = 0;
-  char *zNew = 0;
-  int t = 0;
-  sqlite3 *db;
-  UNUSED_PARAMETER(NotUsed);
-
-  if( zSql==0 ) return;
-
-  /* Jump past the "CREATE TABLE" bit. */
-  if( skipCreateTable(ctx, zSql, &iOff) ) return;
-
-  if( sqlite3_value_type(argv[1])==SQLITE_INTEGER ){
-    iNotNull = sqlite3_value_int(argv[1]);
-  }else{
-    zCons = sqlite3_value_text(argv[1]);
-  }
-
-  /* Search for the named constraint within column definitions. */
-  for(ii=0; iEnd==0; ii++){
-
-    /* Now parse the column or table constraint definition. Search
-    ** for the token CONSTRAINT if this is a DROP CONSTRAINT command, or
-    ** NOT in the right column if this is a DROP NOT NULL. */
-    while( 1 ){
-      iStart = iOff;
-      iOff += getConstraintToken(&zSql[iOff], &t);
-      if( t==TK_CONSTRAINT && (zCons || iNotNull==ii) ){
-        /* Check if this is the constraint we are searching for. */
-        int nTok = 0;
-        int cmp = 1;
-
-        /* Skip past any whitespace. */
-        iOff += getWhitespace(&zSql[iOff]);
-
-        /* Compare the next token - which may be quoted - with the name of
-        ** the constraint being dropped.  */
-        nTok = getConstraintToken(&zSql[iOff], &t);
-        if( zCons ){
-          if( quotedCompare(ctx, t, &zSql[iOff], nTok, zCons, &cmp) ) return;
-        }
-        iOff += nTok;
-
-        /* The next token is usually the first token of the constraint
-        ** definition. This is enough to tell the type of the constraint -
-        ** TK_NOT means it is a NOT NULL, TK_CHECK a CHECK constraint etc.
-        **
-        ** There is also the chance that the next token is TK_CONSTRAINT
-        ** (or TK_DEFAULT or TK_COLLATE), for example if a table has been
-        ** created as follows:
-        **
-        **    CREATE TABLE t1(cols, CONSTRAINT one CONSTRAINT two NOT NULL);
-        **
-        ** In this case, allow the "CONSTRAINT one" bit to be dropped by
-        ** this command if that is what is requested, or to advance to
-        ** the next iteration of the loop with &zSql[iOff] still pointing
-        ** to the CONSTRAINT keyword.  */
-        nTok = getConstraintToken(&zSql[iOff], &t);
-        if( t==TK_CONSTRAINT || t==TK_DEFAULT || t==TK_COLLATE
-         || t==TK_COMMA || t==TK_RP || t==TK_GENERATED || t==TK_AS
-        ){
-          t = TK_CHECK;
-        }else{
-          iOff += nTok;
-          iOff += getConstraint(&zSql[iOff]);
-        }
-
-        if( cmp==0 || (iNotNull>=0 && t==TK_NOT) ){
-          if( t!=TK_NOT && t!=TK_CHECK ){
-            errorMPrintf(ctx, "constraint may not be dropped: %s", zCons);
-            return;
-          }
-          iEnd = iOff;
-          break;
-        }
-
-      }else if( t==TK_NOT && iNotNull==ii ){
-        iEnd = iOff + getConstraint(&zSql[iOff]);
-        break;
-      }else if( t==TK_RP || t==TK_ILLEGAL ){
-        iEnd = -1;
-        break;
-      }else if( t==TK_COMMA ){
-        break;
-      }
-    }
-  }
-
-  /* If the constraint has not been found it is an error. */
-  if( iEnd<=0 ){
-    if( zCons ){
-      errorMPrintf(ctx, "no such constraint: %s", zCons);
-    }else{
-      /* SQLite follows postgres in that a DROP NOT NULL on a column that is
-      ** not NOT NULL is not an error. So just return the original SQL here. */
-      sqlite3_result_text(ctx, (const char*)zSql, -1, SQLITE_TRANSIENT);
-    }
-  }else{
-
-    /* Figure out if an extra space should be inserted after the constraint
-    ** is removed. And if an additional comma preceding the constraint
-    ** should be removed. */
-    const char *zSpace = " ";
-    iEnd += getWhitespace(&zSql[iEnd]);
-    sqlite3GetToken(&zSql[iEnd], &t);
-    if( t==TK_RP || t==TK_COMMA ){
-      zSpace = "";
-      if( zSql[iStart-1]==',' ) iStart--;
-    }
-
-    db = sqlite3_context_db_handle(ctx);
-    zNew = sqlite3MPrintf(db, "%.*s%s%s", iStart, zSql, zSpace, &zSql[iEnd]);
-    sqlite3_result_text(ctx, zNew, -1, SQLITE_DYNAMIC);
-  }
-}
-
-/*
-** Internal SQL function:
-**
-**     sqlite_add_constraint(SQL, CONSTRAINT-TEXT, ICOL)
-**
-** SQL is a CREATE TABLE statement.  Return a modified version of
-** SQL that adds CONSTRAINT-TEXT at the end of the ICOL-th column
-** definition.  (The left-most column defintion is 0.)
-*/
-static void addConstraintFunc(
-  sqlite3_context *ctx,
-  int NotUsed,
-  sqlite3_value **argv
-){
-  const u8 *zSql = sqlite3_value_text(argv[0]);
-  const char *zCons = (const char*)sqlite3_value_text(argv[1]);
-  int iCol = sqlite3_value_int(argv[2]);
-  int iOff = 0;
-  int ii;
-  char *zNew = 0;
-  int t = 0;
-  sqlite3 *db;
-  UNUSED_PARAMETER(NotUsed);
-
-  if( skipCreateTable(ctx, zSql, &iOff) ) return;
-
-  for(ii=0; ii<=iCol || (iCol<0 && t!=TK_RP); ii++){
-    iOff += getConstraintToken(&zSql[iOff], &t);
-    while( 1 ){
-      int nTok = getConstraintToken(&zSql[iOff], &t);
-      if( t==TK_COMMA || t==TK_RP ) break;
-      if( t==TK_ILLEGAL ){
-        sqlite3_result_error_code(ctx, SQLITE_CORRUPT_BKPT);
-        return;
-      }
-      iOff += nTok;
-    }
-  }
-
-  iOff += getWhitespace(&zSql[iOff]);
-
-  db = sqlite3_context_db_handle(ctx);
-  if( iCol<0 ){
-    zNew = sqlite3MPrintf(db, "%.*s, %s%s", iOff, zSql, zCons, &zSql[iOff]);
-  }else{
-    zNew = sqlite3MPrintf(db, "%.*s %s%s", iOff, zSql, zCons, &zSql[iOff]);
-  }
-  sqlite3_result_text(ctx, zNew, -1, SQLITE_DYNAMIC);
-}
-
-/*
-** Find a column named pCol in table pTab. If successful, set output
-** parameter *piCol to the index of the column in the table and return
-** SQLITE_OK. Otherwise, set *piCol to -1 and return an SQLite error
-** code.
-*/
-static int alterFindCol(Parse *pParse, Table *pTab, Token *pCol, int *piCol){
-  sqlite3 *db = pParse->db;
-  char *zName = sqlite3NameFromToken(db, pCol);
-  int rc = SQLITE_NOMEM;
-  int iCol = -1;
-
-  if( zName ){
-    iCol = sqlite3ColumnIndex(pTab, zName);
-    if( iCol<0 ){
-      sqlite3ErrorMsg(pParse, "no such column: %s", zName);
-      rc = SQLITE_ERROR;
-    }else{
-      rc = SQLITE_OK;
-    }
-  }
-
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  if( rc==SQLITE_OK ){
-    const char *zDb = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName;
-    const char *zCol = pTab->aCol[iCol].zCnName;
-    if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, zCol) ){
-      pTab = 0;
-    }
-  }
-#endif
-
-  sqlite3DbFree(db, zName);
-  *piCol = iCol;
-  return rc;
-}
-
-
-/*
-** Find the table named by the first entry in source list pSrc. If successful,
-** return a pointer to the Table structure and set output variable (*pzDb)
-** to point to the name of the database containin the table (i.e. "main",
-** "temp" or the name of an attached database).
-**
-** If the table cannot be located, return NULL. The value of the two output
-** parameters is undefined in this case.
-*/
-static Table *alterFindTable(
-  Parse *pParse,        /* Parsing context */
-  SrcList *pSrc,        /* Name of the table to look for */
-  int *piDb,            /* OUT: write the iDb here */
-  const char **pzDb,    /* OUT: write name of schema here */
-  int bAuth             /* Do ALTER TABLE authorization checks if true */
-){
-  sqlite3 *db = pParse->db;
-  Table *pTab = 0;
-  assert( sqlite3BtreeHoldsAllMutexes(db) );
-  pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
-  if( pTab ){
-    int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-    *pzDb = db->aDb[iDb].zDbSName;
-    *piDb = iDb;
-
-    if( SQLITE_OK!=isRealTable(pParse, pTab, 2)
-     || SQLITE_OK!=isAlterableTable(pParse, pTab)
-    ){
-      pTab = 0;
-    }
-  }
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  if( pTab && bAuth ){
-    if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, *pzDb, pTab->zName, 0) ){
-      pTab = 0;
-    }
-  }
-#endif
-  sqlite3SrcListDelete(db, pSrc);
-  return pTab;
-}
-
-/*
-** Generate bytecode for one of:
-**
-**  (1)   ALTER TABLE pSrc DROP CONSTRAINT pCons
-**  (2)   ALTER TABLE pSrc ALTER pCol DROP NOT NULL
-**
-** One of pCons and pCol must be NULL and the other non-null.
-*/
-SQLITE_PRIVATE void sqlite3AlterDropConstraint(
-  Parse *pParse,    /* Parsing context */
-  SrcList *pSrc,    /* The table being altered */
-  Token *pCons,     /* Name of the constraint to drop */
-  Token *pCol       /* Name of the column from which to remove the NOT NULL */
-){
-  sqlite3 *db = pParse->db;
-  Table *pTab = 0;
-  int iDb = 0;
-  const char *zDb = 0;
-  char *zArg = 0;
-
-  assert( (pCol==0)!=(pCons==0) );
-  assert( pSrc->nSrc==1 );
-  pTab = alterFindTable(pParse, pSrc, &iDb, &zDb, pCons!=0);
-  if( !pTab ) return;
-
-  if( pCons ){
-    char *z = sqlite3NameFromToken(db, pCons);
-    zArg = sqlite3MPrintf(db, "%Q", z);
-    sqlite3DbFree(db, z);
-  }else{
-    int iCol;
-    if( alterFindCol(pParse, pTab, pCol, &iCol) ) return;
-    zArg = sqlite3MPrintf(db, "%d", iCol);
-  }
-
-  /* Edit the SQL for the named table. */
-  sqlite3NestedParse(pParse,
-      "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "
-      "sql = sqlite_drop_constraint(sql, %s) "
-      "WHERE type='table' AND tbl_name=%Q COLLATE nocase"
-      , zDb, zArg, pTab->zName
-  );
-  sqlite3DbFree(db, zArg);
-
-  /* Finally, reload the database schema. */
-  renameReloadSchema(pParse, iDb, INITFLAG_AlterDropCons);
-}
-
-/*
-** The implementation of SQL function sqlite_fail(MSG). This takes a single
-** argument, and returns it as an error message with the error code set to
-** SQLITE_CONSTRAINT.
-*/
-static void failConstraintFunc(
-  sqlite3_context *ctx,
-  int NotUsed,
-  sqlite3_value **argv
-){
-  const char *zText = (const char*)sqlite3_value_text(argv[0]);
-  int err = sqlite3_value_int(argv[1]);
-  (void)NotUsed;
-  sqlite3_result_error(ctx, zText, -1);
-  sqlite3_result_error_code(ctx, err);
-}
-
-/*
-** Buffer pCons, which is nCons bytes in size, contains the text of a
-** NOT NULL or CHECK constraint that will be inserted into a CREATE TABLE
-** statement. If successful, this function returns the size of the buffer in
-** bytes not including any trailing whitespace or "--" style comments. Or,
-** if an OOM occurs, it returns 0 and sets db->mallocFailed to true.
-**
-** C-style comments at the end are preserved.  "--" style comments are
-** removed because the comment terminator might be \000, and we are about
-** to insert the pCons[] text into the middle of a larger string, and that
-** will have the effect of removing the comment terminator and messing up
-** the syntax.
-*/
-static int alterRtrimConstraint(
-  sqlite3 *db,                    /* used to record OOM error */
-  const char *pCons,              /* Buffer containing constraint */
-  int nCons                       /* Size of pCons in bytes */
-){
-  u8 *zTmp = (u8*)sqlite3MPrintf(db, "%.*s", nCons, pCons);
-  int iOff = 0;
-  int iEnd = 0;
-
-  if( zTmp==0 ) return 0;
-
-  while( 1 ){
-    int t = 0;
-    int nToken = sqlite3GetToken(&zTmp[iOff], &t);
-    if( t==TK_ILLEGAL ) break;
-    if( t!=TK_SPACE && (t!=TK_COMMENT || zTmp[iOff]!='-') ){
-      iEnd = iOff+nToken;
-    }
-    iOff += nToken;
-  }
-
-  sqlite3DbFree(db, zTmp);
-  return iEnd;
-}
-
-/*
-** Prepare a statement of the form:
-**
-**   ALTER TABLE pSrc ALTER pCol SET NOT NULL
-*/
-SQLITE_PRIVATE void sqlite3AlterSetNotNull(
-  Parse *pParse,   /* Parsing context */
-  SrcList *pSrc,   /* Name of the table being altered */
-  Token *pCol,     /* Name of the column to add a NOT NULL constraint to */
-  Token *pFirst    /* The NOT token of the NOT NULL constraint text */
-){
-  Table *pTab = 0;
-  int iCol = 0;
-  int iDb = 0;
-  const char *zDb = 0;
-  const char *pCons = 0;
-  int nCons = 0;
-
-  /* Look up the table being altered. */
-  assert( pSrc->nSrc==1 );
-  pTab = alterFindTable(pParse, pSrc, &iDb, &zDb, 0);
-  if( !pTab ) return;
-
-  /* Find the column being altered. */
-  if( alterFindCol(pParse, pTab, pCol, &iCol) ){
-    return;
-  }
-
-  /* Find the length in bytes of the constraint definition */
-  pCons = pFirst->z;
-  nCons = alterRtrimConstraint(pParse->db, pCons, pParse->sLastToken.z - pCons);
-
-  /* Search for a constraint violation. Throw an exception if one is found. */
-  sqlite3NestedParse(pParse,
-      "SELECT sqlite_fail('constraint failed', %d) "
-      "FROM %Q.%Q AS x WHERE x.%.*s IS NULL",
-      SQLITE_CONSTRAINT, zDb, pTab->zName, (int)pCol->n, pCol->z
-  );
-
-  /* Edit the SQL for the named table. */
-  sqlite3NestedParse(pParse,
-      "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "
-      "sql = sqlite_add_constraint(sqlite_drop_constraint(sql, %d), %.*Q, %d) "
-      "WHERE type='table' AND tbl_name=%Q COLLATE nocase"
-      , zDb, iCol, nCons, pCons, iCol, pTab->zName
-  );
-
-  /* Finally, reload the database schema. */
-  renameReloadSchema(pParse, iDb, INITFLAG_AlterDropCons);
-}
-
-/*
-** Implementation of internal SQL function:
-**
-**     sqlite_find_constraint(SQL, CONSTRAINT-NAME)
-**
-** This function returns true if the SQL passed as the first argument is a
-** CREATE TABLE that contains a constraint with the name CONSTRAINT-NAME,
-** or false otherwise.
-*/
-static void findConstraintFunc(
-  sqlite3_context *ctx,
-  int NotUsed,
-  sqlite3_value **argv
-){
-  const u8 *zSql = 0;
-  const u8 *zCons = 0;
-  int iOff = 0;
-  int t = 0;
-
-  (void)NotUsed;
-  zSql = sqlite3_value_text(argv[0]);
-  zCons = sqlite3_value_text(argv[1]);
-
-  if( zSql==0 || zCons==0 ) return;
-  while( t!=TK_LP && t!=TK_ILLEGAL ){
-    iOff += sqlite3GetToken(&zSql[iOff], &t);
-  }
-
-  while( 1 ){
-    iOff += getConstraintToken(&zSql[iOff], &t);
-    if( t==TK_CONSTRAINT ){
-      int nTok = 0;
-      int cmp = 0;
-      iOff += getWhitespace(&zSql[iOff]);
-      nTok = getConstraintToken(&zSql[iOff], &t);
-      if( quotedCompare(ctx, t, &zSql[iOff], nTok, zCons, &cmp) ) return;
-      if( cmp==0 ){
-        sqlite3_result_int(ctx, 1);
-        return;
-      }
-    }else if( t==TK_ILLEGAL ){
-      break;
-    }
-  }
-
-  sqlite3_result_int(ctx, 0);
-}
-
-/*
-** Generate bytecode to implement:
-**
-**    ALTER TABLE pSrc ADD [CONSTRAINT pName] CHECK(pExpr)
-**
-** Any "ON CONFLICT" text that occurs after the "CHECK(...)", up
-** until pParse->sLastToken, is included as part of the new constraint.
-*/
-SQLITE_PRIVATE void sqlite3AlterAddConstraint(
-  Parse *pParse,           /* Parse context */
-  SrcList *pSrc,           /* Table to add constraint to */
-  Token *pFirst,           /* First token of new constraint */
-  Token *pName,            /* Name of new constraint. NULL if name omitted. */
-  const char *pExpr,       /* Text of CHECK expression */
-  int nExpr                /* Size of pExpr in bytes */
-){
-  Table *pTab = 0;         /* Table identified by pSrc */
-  int iDb = 0;             /* Which schema does pTab live in */
-  const char *zDb = 0;     /* Name of the schema in which pTab lives */
-  const char *pCons = 0;   /* Text of the constraint */
-  int nCons;               /* Bytes of text to use from pCons[] */
-
-  /* Look up the table being altered. */
-  assert( pSrc->nSrc==1 );
-  pTab = alterFindTable(pParse, pSrc, &iDb, &zDb, 1);
-  if( !pTab ) return;
-
-  /* If this new constraint has a name, check that it is not a duplicate of
-  ** an existing constraint. It is an error if it is.  */
-  if( pName ){
-    char *zName = sqlite3NameFromToken(pParse->db, pName);
-
-    sqlite3NestedParse(pParse,
-        "SELECT sqlite_fail('constraint %q already exists', %d) "
-        "FROM \"%w\"." LEGACY_SCHEMA_TABLE " "
-        "WHERE type='table' AND tbl_name=%Q COLLATE nocase "
-        "AND sqlite_find_constraint(sql, %Q)",
-        zName, SQLITE_ERROR, zDb, pTab->zName, zName
-    );
-    sqlite3DbFree(pParse->db, zName);
-  }
-
-  /* Search for a constraint violation. Throw an exception if one is found. */
-  sqlite3NestedParse(pParse,
-      "SELECT sqlite_fail('constraint failed', %d) "
-      "FROM %Q.%Q WHERE (%.*s) IS NOT TRUE",
-      SQLITE_CONSTRAINT, zDb, pTab->zName, nExpr, pExpr
-  );
-
-  /* Edit the SQL for the named table. */
-  pCons = pFirst->z;
-  nCons = alterRtrimConstraint(pParse->db, pCons, pParse->sLastToken.z - pCons);
-
-  sqlite3NestedParse(pParse,
-      "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "
-      "sql = sqlite_add_constraint(sql, %.*Q, -1) "
-      "WHERE type='table' AND tbl_name=%Q COLLATE nocase"
-      , zDb, nCons, pCons, pTab->zName
-  );
-
-  /* Finally, reload the database schema. */
-  renameReloadSchema(pParse, iDb, INITFLAG_AlterDropCons);
-}
-
-/*
-** 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),
-    INTERNAL_FUNCTION(sqlite_drop_constraint,2, dropConstraintFunc),
-    INTERNAL_FUNCTION(sqlite_fail,           2, failConstraintFunc),
-    INTERNAL_FUNCTION(sqlite_add_constraint, 3, addConstraintFunc),
-    INTERNAL_FUNCTION(sqlite_find_constraint,2, findConstraintFunc),
-  };
-  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; i<ArraySize(aTable); i++){
-    const char *zTab = aTable[i].zName;
-    Table *pStat;
-    aCreateTbl[i] = 0;
-    if( (pStat = sqlite3FindTable(db, zTab, pDb->zDbSName))==0 ){
-      if( i<nToOpen ){
-        /* The sqlite_statN table does not exist. Create it. Note that a
-        ** side-effect of the CREATE TABLE statement is to leave the rootpage
-        ** of the new table in register pParse->regRoot. 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
-        );
-        assert( pParse->isCreate || pParse->nErr );
-        aRoot[i] = (u32)pParse->u1.cr.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; i<nToOpen; i++){
-    assert( i<ArraySize(aTable) );
-    sqlite3VdbeAddOp4Int(v, OP_OpenWrite, iStatCur+i, (int)aRoot[i], iDb, 3);
-    sqlite3VdbeChangeP5(v, aCreateTbl[i]);
-    VdbeComment((v, aTable[i].zName));
-  }
-}
-
-/*
-** Recommended number of samples for sqlite_stat4
-*/
-#ifndef SQLITE_STAT4_SAMPLES
-# define SQLITE_STAT4_SAMPLES 24
-#endif
-
-/*
-** Three SQL functions - stat_init(), stat_push(), and stat_get() -
-** share an instance of the following structure to hold their state
-** information.
-*/
-typedef struct StatAccum StatAccum;
-typedef struct StatSample StatSample;
-struct StatSample {
-  tRowcnt *anDLt;                 /* sqlite_stat4.nDLt */
-#ifdef SQLITE_ENABLE_STAT4
-  tRowcnt *anEq;                  /* sqlite_stat4.nEq */
-  tRowcnt *anLt;                  /* sqlite_stat4.nLt */
-  union {
-    i64 iRowid;                     /* Rowid in main table of the key */
-    u8 *aRowid;                     /* Key for WITHOUT ROWID tables */
-  } u;
-  u32 nRowid;                     /* Sizeof aRowid[] */
-  u8 isPSample;                   /* True if a periodic sample */
-  int iCol;                       /* If !isPSample, the reason for inclusion */
-  u32 iHash;                      /* Tiebreaker hash */
-#endif
-};
-struct StatAccum {
-  sqlite3 *db;              /* Database connection, for malloc() */
-  tRowcnt nEst;             /* Estimated number of rows */
-  tRowcnt nRow;             /* Number of rows visited so far */
-  int nLimit;               /* Analysis row-scan limit */
-  int nCol;                 /* Number of columns in index + pk/rowid */
-  int nKeyCol;              /* Number of index columns w/o the pk/rowid */
-  u8 nSkipAhead;            /* Number of times of skip-ahead */
-  StatSample current;       /* Current row as a StatSample */
-#ifdef SQLITE_ENABLE_STAT4
-  tRowcnt nPSample;         /* How often to do a periodic sample */
-  int mxSample;             /* Maximum number of samples to accumulate */
-  u32 iPrn;                 /* Pseudo-random number used for sampling */
-  StatSample *aBest;        /* Array of nCol best samples */
-  int iMin;                 /* Index in a[] of entry with minimum score */
-  int nSample;              /* Current number of samples */
-  int nMaxEqZero;           /* Max leading 0 in anEq[] for any a[] entry */
-  int iGet;                 /* Index of current sample accessed by stat_get() */
-  StatSample *a;            /* Array of mxSample StatSample objects */
-#endif
-};
-
-/* Reclaim memory used by a StatSample
-*/
-#ifdef SQLITE_ENABLE_STAT4
-static void sampleClear(sqlite3 *db, StatSample *p){
-  assert( db!=0 );
-  if( p->nRowid ){
-    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; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
-    for(i=0; i<p->mxSample; 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 */
-  i64 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.anDLt */
-#ifdef SQLITE_ENABLE_STAT4
-  n += sizeof(tRowcnt)*nColUp;                   /* StatAccum.anEq */
-  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_int(argv[3]);
-  p->nCol = nCol;
-  p->nKeyCol = nKeyCol;
-  p->nSkipAhead = 0;
-  p->current.anDLt = (tRowcnt*)&p[1];
-
-#ifdef SQLITE_ENABLE_STAT4
-  p->current.anEq = &p->current.anDLt[nColUp];
-  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; i<nCol; i++){
-      p->aBest[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; i<nCol; i++){
-    if( pNew->anEq[i]>pOld->anEq[i] ) return 1;
-    if( pNew->anEq[i]<pOld->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->iCol<pOld->iCol ) 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; i<p->mxSample; 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->nSample<p->mxSample || 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; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
-  }
-
-  /* Update the anEq[] fields of any samples already collected. */
-  if( iChng<p->nMaxEqZero ){
-    for(i=p->nSample-1; i>=0; i--){
-      int j;
-      for(j=iChng; j<p->nCol; 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( iChng<p->nCol );
-
-  if( p->nRow==0 ){
-    /* This is the first call to this function. Do initialization. */
-#ifdef SQLITE_ENABLE_STAT4
-    for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
-#endif
-  }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. */
-#ifdef SQLITE_ENABLE_STAT4
-    for(i=0; i<iChng; i++){
-      p->current.anEq[i]++;
-    }
-#endif
-    for(i=iChng; i<p->nCol; i++){
-      p->current.anDLt[i]++;
-#ifdef SQLITE_ENABLE_STAT4
-      if( p->mxSample ) p->current.anLt[i] += p->current.anEq[i];
-      p->current.anEq[i] = 1;
-#endif
-    }
-  }
-
-  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; i<p->nKeyCol; 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);
-#ifdef SQLITE_ENABLE_STAT4
-      assert( p->current.anEq[i] || p->nRow==0 );
-#endif
-    }
-    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->iGet<p->nSample ){
-      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->iGet<p->nSample );
-    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; i<p->nCol; 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 && k<pIdx->nColumn );
-  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 addrGotoEnd;               /* 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():
-    **
-    **   regChng = 0
-    **   Rewind csr
-    **   if eof(csr){
-    **      stat_init() with count = 0;
-    **      goto end_of_scan;
-    **   }
-    **   count()
-    **   stat_init()
-    **   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));
-
-    /* Implementation of the following:
-    **
-    **   regChng = 0
-    **   Rewind csr
-    **   if eof(csr){
-    **      stat_init() with count = 0;
-    **      goto end_of_scan;
-    **   }
-    **   count()
-    **   stat_init()
-    **   goto chng_addr_0;
-    */
-    assert( regTemp2==regStat+4 );
-    sqlite3VdbeAddOp2(v, OP_Integer, db->nAnalysisLimit, regTemp2);
-
-    /* Arguments to stat_init():
-    **    (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);
-    sqlite3VdbeAddOp3(v, OP_Count, iIdxCur, regTemp,
-                      OptimizationDisabled(db, SQLITE_Stat4));
-    sqlite3VdbeAddFunctionCall(pParse, 0, regStat+1, regStat, 4,
-                               &statInitFuncdef, 0);
-    addrGotoEnd = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur);
-    VdbeCoverage(v);
-
-    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; i<nColTest; i++){
-        char *pColl = (char*)sqlite3LocateCollSeq(pParse, pIdx->azColl[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; i<nColTest; i++){
-        sqlite3VdbeJumpHere(v, aGotoChng[i]);
-        sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regPrev+i);
-        analyzeVdbeCommentIndexWithColumnName(v,pIdx,i);
-      }
-      sqlite3VdbeResolveLabel(v, endDistinctTest);
-      sqlite3DbFree(db, aGotoChng);
-    }
-
-    /*
-    **  chng_addr_N:
-    **   regRowid = idx(rowid)            // STAT4 only
-    **   stat_push(P, regChng, regRowid)  // 3rd parameter STAT4 only
-    **   Next csr
-    **   if !eof(csr) goto next_row;
-    */
-#ifdef SQLITE_ENABLE_STAT4
-    if( OptimizationEnabled(db, SQLITE_Stat4) ){
-      assert( regRowid==(regStat+2) );
-      if( HasRowid(pTab) ){
-        sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, regRowid);
-      }else{
-        Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
-        int j, k, regKey;
-        regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol);
-        for(j=0; j<pPk->nKeyCol; j++){
-          k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]);
-          assert( k>=0 && k<pIdx->nColumn );
-          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. */
-    if( pIdx->pPartIdxWhere ){
-      /* Partial indexes might get a zero-entry in sqlite_stat1.  But
-      ** an empty table is omitted from sqlite_stat1. */
-      sqlite3VdbeJumpHere(v, addrGotoEnd);
-      addrGotoEnd = 0;
-    }
-    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;
-
-      /* No STAT4 data is generated if the number of rows is zero */
-      if( addrGotoEnd==0 ){
-        sqlite3VdbeAddOp2(v, OP_Cast, regStat1, SQLITE_AFF_INTEGER);
-        addrGotoEnd = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1);
-        VdbeCoverage(v);
-      }
-
-      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; i<nCol; i++){
-        sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iTabCur, i, regCol+i);
-      }
-      sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
-      sqlite3VdbeAddOp3(v, OP_MakeRecord, regTabname, 6, regTemp);
-      sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur+1, regNewRowid);
-      sqlite3VdbeAddOp3(v, OP_Insert, iStatCur+1, regTemp, regNewRowid);
-      sqlite3VdbeAddOp2(v, OP_Goto, 1, addrNext); /* P1==1 for end-of-loop */
-      sqlite3VdbeJumpHere(v, addrIsNull);
-    }
-#endif /* SQLITE_ENABLE_STAT4 */
-
-    /* End of analysis */
-    if( addrGotoEnd ) sqlite3VdbeJumpHere(v, addrGotoEnd);
-  }
-
-
-  /* Create a single sqlite_stat1 entry containing NULL as the index
-  ** name and the row count as the content.
-  */
-  if( pOnlyIdx==0 && needTableCnt ){
-    VdbeComment((v, "%s", pTab->zName));
-    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  <database>                -- 2
-**        ANALYZE  ?<database>.?<tablename>  -- 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; i<db->nDb; 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<nOut; i++){
-    v = 0;
-    while( (c=z[0])>='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; j<pIdx->nSample; 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; iCol<nCol; iCol++){
-      int nSample = pIdx->nSample;
-      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; i<nSample; i++){
-        if( i==(pIdx->nSample-1)
-         || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol]
-        ){
-          sumEq += aSample[i].anEq[iCol];
-          nSum100 += 100;
-        }
-      }
-
-      if( nDist100>nSum100 && sumEq<nRow ){
-        avgEq = ((i64)100 * (nRow - sumEq))/(nDist100 - nSum100);
-      }
-      if( avgEq==0 ) avgEq = 1;
-      pIdx->aAvgEq[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 */
-    i64 nByte;       /* Bytes of space required */
-    i64 i;           /* Bytes of space required */
-    tRowcnt *pSpace; /* Available allocated memory space */
-    u8 *pPtr;        /* Available memory as a u8 for easier manipulation */
-
-    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 = ROUND8(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;
-    }
-    pPtr = (u8*)pIdx->aSample;
-    pPtr += ROUND8(nSample*sizeof(pIdx->aSample[0]));
-    pSpace = (tRowcnt*)pPtr;
-    assert( EIGHT_BYTE_ALIGNMENT( pSpace ) );
-    pIdx->aAvgEq = pSpace; pSpace += nIdxCol;
-    pIdx->pTable->tabFlags |= TF_HasStat4;
-    for(i=0; i<nSample; i++){
-      pIdx->aSample[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 8 extra 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.  Or it might try to read a large integer from the
-    ** buffer.  In any case, eight 0x00 bytes prevents this from causing
-    ** a buffer overread.  */
-    pSample->n = sqlite3_column_bytes(pStmt, 4);
-    pSample->p = sqlite3DbMallocZero(db, pSample->n + 8);
-    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 && iDb<db->nDb );
-  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;
-
-    pNew = &db->aDb[db->init.iDb];
-    assert( pNew->pBt!=0 );
-    if( sqlite3BtreeTxnState(pNew->pBt)!=SQLITE_TXN_NONE
-     || sqlite3BtreeIsInBackup(pNew->pBt)
-    ){
-      rc = SQLITE_BUSY;
-      goto attach_error;
-    }
-
-    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.  */
-        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; i<db->nDb; 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])*(1+(i64)db->nDb));
-      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;
-    }
-    if( (db->flags & SQLITE_AttachWrite)==0 ){
-      flags &= ~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE);
-      flags |= SQLITE_OPEN_READONLY;
-    }else if( (db->flags & SQLITE_AttachCreate)==0 ){
-      flags &= ~SQLITE_OPEN_CREATE;
-    }
-    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;
-  }
-  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);
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    if( db->setlkFlags & SQLITE_SETLK_BLOCK_ON_CONNECT ){
-      int val = 1;
-      sqlite3_file *fd = sqlite3PagerFile(sqlite3BtreePager(pNew->pBt));
-      sqlite3OsFileControlHint(fd, SQLITE_FCNTL_BLOCK_ON_CONNECT, &val);
-    }
-#endif
-    if( !REOPEN_AS_MEMDB(db) ){
-      rc = sqlite3Init(db, &zErrDyn);
-    }
-    sqlite3BtreeLeaveAll(db);
-    assert( zErrDyn==0 || rc!=SQLITE_OK );
-  }
-  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; i<db->nDb; 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; i<pList->nSrc; i++, pItem++){
-    if( pFix->bTemp==0 && pItem->fg.isSubquery==0 ){
-      if( pItem->fg.fixedSchema==0 && pItem->u4.zDatabase!=0 ){
-        if( iDb!=sqlite3FindDbName(db, pItem->u4.zDatabase) ){
-          sqlite3ErrorMsg(pFix->pParse,
-              "%s %T cannot reference objects in database %s",
-              pFix->zType, pFix->pName, pItem->u4.zDatabase);
-          return WRC_Abort;
-        }
-        sqlite3DbFree(db, pItem->u4.zDatabase);
-        pItem->fg.notCte = 1;
-        pItem->fg.hadSchema = 1;
-      }
-      pItem->u4.pSchema = pFix->pSchema;
-      pItem->fg.fromDDL = 1;
-      pItem->fg.fixedSchema = 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; i<pSelect->pWith->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->pSrc)
-    ){
-      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;
-  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);
-  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; iSrc<pTabList->nSrc; iSrc++){
-      if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
-        pTab = pTabList->a[iSrc].pSTab;
-        break;
-      }
-    }
-  }
-  iCol = pExpr->iColumn;
-  if( pTab==0 ) return;
-
-  if( iCol>=0 ){
-    assert( iCol<pTab->nCol );
-    zCol = pTab->aCol[iCol].zCnName;
-  }else if( pTab->iPKey>=0 ){
-    assert( pTab->iPKey<pTab->nCol );
-    zCol = pTab->aCol[pTab->iPKey].zCnName;
-  }else{
-    zCol = "ROWID";
-  }
-  assert( iDb>=0 && iDb<pParse->db->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 initializing
-  ** 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);
-  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; i<pToplevel->nTableLock; i++){
-    p = &pToplevel->aTableLock[i];
-    if( p->iDb==iDb && p->iTab==iTab ){
-      p->isWriteLock = (p->isWriteLock || isWriteLock);
-      return;
-    }
-  }
-
-  assert( pToplevel->nTableLock < 0x7fff0000 );
-  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; i<pParse->nTableLock; 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; i<sizeof(yDbMask); i++) if( m[i] ) return 0;
-  return 1;
-}
-#endif
-
-/*
-** This routine is called after a single SQL statement has been
-** parsed and a VDBE program to execute that statement has been
-** prepared.  This routine puts the finishing touches on the
-** VDBE program and resets the pParse structure for the next
-** parse.
-**
-** Note that if an error occurred, it might be the case that
-** no VDBE code was generated.
-*/
-SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
-  sqlite3 *db;
-  Vdbe *v;
-  int iDb, i;
-
-  assert( pParse->pToplevel==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;
-      int addrRewind;
-      int reg;
-
-      assert( !pParse->isCreate );
-      pReturning = pParse->u1.d.pReturning;
-      if( pReturning->nRetCol ){
-        sqlite3VdbeAddOp0(v, OP_FkCheck);
-        addrRewind =
-           sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur);
-        VdbeCoverage(v);
-        reg = pReturning->iRetReg;
-        for(i=0; i<pReturning->nRetCol; 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);
-
-    /* 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( ++iDb<db->nDb );
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-    for(i=0; i<pParse->nVtabLock; i++){
-      char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
-      sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
-    }
-    pParse->nVtabLock = 0;
-#endif
-
-#ifndef SQLITE_OMIT_SHARED_CACHE
-    /* 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.
-    */
-    if( pParse->nTableLock ) codeTableLocks(pParse);
-#endif
-
-    /* Initialize any AUTOINCREMENT data structures required.
-    */
-    if( pParse->pAinc ) sqlite3AutoincrementBegin(pParse);
-
-    /* Code constant expressions that were factored out of inner loops.
-    */
-    if( pParse->pConstExpr ){
-      ExprList *pEL = pParse->pConstExpr;
-      pParse->okConstFactor = 0;
-      for(i=0; i<pEL->nExpr; i++){
-        assert( pEL->a[i].u.iConstExprReg>0 );
-        sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
-      }
-    }
-
-    if( pParse->bReturning ){
-      Returning *pRet;
-      assert( !pParse->isCreate );
-      pRet = pParse->u1.d.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--;
-}
-
-/*
-** 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( zDatabase ){
-    for(i=0; i<db->nDb; 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; i<db->nDb; 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);
-      }
-#ifndef SQLITE_OMIT_JSON
-      if( pMod==0 && sqlite3_strnicmp(zName, "json", 4)==0 ){
-        pMod = sqlite3JsonVtabRegister(db, zName);
-      }
-#endif
-#ifdef SQLITE_ENABLE_CARRAY
-      if( pMod==0 && sqlite3_stricmp(zName, "carray")==0 ){
-        pMod = sqlite3CarrayRegister(db);
-      }
-#endif
-      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;
-  if( p->fg.fixedSchema ){
-    int iDb = sqlite3SchemaToIndex(pParse->db, p->u4.pSchema);
-    assert( iDb>=0 && iDb<pParse->db->nDb );
-    zDb = pParse->db->aDb[iDb].zDbSName;
-  }else{
-    assert( !p->fg.isSubquery );
-    zDb = p->u4.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; i<db->nDb; 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; i<db->nDb; i++){
-    struct Db *pDb = &db->aDb[i];
-    if( pDb->pBt==0 ){
-      sqlite3DbFree(db, pDb->zDbSName);
-      pDb->zDbSName = 0;
-      continue;
-    }
-    if( j<i ){
-      db->aDb[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( iDb<db->nDb );
-
-  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; i<db->nDb; 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; i<db->nDb; 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->nExpr<pCol->iDflt)
-  ){
-    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( !IsOrdinaryTable(pTab) ) return 0;
-  if( NEVER(pTab->u.tab.pDfltList==0) ) return 0;
-  if( NEVER(pTab->u.tab.pDfltList->nExpr<pCol->iDflt) ) 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 sequence 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; i<pTable->nCol; 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);
-}
-SQLITE_PRIVATE void sqlite3DeleteTableGeneric(sqlite3 *db, void *pTable){
-  sqlite3DeleteTable(db, (Table*)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 && iDb<db->nDb );
-  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 int sqlite3TableColumnToIndex(Index *pIdx, int iCol){
-  int i;
-  i16 iCol16;
-  assert( iCol>=(-1) && iCol<=SQLITE_MAX_COLUMN );
-  assert( pIdx->nColumn<=SQLITE_MAX_COLUMN*2 );
-  iCol16 = iCol;
-  for(i=0; i<pIdx->nColumn; i++){
-    if( iCol16==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( iCol<pTab->nCol );
-  if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
-  for(i=0, n=0; i<iCol; i++){
-    if( (pTab->aCol[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.
-    */
-    assert( pParse->isCreate );
-    reg1 = pParse->u1.cr.regRowid = ++pParse->nMem;
-    reg2 = pParse->u1.cr.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->u1.cr.regRowid.
-    ** The root page of the new table is left in reg pParse->u1.cr.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.cr.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);
-  }else if( db->init.imposterTable ){
-    pTable->tabFlags |= TF_Imposter;
-    if( db->init.imposterTable>=2 ) pTable->tabFlags |= TF_Readonly;
-  }
-
-  /* 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
-
-/*
-** Clean up the data structures associated with the RETURNING clause.
-*/
-static void sqlite3DeleteReturning(sqlite3 *db, void *pArg){
-  Returning *pRet = (Returning*)pArg;
-  Hash *pHash;
-  pHash = &(db->aDb[1].pSchema->trigHash);
-  sqlite3HashInsert(pHash, pRet->zName, 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;
-  }
-  assert( !pParse->isCreate );
-  pParse->u1.d.pReturning = pRet;
-  pRet->pParse = pParse;
-  pRet->pReturnEL = pList;
-  sqlite3ParserAddCleanup(pParse, sqlite3DeleteReturning, pRet);
-  testcase( pParse->earlyCleanup );
-  if( db->mallocFailed ) return;
-  sqlite3_snprintf(sizeof(pRet->zName), pRet->zName,
-                   "sqlite_returning_%p", pParse);
-  pRet->retTrig.zName = pRet->zName;
-  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, pRet->zName)==0
-          || pParse->nErr  || pParse->ifNotExists );
-  if( sqlite3HashInsert(pHash, pRet->zName, &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;
-  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 identifiers
-  ** 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; i<SQLITE_N_STDTYPE; i++){
-       if( sType.n==sqlite3StdTypeLen[i]
-        && sqlite3_strnicmp(sType.z, sqlite3StdType[i], sType.n)==0
-       ){
-         sType.n = 0;
-         eType = i+1;
-         affinity = sqlite3StdTypeAffinity[i];
-         if( affinity<=SQLITE_AFF_TEXT ) szEst = 5;
-         break;
-       }
-    }
-  }
-
-  z = sqlite3DbMallocRaw(db, (i64)sName.n + 1 + (i64)sType.n + (sType.n>0) );
-  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);
-  if( p->nCol && sqlite3ColumnIndex(p, z)>=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 = sqlite3StrIHash(z);
-  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;
-  }
-  if( p->nCol<=0xff ){
-    u8 h = pCol->hName % sizeof(p->aHx);
-    p->aHx[h] = p->nCol;
-  }
-  p->nCol++;
-  p->nNVCol++;
-  assert( pParse->isCreate );
-  pParse->u1.cr.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] ){
-    u8 x = *(u8*)zIn;
-    h = (h<<8) + sqlite3UpperToLower[x];
-    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<SQLITE_AFF_NUMERIC ){
-      if( zChar ){
-        while( zChar[0] ){
-          if( sqlite3Isdigit(zChar[0]) ){
-            /* BLOB(k), VARCHAR(k), CHAR(k) -> 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 default 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; i<nTerm; i++){
-      Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
-      assert( pCExpr!=0 );
-      sqlite3StringToId(pCExpr);
-      if( pCExpr->op==TK_ID ){
-        assert( !ExprHasProperty(pCExpr, EP_IntValue) );
-        iCol = sqlite3ColumnIndex(pTab, pCExpr->u.zToken);
-        if( iCol>=0 ){
-          pCol = &pTab->aCol[iCol];
-          makeColumnPartOfPrimaryKey(pParse, pCol);
-        }
-      }
-    }
-  }
-  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);
-    assert( pParse->isCreate );
-    if( pParse->u1.cr.constraintName.n ){
-      sqlite3ExprListSetName(pParse, pTab->pCheck,
-                             &pParse->u1.cr.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 "<name> PRIMARY KEY COLLATE <type>",
-    ** 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 i64 identLength(const char *z){
-  i64 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 alphanumeric
-** 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, len;
-  i64 n;
-  char *zStmt;
-  char *zSep, *zSep2, *zEnd;
-  Column *pCol;
-  n = 0;
-  for(pCol = p->aCol, i=0; i<p->nCol; 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;
-  }
-  assert( n>14 && n<=0x7fffffff );
-  memcpy(zStmt, "CREATE TABLE ", 13);
-  k = 13;
-  identPut(zStmt, &k, p->zName);
-  zStmt[k++] = '(';
-  for(pCol=p->aCol, i=0; i<p->nCol; 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",
-    };
-    const char *zType;
-
-    len = sqlite3Strlen30(zSep);
-    assert( k+len<n );
-    memcpy(&zStmt[k], zSep, len);
-    k += len;
-    zSep = zSep2;
-    identPut(zStmt, &k, pCol->zCnName);
-    assert( k<n );
-    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) );
-    assert( k+len<n );
-    memcpy(&zStmt[k], zType, len);
-    k += len;
-    assert( k<=n );
-  }
-  len = sqlite3Strlen30(zEnd);
-  assert( k+len<n );
-  memcpy(&zStmt[k], zEnd, len+1);
-  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(Parse *pParse, Index *pIdx, int N){
-  char *zExtra;
-  u64 nByte;
-  sqlite3 *db;
-  if( pIdx->nColumn>=N ) return SQLITE_OK;
-  db = pParse->db;
-  assert( N>0 );
-  assert( N <= SQLITE_MAX_COLUMN*2 /* tag-20250221-1 */ );
-  testcase( N==2*pParse->db->aLimit[SQLITE_LIMIT_COLUMN] );
-  assert( pIdx->isResized==0 );
-  nByte = (sizeof(char*) + sizeof(LogEst) + sizeof(i16) + 1)*(u64)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 = (u16)N;  /* See tag-20250221-1 above for proof of safety */
-  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; i<pIdx->nColumn; i++){
-    i16 x = pIdx->aiColumn[i];
-    assert( x<pIdx->pTable->nCol );
-    wIndex += x<0 ? 1 : aCol[x].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( iCol<MAX(pPk->nColumn,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; i<nKey; i++){
-    assert( pIdx->aiColumn[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( x<BMS-1 ) m |= MASKBIT(x);
-    }
-  }
-  pIdx->colNotIdxed = ~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; i<pTab->nCol; 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.cr.addrCrTab ){
-    assert( v );
-    sqlite3VdbeChangeP3(v, pParse->u1.cr.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; i<pPk->nKeyCol; 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; i<nPk; i++){
-      if( !isDupColumn(pIdx, pIdx->nKeyCol, 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(pParse, pIdx, pIdx->nKeyCol+n) ) return;
-    for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
-      if( !isDupColumn(pIdx, pIdx->nKeyCol, 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://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; i<pTab->nCol; i++){
-    if( !hasColumn(pPk->aiColumn, nPk, i)
-     && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++;
-  }
-  if( resizeIndexObject(pParse, pPk, nPk+nExtra) ) return;
-  for(i=0, j=nPk; i<pTab->nCol; i++){
-    if( !hasColumn(pPk->aiColumn, j, i)
-     && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0
-    ){
-      const char *zColl = sqlite3ColumnColl(&pTab->aCol[i]);
-      assert( j<pPk->nColumn );
-      pPk->aiColumn[j] = i;
-      pPk->azColl[j] = zColl ? zColl : 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){
-  const char *zTail;            /* Pointer to the last "_" in zName */
-  Table *pTab;                  /* Table that zName is a shadow of */
-  char *zCopy;
-  zTail = strrchr(zName, '_');
-  if( zTail==0 ) return 0;
-  zCopy = sqlite3DbStrNDup(db, zName, (int)(zTail-zName));
-  pTab = zCopy ? sqlite3FindTable(db, zCopy, 0) : 0;
-  sqlite3DbFree(db, zCopy);
-  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; ii<p->nCol; 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);
-  assert( iDb>=0 && iDb<=db->nDb );
-
-#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; ii<p->nCol; 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->u1.cr.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 */
-      int iCsr;           /* Write cursor on the new table */
-
-      if( IN_SPECIAL_PARSE ){
-        pParse->rc = SQLITE_ERROR;
-        pParse->nErr++;
-        return;
-      }
-      iCsr = pParse->nTab++;
-      regYield = ++pParse->nMem;
-      regRec = ++pParse->nMem;
-      regRowid = ++pParse->nMem;
-      sqlite3MayAbort(pParse);
-      assert( pParse->isCreate );
-      sqlite3VdbeAddOp3(v, OP_OpenWrite, iCsr, pParse->u1.cr.regRoot, iDb);
-      sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
-      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, iCsr, regRowid);
-      sqlite3VdbeAddOp3(v, OP_Insert, iCsr, regRec, regRowid);
-      sqlite3VdbeGoto(v, addrInsLoop);
-      sqlite3VdbeJumpHere(v, addrInsLoop);
-      sqlite3VdbeAddOp1(v, OP_Close, iCsr);
-    }
-
-    /* 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.
-    */
-    assert( pParse->isCreate );
-    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->u1.cr.regRoot,
-      zStmt,
-      pParse->u1.cr.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);
-
-    /* Test for cycles in generated columns and illegal expressions
-    ** in CHECK constraints and in DEFAULT clauses. */
-    if( p->tabFlags & TF_HasGenerated ){
-      sqlite3VdbeAddOp4(v, OP_SqlExec, 0x0001, 0, 0,
-             sqlite3MPrintf(db, "SELECT*FROM\"%w\".\"%w\"",
-                   db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
-    }
-  }
-
-  /* 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.  The ability can also be toggled
-  ** using sqlite3_config(SQLITE_CONFIG_ROWID_IN_VIEW,...) */
-#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
-  p->tabFlags |= sqlite3Config.mNoVisibleRowid; /* Optional. Allow by default */
-#else
-  p->tabFlags |= TF_NoVisibleRowid;             /* Never allow rowid in view */
-#endif
-
-  sqlite3TwoPartName(pParse, pName1, pName2, &pName);
-  iDb = sqlite3SchemaToIndex(db, p->pSchema);
-  assert( iDb>=0 && iDb<db->nDb );
-  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 non-zero if
-** there are errors.  If an error is seen an error message is left
-** 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 + pParse->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 || iTab<iDestroyed ){
-      iLargest = iTab;
-    }
-    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
-      Pgno iIdx = pIdx->tnum;
-      assert( pIdx->pSchema==pTab->pSchema );
-      if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
-        iLargest = iIdx;
-      }
-    }
-    if( iLargest==0 ){
-      return;
-    }else{
-      int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
-      assert( iDb>=0 && iDb<pParse->db->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 );
-  assert( pName->a[0].fg.fixedSchema==0 );
-  assert( pName->a[0].fg.isSubquery==0 );
-  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].u4.zDatabase);
-      sqlite3ForceNotReadOnly(pParse);
-    }
-    goto exit_drop_table;
-  }
-  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-  assert( iDb>=0 && iDb<db->nDb );
-
-  /* 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 = SZ_FKEY(nCol) + pTo->n + 1;
-  if( pToCol ){
-    for(i=0; i<pToCol->nExpr; 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; i<nCol; i++){
-      int j;
-      for(j=0; j<p->nCol; 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; i<nCol; i++){
-      int n = sqlite3Strlen30(pToCol->a[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://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 */
-  int 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 */
-  i64 nByte;           /* Bytes of space for Index object + arrays */
-
-  assert( nCol <= 2*db->aLimit[SQLITE_LIMIT_COLUMN] );
-  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;
-    assert( nCol>0 );
-    p->nColumn = (u16)nCol;
-    p->nKeyCol = (u16)(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; i<pList->nExpr; 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 initializing 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
-  ){
-    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; i<pList->nExpr; 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; i<pIndex->nKeyCol; 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; j<pPk->nKeyCol; 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; j<pTab->nCol; 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; k<pIdx->nKeyCol; 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 );
-  assert( pName->a[0].fg.fixedSchema==0 );
-  assert( pName->a[0].fg.isSubquery==0 );
-  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
-    goto exit_drop_index;
-  }
-  pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].u4.zDatabase);
-  if( pIndex==0 ){
-    if( !ifExists ){
-      sqlite3ErrorMsg(pParse, "no such index: %S", pName->a);
-    }else{
-      sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].u4.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);
-  assert( iDb>=0 && iDb<db->nDb );
-#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, SZ_IDLIST(1));
-    if( pList==0 ) return 0;
-  }else{
-    IdList *pNew;
-    pNew = sqlite3DbRealloc(db, pList, SZ_IDLIST(pList->nId+1));
-    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;
-  for(i=0; i<pList->nId; 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; i<pList->nId; 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, SZ_SRCLIST(nAlloc));
-    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; i<iStart+nExtra; i++){
-    pSrc->a[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, SZ_SRCLIST(1));
-    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;
-  }
-  assert( pItem->fg.fixedSchema==0 );
-  assert( pItem->fg.isSubquery==0 );
-  if( pDatabase ){
-    pItem->zName = sqlite3NameFromToken(db, pDatabase);
-    pItem->u4.zDatabase = sqlite3NameFromToken(db, pTable);
-  }else{
-    pItem->zName = sqlite3NameFromToken(db, pTable);
-    pItem->u4.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; i<pList->nSrc; i++, pItem++){
-      if( pItem->iCursor>=0 ) continue;
-      pItem->iCursor = pParse->nTab++;
-      if( pItem->fg.isSubquery ){
-        assert( pItem->u4.pSubq!=0 );
-        assert( pItem->u4.pSubq->pSelect!=0 );
-        assert( pItem->u4.pSubq->pSelect->pSrc!=0 );
-        sqlite3SrcListAssignCursors(pParse, pItem->u4.pSubq->pSelect->pSrc);
-      }
-    }
-  }
-}
-
-/*
-** Delete a Subquery object and its substructure.
-*/
-SQLITE_PRIVATE void sqlite3SubqueryDelete(sqlite3 *db, Subquery *pSubq){
-  assert( pSubq!=0 && pSubq->pSelect!=0 );
-  sqlite3SelectDelete(db, pSubq->pSelect);
-  sqlite3DbFree(db, pSubq);
-}
-
-/*
-** Remove a Subquery from a SrcItem.  Return the associated Select object.
-** The returned Select becomes the responsibility of the caller.
-*/
-SQLITE_PRIVATE Select *sqlite3SubqueryDetach(sqlite3 *db, SrcItem *pItem){
-  Select *pSel;
-  assert( pItem!=0 );
-  assert( pItem->fg.isSubquery );
-  pSel = pItem->u4.pSubq->pSelect;
-  sqlite3DbFree(db, pItem->u4.pSubq);
-  pItem->u4.pSubq = 0;
-  pItem->fg.isSubquery = 0;
-  return pSel;
-}
-
-/*
-** 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; i<pList->nSrc; i++, pItem++){
-
-    /* Check invariants on SrcItem */
-    assert( !pItem->fg.isIndexedBy || !pItem->fg.isTabFunc );
-    assert( !pItem->fg.isCte || !pItem->fg.isIndexedBy );
-    assert( !pItem->fg.fixedSchema || !pItem->fg.isSubquery );
-    assert( !pItem->fg.isSubquery || (pItem->u4.pSubq!=0 &&
-                                      pItem->u4.pSubq->pSelect!=0) );
-
-    if( pItem->zName ) sqlite3DbNNFreeNN(db, pItem->zName);
-    if( pItem->zAlias ) sqlite3DbNNFreeNN(db, pItem->zAlias);
-    if( pItem->fg.isSubquery ){
-      sqlite3SubqueryDelete(db, pItem->u4.pSubq);
-    }else if( pItem->fg.fixedSchema==0 && pItem->u4.zDatabase!=0 ){
-      sqlite3DbNNFreeNN(db, pItem->u4.zDatabase);
-    }
-    if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
-    if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
-    sqlite3DeleteTable(db, pItem->pSTab);
-    if( pItem->fg.isUsing ){
-      sqlite3IdListDelete(db, pItem->u3.pUsing);
-    }else if( pItem->u3.pOn ){
-      sqlite3ExprDelete(db, pItem->u3.pOn);
-    }
-  }
-  sqlite3DbNNFreeNN(db, pList);
-}
-
-/*
-** Attach a Subquery object to pItem->uv.pSubq.  Set the
-** pSelect value but leave all the other values initialized
-** to zero.
-**
-** A copy of the Select object is made if dupSelect is true, and the
-** SrcItem takes responsibility for deleting the copy.  If dupSelect is
-** false, ownership of the Select passes to the SrcItem.  Either way,
-** the SrcItem will take responsibility for deleting the Select.
-**
-** When dupSelect is zero, that means the Select might get deleted right
-** away if there is an OOM error.  Beware.
-**
-** Return non-zero on success.  Return zero on an OOM error.
-*/
-SQLITE_PRIVATE int sqlite3SrcItemAttachSubquery(
-  Parse *pParse,     /* Parsing context */
-  SrcItem *pItem,    /* Item to which the subquery is to be attached */
-  Select *pSelect,   /* The subquery SELECT.  Must be non-NULL */
-  int dupSelect      /* If true, attach a copy of pSelect, not pSelect itself.*/
-){
-  Subquery *p;
-  assert( pSelect!=0 );
-  assert( pItem->fg.isSubquery==0 );
-  if( pItem->fg.fixedSchema ){
-    pItem->u4.pSchema = 0;
-    pItem->fg.fixedSchema = 0;
-  }else if( pItem->u4.zDatabase!=0 ){
-    sqlite3DbFree(pParse->db, pItem->u4.zDatabase);
-    pItem->u4.zDatabase = 0;
-  }
-  if( dupSelect ){
-    pSelect = sqlite3SelectDup(pParse->db, pSelect, 0);
-    if( pSelect==0 ) return 0;
-  }
-  p = pItem->u4.pSubq = sqlite3DbMallocRawNN(pParse->db, sizeof(Subquery));
-  if( p==0 ){
-    sqlite3SelectDelete(pParse->db, pSelect);
-    return 0;
-  }
-  pItem->fg.isSubquery = 1;
-  p->pSelect = pSelect;
-  assert( offsetof(Subquery, pSelect)==0 );
-  memset(((char*)p)+sizeof(p->pSelect), 0, sizeof(*p)-sizeof(p->pSelect));
-  return 1;
-}
-
-
-/*
-** 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);
-  }
-  assert( pSubquery==0 || pDatabase==0 );
-  if( pSubquery ){
-    if( sqlite3SrcItemAttachSubquery(pParse, pItem, pSubquery, 0) ){
-      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 );
-  assert( p2 || pParse->nErr );
-  assert( p2==0 || p2->nSrc>=1 );
-  testcase( p1->nSrc==0 );
-  if( p2 ){
-    int nOld = p1->nSrc;
-    SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, nOld);
-    if( pNew==0 ){
-      sqlite3SrcListDelete(pParse->db, p2);
-    }else{
-      p1 = pNew;
-      memcpy(&p1->a[nOld], p2->a, p2->nSrc*sizeof(SrcItem));
-      assert( nOld==1 || (p2->a[0].fg.jointype & JT_LTORJ)==0 );
-      assert( p1->nSrc>=1 );
-      p1->a[0].fg.jointype |= (JT_LTORJ & p2->a[0].fg.jointype);
-      sqlite3DbFree(pParse->db, p2);
-    }
-  }
-  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; i<db->nDb; 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 && iDb<pToplevel->db->nDb );
-  assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
-  assert( iDb<SQLITE_MAX_DB );
-  assert( sqlite3SchemaMutexHeld(pToplevel->db, 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; i<db->nDb; 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; j<pIdx->nKeyCol; 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);
-}
-
-/*
-** Return true if any column of pIndex uses the zColl collation
-*/
-#ifndef SQLITE_OMIT_REINDEX
-static int collationMatch(const char *zColl, Index *pIndex){
-  int i;
-  assert( zColl!=0 );
-  for(i=0; i<pIndex->nColumn; i++){
-    const char *z = pIndex->azColl[i];
-    assert( z!=0 );
-    if( 0==sqlite3StrICmp(z, zColl) ){
-      return 1;
-    }
-  }
-  return 0;
-}
-#endif
-
-/*
-** Generate code for the REINDEX command.
-**
-**        REINDEX                            -- 1
-**        REINDEX  <collation>               -- 2
-**        REINDEX  ?<database>.?<indexname>  -- 3
-**        REINDEX  ?<database>.?<tablename>  -- 4
-**        REINDEX  EXPRESSIONS               -- 5
-**
-** Form 1 causes all indexes in all attached databases to be rebuilt.
-** Form 2 rebuilds all indexes in all databases that use the named
-** collating function.  Forms 3 and 4 rebuild the named index or all
-** indexes associated with the named table, respectively.  Form 5
-** rebuilds all expression indexes in addition to all collations,
-** indexes, or tables named "EXPRESSIONS".
-**
-** If the name is ambiguous such that it matches two or more of
-** forms 2 through 5, then rebuild the union of all matching indexes,
-** taken care to avoid rebuilding the same index more than once.
-*/
-#ifndef SQLITE_OMIT_REINDEX
-SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
-  char *z = 0;                /* Name of a table or index or collation */
-  const char *zDb = 0;        /* Name of the database */
-  int iReDb = -1;             /* The database index number */
-  sqlite3 *db = pParse->db;   /* The database connection */
-  Token *pObjName;            /* Name of the table or index to be reindexed */
-  int bMatch = 0;             /* At least one name match */
-  const char *zColl = 0;      /* Rebuild indexes using this collation */
-  Table *pReTab = 0;          /* Rebuild all indexes of this table */
-  Index *pReIndex = 0;        /* Rebuild this index */
-  int isExprIdx = 0;          /* Rebuild all expression indexes */
-  int bAll = 0;               /* Rebuild all indexes */
-
-  /* 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 ){
-    /* rebuild all indexes */
-    bMatch = 1;
-    bAll = 1;
-  }else if( NEVER(pName2==0) || pName2->z==0 ){
-    assert( pName1->z );
-    z = sqlite3NameFromToken(pParse->db, pName1);
-    if( z==0 ) return;
-  }else{
-    iReDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
-    if( iReDb<0 ) return;
-    z = sqlite3NameFromToken(db, pObjName);
-    if( z==0 ) return;
-    zDb = db->aDb[iReDb].zDbSName;
-  }
-  if( !bAll ){
-    if( zDb==0 && sqlite3StrICmp(z, "expressions")==0 ){
-      isExprIdx = 1;
-      bMatch = 1;
-    }
-    if( zDb==0 && sqlite3FindCollSeq(db, ENC(db), z, 0)!=0 ){
-      zColl = z;
-      bMatch = 1;
-    }
-    if( zColl==0 && (pReTab = sqlite3FindTable(db, z, zDb))!=0 ){
-      bMatch = 1;
-    }
-    if( zColl==0 && (pReIndex = sqlite3FindIndex(db, z, zDb))!=0 ){
-      bMatch = 1;
-    }
-  }
-  if( bMatch ){
-    int iDb;
-    HashElem *k;
-    Table *pTab;
-    Index *pIdx;
-    Db *pDb;
-    for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
-      assert( pDb!=0 );
-      if( iReDb>=0 && iReDb!=iDb ) continue;
-      for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
-        pTab = (Table*)sqliteHashData(k);
-        if( IsVirtual(pTab) ) continue;
-        for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
-          if( bAll
-           || pTab==pReTab
-           || pIdx==pReIndex
-           || (isExprIdx && pIdx->bHasExpr)
-           || (zColl!=0 && collationMatch(zColl,pIdx))
-          ){
-            sqlite3BeginWriteOperation(pParse, 0, iDb);
-            sqlite3RefillIndex(pParse, pIdx, -1);
-          }
-        } /* End loop over indexes of pTab */
-      } /* End loop over tables of iDb */
-    } /* End loop over databases */
-  }else{
-    sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
-  }
-  sqlite3DbFree(db, z);
-  return;
-}
-#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; i<nCol; i++){
-      const char *zColl = pIdx->azColl[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
-       && sqlite3HashFind(&pIdx->pSchema->idxHash, pIdx->zName)
-      ){
-        /* 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.
-        **
-        ** Except, do not do this if the index is not in the schema hash
-        ** table. In this case the index is currently being constructed
-        ** by a CREATE INDEX statement, and retrying will not help.  */
-        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 the 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; i<pWith->nCte; i++){
-      if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
-        sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
-      }
-    }
-  }
-
-  if( pWith ){
-    pNew = sqlite3DbRealloc(db, pWith, SZ_WITH(pWith->nCte+1));
-  }else{
-    pNew = sqlite3DbMallocZero(db, SZ_WITH(1));
-  }
-  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; i<pWith->nCte; i++){
-      cteClear(db, &pWith->a[i]);
-    }
-    sqlite3DbFree(db, pWith);
-  }
-}
-SQLITE_PRIVATE void sqlite3WithDeleteGeneric(sqlite3 *db, void *pWith){
-  sqlite3WithDelete(db, (With*)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>=(-4) && p->nArg!=(-2) );
-  assert( nArg>=(-2) );
-
-  /* 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;
-    /* Special p->nArg values available to built-in functions only:
-    **    -3     1 or more arguments required
-    **    -4     2 or more arguments required
-    */
-    if( p->nArg<(-2) && nArg<(-2-p->nArg) ) 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; i<nDef; i++){
-    FuncDef *pOther;
-    const char *zName = aDef[i].zName;
-    int nName = sqlite3Strlen30(zName);
-    int h = SQLITE_FUNC_HASH(zName[0], nName);
-    assert( aDef[i].funcFlags & SQLITE_FUNC_BUILTIN );
-    pOther = sqlite3FunctionSearch(h, zName);
-    if( pOther ){
-      assert( pOther!=&aDef[i] && pOther->pNext!=&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 && bestScore<FUNC_PERFECT_MATCH &&
-      (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
-    FuncDef *pOther;
-    u8 *z;
-    pBest->zName = (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].spTab        Pointer to the Table object
-**    pSrc->a[0].u2.pIBIndex  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);
-  if( pItem->pSTab ) sqlite3DeleteTable(pParse->db, pItem->pSTab);
-  pItem->pSTab = pTab;
-  pItem->fg.notCte = 1;
-  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){
-  assert( IsVirtual(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 || (pParse->prepFlags & SQLITE_PREPARE_FROM_DDL))
-   && 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);
-    assert( pFrom->a[0].fg.fixedSchema==0 && pFrom->a[0].fg.isSubquery==0 );
-    pFrom->a[0].u4.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 containing 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].pSTab;
-  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);
-    assert( pPk!=0 );
-    assert( pPk->nKeyCol>=1 );
-    if( pPk->nKeyCol==1 ){
-      const char *zName;
-      assert( pPk->aiColumn[0]>=0 && pPk->aiColumn[0]<pTab->nCol );
-      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; i<pPk->nKeyCol; i++){
-        Expr *p;
-        assert( pPk->aiColumn[i]>=0 && pPk->aiColumn[i]<pTab->nCol );
-        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].pSTab = 0;
-  pSelectSrc = sqlite3SrcListDup(db, pSrc, 0);
-  pSrc->a[0].pSTab = 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/UPDATE */
-  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( iDb<db->nDb );
-  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;
-      assert( 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
-            || OptimizationDisabled(db, SQLITE_OnePass) );
-    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; i<nPk; i++){
-        assert( pPk->aiColumn[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; iCol<pTab->nCol; 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<sqlite3VdbeCurrentAddr(v) ){
-      sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
-      VdbeCoverageIf(v, opSeek==OP_NotExists);
-      VdbeCoverageIf(v, opSeek==OP_NotFound);
-      testcase( iIdxNoSeek>=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. */
-  if( pTrigger ){
-    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
-    );
-    sqlite3VdbeChangeP4(v, -1, (const char*)pIdx, P4_INDEX);
-    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; j<nCol; j++){
-    if( pPrior
-     && pPrior->aiColumn[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 <stdlib.h> */
-/* #include <assert.h> */
-#ifndef SQLITE_OMIT_FLOATING_POINT
-/* #include <math.h> */
-#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<argc; i++){
-    if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
-    if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=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<ArraySize(azType) );
-  assert( SQLITE_INTEGER==1 );
-  assert( SQLITE_FLOAT==2 );
-  assert( SQLITE_TEXT==3 );
-  assert( SQLITE_BLOB==4 );
-  assert( SQLITE_NULL==5 );
-  /* EVIDENCE-OF: R-01470-60482 The sqlite3_value_type(V) interface returns
-  ** the 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. */
-  sqlite3_result_text(context, azType[i], -1, SQLITE_STATIC);
-}
-
-/* subtype(X)
-**
-** Return the subtype of X
-*/
-static void subtypeFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  UNUSED_PARAMETER(argc);
-  sqlite3_result_int(context, sqlite3_value_subtype(argv[0]));
-}
-
-/*
-** Implementation of the length() function
-*/
-static void lengthFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  assert( argc==1 );
-  UNUSED_PARAMETER(argc);
-  switch( sqlite3_value_type(argv[0]) ){
-    case SQLITE_BLOB:
-    case SQLITE_INTEGER:
-    case SQLITE_FLOAT: {
-      sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
-      break;
-    }
-    case SQLITE_TEXT: {
-      const unsigned char *z = sqlite3_value_text(argv[0]);
-      const unsigned char *z0;
-      unsigned char c;
-      if( z==0 ) return;
-      z0 = z;
-      while( (c = *z)!=0 ){
-        z++;
-        if( c>=0xc0 ){
-          while( (*z & 0xc0)==0x80 ){ z++; z0++; }
-        }
-      }
-      sqlite3_result_int(context, (int)(z-z0));
-      break;
-    }
-    default: {
-      sqlite3_result_null(context);
-      break;
-    }
-  }
-}
-
-/*
-** Implementation of the octet_length() function
-*/
-static void bytelengthFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  assert( argc==1 );
-  UNUSED_PARAMETER(argc);
-  switch( sqlite3_value_type(argv[0]) ){
-    case SQLITE_BLOB: {
-      sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
-      break;
-    }
-    case SQLITE_INTEGER:
-    case SQLITE_FLOAT: {
-      i64 m = sqlite3_context_db_handle(context)->enc<=SQLITE_UTF8 ? 1 : 2;
-      sqlite3_result_int64(context, sqlite3_value_bytes(argv[0])*m);
-      break;
-    }
-    case SQLITE_TEXT: {
-      if( sqlite3_value_encoding(argv[0])<=SQLITE_UTF8 ){
-        sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
-      }else{
-        sqlite3_result_int(context, sqlite3_value_bytes16(argv[0]));
-      }
-      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;
-
-  assert( argc==3 || argc==2 );
-  p0type = sqlite3_value_type(argv[0]);
-  p1 = sqlite3_value_int64(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);
-      }
-    }
-  }
-  if( argc==3 ){
-    p2 = sqlite3_value_int64(argv[2]);
-    if( p2==0 && sqlite3_value_type(argv[2])==SQLITE_NULL ) return;
-  }else{
-    p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
-  }
-  if( p1==0 ){
-#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. */
-    p1 = 1; /* <rdar://problem/6778339> */
-#endif
-    if( sqlite3_value_type(argv[1])==SQLITE_NULL ) return;
-  }
-  if( p1<0 ){
-    p1 += len;
-    if( p1<0 ){
-      if( p2<0 ){
-        p2 = 0;
-      }else{
-        p2 += p1;
-      }
-      p1 = 0;
-    }
-  }else if( p1>0 ){
-    p1--;
-  }else if( p2>0 ){
-    p2--;
-  }
-  if( p2<0 ){
-    if( p2<-p1 ){
-      p2 = p1;
-    }else{
-      p2 = -p2;
-    }
-    p1 -= p2;
-  }
-  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>=len ){
-      p1 = p2 = 0;
-    }else if( p2>len-p1 ){
-      p2 = len-p1;
-      assert( 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){
-  i64 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_int64(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",(int)n,r);
-    if( zBuf==0 ){
-      sqlite3_result_error_nomem(context);
-      return;
-    }
-    sqlite3AtoF(zBuf, &r);
-    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==(i64)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; i<n; i++){
-        z1[i] = (char)sqlite3Toupper(z2[i]);
-      }
-      sqlite3_result_text(context, z1, n, sqlite3_free);
-    }
-  }
-}
-static void lowerFunc(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; i<n; i++){
-        z1[i] = sqlite3Tolower(z2[i]);
-      }
-      sqlite3_result_text(context, z1, n, sqlite3_free);
-    }
-  }
-}
-
-/*
-** Some functions like COALESCE() and IFNULL() and UNLIKELY() are implemented
-** as VDBE code so that unused argument values do not have to be computed.
-** However, we still need some kind of function implementation for this
-** routines in the function table.  The noopFunc macro provides this.
-** noopFunc will never be called so it doesn't matter what the implementation
-** is.  We might as well use the "version()" function as a substitute.
-*/
-#define noopFunc versionFunc   /* Substitute function - never called */
-
-/*
-** Implementation of random().  Return a random integer.
-*/
-static void randomFunc(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **NotUsed2
-){
-  sqlite_int64 r;
-  UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  sqlite3_randomness(sizeof(r), &r);
-  if( r<0 ){
-    /* We need to prevent a random number of 0x8000000000000000
-    ** (or -9223372036854775808) since when you do abs() of that
-    ** number of you get the same value back again.  To do this
-    ** in a way that is testable, mask the sign bit off of negative
-    ** values, resulting in a positive value.  Then take the
-    ** 2s complement of that positive value.  The end result can
-    ** therefore be no less than -9223372036854775807.
-    */
-    r = -(r & LARGEST_INT64);
-  }
-  sqlite3_result_int64(context, r);
-}
-
-/*
-** Implementation of randomblob(N).  Return a random blob
-** that is N bytes long.
-*/
-static void randomBlob(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  sqlite3_int64 n;
-  unsigned char *p;
-  assert( argc==1 );
-  UNUSED_PARAMETER(argc);
-  n = sqlite3_value_int64(argv[0]);
-  if( n<1 ){
-    n = 1;
-  }
-  p = contextMalloc(context, n);
-  if( p ){
-    sqlite3_randomness(n, p);
-    sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
-  }
-}
-
-/*
-** Implementation of the last_insert_rowid() SQL function.  The return
-** value is the same as the sqlite3_last_insert_rowid() API function.
-*/
-static void last_insert_rowid(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **NotUsed2
-){
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
-  ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface
-  ** function. */
-  sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
-}
-
-/*
-** Implementation of the changes() SQL function.
-**
-** IMP: R-32760-32347 The changes() SQL function is a wrapper
-** around the sqlite3_changes64() C/C++ function and hence follows the
-** same rules for counting changes.
-*/
-static void changes(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **NotUsed2
-){
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  sqlite3_result_int64(context, sqlite3_changes64(db));
-}
-
-/*
-** Implementation of the total_changes() SQL function.  The return value is
-** the same as the sqlite3_total_changes64() API function.
-*/
-static void total_changes(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **NotUsed2
-){
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  /* IMP: R-11217-42568 This function is a wrapper around the
-  ** sqlite3_total_changes64() C/C++ interface. */
-  sqlite3_result_int64(context, sqlite3_total_changes64(db));
-}
-
-/*
-** A structure defining how to do GLOB-style comparisons.
-*/
-struct compareInfo {
-  u8 matchAll;          /* "*" or "%" */
-  u8 matchOne;          /* "?" or "_" */
-  u8 matchSet;          /* "[" or 0 */
-  u8 noCase;            /* true to ignore case differences */
-};
-
-/*
-** For LIKE and GLOB matching on EBCDIC machines, assume that every
-** character is exactly one byte in size.  Also, provide the Utf8Read()
-** macro for fast reading of the next character in the common case where
-** the next character is ASCII.
-*/
-#if defined(SQLITE_EBCDIC)
-# define sqlite3Utf8Read(A)        (*((*A)++))
-# define Utf8Read(A)               (*(A++))
-#else
-# define Utf8Read(A)               (A[0]<0x80?*(A++):sqlite3Utf8Read(&A))
-#endif
-
-static const struct compareInfo globInfo = { '*', '?', '[', 0 };
-/* The correct SQL-92 behavior is for the LIKE operator to ignore
-** case.  Thus  'a' LIKE 'A' would be true. */
-static const struct compareInfo likeInfoNorm = { '%', '_',   0, 1 };
-/* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
-** is case sensitive causing 'a' LIKE 'A' to be false */
-static const struct compareInfo likeInfoAlt = { '%', '_',   0, 0 };
-
-/*
-** Possible error returns from patternMatch()
-*/
-#define SQLITE_MATCH             0
-#define SQLITE_NOMATCH           1
-#define SQLITE_NOWILDCARDMATCH   2
-
-/*
-** Compare two UTF-8 strings for equality where the first string is
-** a GLOB or LIKE expression.  Return values:
-**
-**    SQLITE_MATCH:            Match
-**    SQLITE_NOMATCH:          No match
-**    SQLITE_NOWILDCARDMATCH:  No match in spite of having * or % wildcards.
-**
-** Globbing rules:
-**
-**      '*'       Matches any sequence of zero or more characters.
-**
-**      '?'       Matches exactly one character.
-**
-**     [...]      Matches one character from the enclosed list of
-**                characters.
-**
-**     [^...]     Matches one character not in the enclosed list.
-**
-** With the [...] and [^...] matching, a ']' character can be included
-** in the list by making it the first character after '[' or '^'.  A
-** range of characters can be specified using '-'.  Example:
-** "[a-z]" matches any single lower-case letter.  To match a '-', make
-** it the last character in the list.
-**
-** Like matching rules:
-**
-**      '%'       Matches any sequence of zero or more characters
-**
-***     '_'       Matches any one character
-**
-**      Ec        Where E is the "esc" character and c is any other
-**                character, including '%', '_', and esc, match exactly c.
-**
-** The comments within this routine usually assume glob matching.
-**
-** This routine is usually quick, but can be N**2 in the worst case.
-*/
-static int patternCompare(
-  const u8 *zPattern,              /* The glob pattern */
-  const u8 *zString,               /* The string to compare against the glob */
-  const struct compareInfo *pInfo, /* Information about how to do the compare */
-  u32 matchOther                   /* The escape char (LIKE) or '[' (GLOB) */
-){
-  u32 c, c2;                       /* Next pattern and input string chars */
-  u32 matchOne = pInfo->matchOne;  /* "?" 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 built-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, int bEscape){
-  /* 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: {
-                             /*    ,---  Show infinity as 9.0e+999
-                             **    |
-                             **    | ,--- 17 precision guarantees round-trip
-                             **    v v                                       */
-      sqlite3_str_appendf(pStr, "%!0.17g", sqlite3_value_double(pValue));
-      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<nBlob; i++){
-          zText[(i*2)+2] = hexdigits[(zBlob[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, bEscape ? "%#Q" : "%Q", zArg);
-      break;
-    }
-    default: {
-      assert( sqlite3_value_type(pValue)==SQLITE_NULL );
-      sqlite3_str_append(pStr, "NULL", 4);
-      break;
-    }
-  }
-}
-
-/*
-** Return true if z[] begins with N hexadecimal digits, and write
-** a decoding of those digits into *pVal.  Or return false if any
-** one of the first N characters in z[] is not a hexadecimal digit.
-*/
-static int isNHex(const char *z, int N, u32 *pVal){
-  int i;
-  u32 v = 0;
-  for(i=0; i<N; i++){
-    if( !sqlite3Isxdigit(z[i]) ) return 0;
-    v = (v<<4) + sqlite3HexToInt(z[i]);
-  }
-  *pVal = v;
-  return 1;
-}
-
-/*
-** Implementation of the UNISTR() function.
-**
-** This is intended to be a work-alike of the UNISTR() function in
-** PostgreSQL.  Quoting from the PG documentation (PostgreSQL 17 -
-** scraped on 2025-02-22):
-**
-**    Evaluate escaped Unicode characters in the argument. Unicode
-**    characters can be specified as \XXXX (4 hexadecimal digits),
-**    \+XXXXXX (6 hexadecimal digits), \uXXXX (4 hexadecimal digits),
-**    or \UXXXXXXXX (8 hexadecimal digits). To specify a backslash,
-**    write two backslashes. All other characters are taken literally.
-*/
-static void unistrFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  char *zOut;
-  const char *zIn;
-  int nIn;
-  int i, j, n;
-  u32 v;
-
-  assert( argc==1 );
-  UNUSED_PARAMETER( argc );
-  zIn = (const char*)sqlite3_value_text(argv[0]);
-  if( zIn==0 ) return;
-  nIn = sqlite3_value_bytes(argv[0]);
-  zOut = sqlite3_malloc64(nIn+1);
-  if( zOut==0 ){
-    sqlite3_result_error_nomem(context);
-    return;
-  }
-  i = j = 0;
-  while( i<nIn ){
-    const char *z = strchr(&zIn[i],'\\');
-    if( z==0 ){
-      n = nIn - i;
-      memmove(&zOut[j], &zIn[i], n);
-      j += n;
-      break;
-    }
-    n = z - &zIn[i];
-    if( n>0 ){
-      memmove(&zOut[j], &zIn[i], n);
-      j += n;
-      i += n;
-    }
-    if( zIn[i+1]=='\\' ){
-      i += 2;
-      zOut[j++] = '\\';
-    }else if( sqlite3Isxdigit(zIn[i+1]) ){
-      if( !isNHex(&zIn[i+1], 4, &v) ) goto unistr_error;
-      i += 5;
-      j += sqlite3AppendOneUtf8Character(&zOut[j], v);
-    }else if( zIn[i+1]=='+' ){
-      if( !isNHex(&zIn[i+2], 6, &v) ) goto unistr_error;
-      i += 8;
-      j += sqlite3AppendOneUtf8Character(&zOut[j], v);
-    }else if( zIn[i+1]=='u' ){
-      if( !isNHex(&zIn[i+2], 4, &v) ) goto unistr_error;
-      i += 6;
-      j += sqlite3AppendOneUtf8Character(&zOut[j], v);
-    }else if( zIn[i+1]=='U' ){
-      if( !isNHex(&zIn[i+2], 8, &v) ) goto unistr_error;
-      i += 10;
-      j += sqlite3AppendOneUtf8Character(&zOut[j], v);
-    }else{
-      goto unistr_error;
-    }
-  }
-  zOut[j] = 0;
-  sqlite3_result_text64(context, zOut, j, sqlite3_free, SQLITE_UTF8_ZT);
-  return;
-
-unistr_error:
-  sqlite3_free(zOut);
-  sqlite3_result_error(context, "invalid Unicode escape", -1);
-  return;
-}
-
-
-/*
-** 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.
-**
-** If sqlite3_user_data() is non-zero, then the UNISTR_QUOTE() function is
-** implemented instead.  The difference is that UNISTR_QUOTE() uses the
-** UNISTR() function to escape control characters.
-*/
-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],SQLITE_PTR_TO_INT(sqlite3_user_data(context)));
-  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; i<argc; i++){
-    sqlite3_int64 x;
-    unsigned c;
-    x = sqlite3_value_int64(argv[i]);
-    if( x<0 || x>0x10ffff ) 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);
-    }                                                    \
-  }
-  *zOut = 0;
-  sqlite3_result_text64(context, (char*)z, zOut-z,sqlite3_free,SQLITE_UTF8_ZT);
-}
-
-/*
-** 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<n; i++, pBlob++){
-      unsigned char c = *pBlob;
-      *(z++) = hexdigits[(c>>4)&0xf];
-      *(z++) = hexdigits[c&0xf];
-    }
-    *z = 0;
-    sqlite3_result_text64(context, zHex, (u64)(z-zHex),
-                          sqlite3_free, SQLITE_UTF8_ZT);
-  }
-}
-
-/*
-** 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( z<zEnd ){
-    u32 tst = Utf8Read(z);
-    if( tst==ch ) return 1;
-  }
-  return 0;
-}
-
-/*
-** The unhex() function. This function may be invoked with either one or
-** two arguments. In both cases the first argument is interpreted as text
-** a text value containing a set of pairs of hexadecimal digits which are
-** decoded and returned as a blob.
-**
-** If there is only a single argument, then it must consist only of an
-** even number of hexadecimal digits. Otherwise, return NULL.
-**
-** Or, if there is a second argument, then any character that appears in
-** the second argument is also allowed to appear between pairs of hexadecimal
-** digits in the first argument. If any other character appears in the
-** first argument, or if one of the allowed characters appears between
-** two hexadecimal digits that make up a single byte, NULL is returned.
-**
-** The following expressions are all true:
-**
-**     unhex('ABCD')       IS x'ABCD'
-**     unhex('AB CD')      IS NULL
-**     unhex('AB CD', ' ') IS x'ABCD'
-**     unhex('A BCD', ' ') IS NULL
-*/
-static void unhexFunc(
-  sqlite3_context *pCtx,
-  int argc,
-  sqlite3_value **argv
-){
-  const u8 *zPass = (const u8*)"";
-  int nPass = 0;
-  const u8 *zHex = sqlite3_value_text(argv[0]);
-  int nHex = sqlite3_value_bytes(argv[0]);
-#ifdef SQLITE_DEBUG
-  const u8 *zEnd = zHex ? &zHex[nHex] : 0;
-#endif
-  u8 *pBlob = 0;
-  u8 *p = 0;
-
-  assert( argc==1 || argc==2 );
-  if( argc==2 ){
-    zPass = sqlite3_value_text(argv[1]);
-    nPass = sqlite3_value_bytes(argv[1]);
-  }
-  if( !zHex || !zPass ) return;
-
-  p = pBlob = contextMalloc(pCtx, (nHex/2)+1);
-  if( pBlob ){
-    u8 c;                         /* Most significant digit of next byte */
-    u8 d;                         /* Least significant digit of next byte */
-
-    while( (c = *zHex)!=0x00 ){
-      while( !sqlite3Isxdigit(c) ){
-        u32 ch = Utf8Read(zHex);
-        assert( zHex<=zEnd );
-        if( !strContainsChar(zPass, nPass, ch) ) goto unhex_null;
-        c = *zHex;
-        if( c==0x00 ) goto unhex_done;
-      }
-      zHex++;
-      assert( *zEnd==0x00 );
-      assert( zHex<=zEnd );
-      d = *(zHex++);
-      if( !sqlite3Isxdigit(d) ) goto unhex_null;
-      *(p++) = (sqlite3HexToInt(c)<<4) | sqlite3HexToInt(d);
-    }
-  }
-
- unhex_done:
-  sqlite3_result_blob(pCtx, pBlob, (p - pBlob), sqlite3_free);
-  return;
-
- unhex_null:
-  sqlite3_free(pBlob);
-  return;
-}
-
-
-/*
-** The zeroblob(N) function returns a zero-filled blob of size N bytes.
-*/
-static void zeroblobFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  i64 n;
-  int rc;
-  assert( argc==1 );
-  UNUSED_PARAMETER(argc);
-  n = sqlite3_value_int64(argv[0]);
-  if( n<0 ) n = 0;
-  rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
-  if( rc ){
-    sqlite3_result_error_code(context, rc);
-  }
-}
-
-/*
-** The replace() function.  Three arguments are all strings: call
-** them A, B, and C. The result is also a string which is derived
-** from A by replacing every occurrence of B with C.  The match
-** must be exact.  Collating sequences are not used.
-*/
-static void replaceFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  const unsigned char *zStr;        /* The input string A */
-  const unsigned char *zPattern;    /* The pattern string B */
-  const unsigned char *zRep;        /* The replacement string C */
-  unsigned char *zOut;              /* The output */
-  int nStr;                /* Size of zStr */
-  int nPattern;            /* Size of zPattern */
-  int nRep;                /* Size of zRep */
-  i64 nOut;                /* Maximum size of zOut */
-  int loopLimit;           /* Last zStr[] that might match zPattern[] */
-  int i, j;                /* Loop counters */
-  unsigned cntExpand;      /* Number zOut expansions */
-  sqlite3 *db = sqlite3_context_db_handle(context);
-
-  assert( argc==3 );
-  UNUSED_PARAMETER(argc);
-  zStr = sqlite3_value_text(argv[0]);
-  if( zStr==0 ) return;
-  nStr = sqlite3_value_bytes(argv[0]);
-  assert( zStr==sqlite3_value_text(argv[0]) );  /* No encoding change */
-  zPattern = sqlite3_value_text(argv[1]);
-  if( zPattern==0 ){
-    assert( sqlite3_value_type(argv[1])==SQLITE_NULL
-            || sqlite3_context_db_handle(context)->mallocFailed );
-    return;
-  }
-  if( zPattern[0]==0 ){
-    assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
-    sqlite3_result_text(context, (const char*)zStr, nStr, SQLITE_TRANSIENT);
-    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( nOut<SQLITE_MAX_LENGTH );
-  zOut = contextMalloc(context, nOut);
-  if( zOut==0 ){
-    return;
-  }
-  loopLimit = nStr - nPattern;
-  cntExpand = 0;
-  for(i=j=0; i<=loopLimit; i++){
-    if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
-      zOut[j++] = zStr[i];
-    }else{
-      if( nRep>nPattern ){
-        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; i++){
-          len = aLen[i];
-          if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
-        }
-        if( i>=nChar ) break;
-        zIn += len;
-        nIn -= len;
-      }
-    }
-    if( flags & 2 ){
-      while( nIn>0 ){
-        unsigned int len = 0;
-        for(i=0; i<nChar; i++){
-          len = aLen[i];
-          if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
-        }
-        if( i>=nChar ) break;
-        nIn -= len;
-      }
-    }
-    if( zCharSet ){
-      sqlite3_free(azChar);
-    }
-  }
-  sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
-}
-
-/* The core implementation of the CONCAT(...) and CONCAT_WS(SEP,...)
-** functions.
-**
-** Return a string value that is the concatenation of all non-null
-** entries in argv[].  Use zSep as the separator.
-*/
-static void concatFuncCore(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv,
-  int nSep,
-  const char *zSep
-){
-  i64 j, n = 0;
-  int i;
-  int bNotNull = 0;   /* True after at least NOT NULL argument seen */
-  char *z;
-  for(i=0; i<argc; i++){
-    n += sqlite3_value_bytes(argv[i]);
-  }
-  n += (argc-1)*(i64)nSep;
-  z = sqlite3_malloc64(n+1);
-  if( z==0 ){
-    sqlite3_result_error_nomem(context);
-    return;
-  }
-  j = 0;
-  for(i=0; i<argc; i++){
-    if( sqlite3_value_type(argv[i])!=SQLITE_NULL ){
-      int k = sqlite3_value_bytes(argv[i]);
-      const char *v = (const char*)sqlite3_value_text(argv[i]);
-      if( v!=0 ){
-        if( bNotNull && nSep>0 ){
-          memcpy(&z[j], zSep, nSep);
-          j += nSep;
-        }
-        memcpy(&z[j], v, k);
-        j += k;
-        bNotNull = 1;
-      }
-    }
-  }
-  z[j] = 0;
-  assert( j<=n );
-  sqlite3_result_text64(context, z, j, sqlite3_free, SQLITE_UTF8_ZT);
-}
-
-/*
-** The CONCAT(...) function.  Generate a string result that is the
-** concatentation of all non-null arguments.
-*/
-static void concatFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  concatFuncCore(context, argc, argv, 0, "");
-}
-
-/*
-** The CONCAT_WS(separator, ...) function.
-**
-** Generate a string that is the concatenation of 2nd through the Nth
-** argument.  Use the first argument (which must be non-NULL) as the
-** separator.
-*/
-static void concatwsFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  int nSep = sqlite3_value_bytes(argv[0]);
-  const char *zSep = (const char*)sqlite3_value_text(argv[0]);
-  if( zSep==0 ) return;
-  concatFuncCore(context, argc-1, argv+1, nSep, zSep);
-}
-
-
-#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;      /* Running sum as as a double */
-  double rErr;      /* Error term for Kahan-Babushka-Neumaier summation */
-  i64 iSum;         /* Running sum as a signed integer */
-  i64 cnt;          /* Number of elements summed */
-  u8 approx;        /* True if any non-integer value was input to the sum */
-  u8 ovrfl;         /* Integer overflow seen */
-};
-
-/*
-** Do one step of the Kahan-Babushka-Neumaier summation.
-**
-** https://en.wikipedia.org/wiki/Kahan_summation_algorithm
-**
-** Variables are marked "volatile" to defeat c89 x86 floating point
-** optimizations can mess up this algorithm.
-*/
-static void kahanBabuskaNeumaierStep(
-  volatile SumCtx *pSum,
-  volatile double r
-){
-  volatile double s = pSum->rSum;
-  volatile double t = s + r;
-  if( fabs(s) > fabs(r) ){
-    pSum->rErr += (s - t) + r;
-  }else{
-    pSum->rErr += (r - t) + s;
-  }
-  pSum->rSum = t;
-}
-
-/*
-** Add a (possibly large) integer to the running sum.
-*/
-static void kahanBabuskaNeumaierStepInt64(volatile SumCtx *pSum, i64 iVal){
-  if( iVal<=-4503599627370496LL || iVal>=+4503599627370496LL ){
-    i64 iBig, iSm;
-    iSm = iVal % 16384;
-    iBig = iVal - iSm;
-    kahanBabuskaNeumaierStep(pSum, iBig);
-    kahanBabuskaNeumaierStep(pSum, iSm);
-  }else{
-    kahanBabuskaNeumaierStep(pSum, (double)iVal);
-  }
-}
-
-/*
-** Initialize the Kahan-Babaska-Neumaier sum from a 64-bit integer
-*/
-static void kahanBabuskaNeumaierInit(
-  volatile SumCtx *p,
-  i64 iVal
-){
-  if( iVal<=-4503599627370496LL || iVal>=+4503599627370496LL ){
-    i64 iSm = iVal % 16384;
-    p->rSum = (double)(iVal - iSm);
-    p->rErr = (double)iSm;
-  }else{
-    p->rSum = (double)iVal;
-    p->rErr = 0.0;
-  }
-}
-
-/*
-** 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 throw 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( p->approx==0 ){
-      if( type!=SQLITE_INTEGER ){
-        kahanBabuskaNeumaierInit(p, p->iSum);
-        p->approx = 1;
-        kahanBabuskaNeumaierStep(p, sqlite3_value_double(argv[0]));
-      }else{
-        i64 x = p->iSum;
-        if( sqlite3AddInt64(&x, sqlite3_value_int64(argv[0]))==0 ){
-          p->iSum = x;
-        }else{
-          p->ovrfl = 1;
-          kahanBabuskaNeumaierInit(p, p->iSum);
-          p->approx = 1;
-          kahanBabuskaNeumaierStepInt64(p, sqlite3_value_int64(argv[0]));
-        }
-      }
-    }else{
-      if( type==SQLITE_INTEGER ){
-        kahanBabuskaNeumaierStepInt64(p, sqlite3_value_int64(argv[0]));
-      }else{
-        p->ovrfl = 0;
-        kahanBabuskaNeumaierStep(p, sqlite3_value_double(argv[0]));
-      }
-    }
-  }
-}
-#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--;
-    if( !p->approx ){
-      if( sqlite3SubInt64(&p->iSum, sqlite3_value_int64(argv[0])) ){
-        p->ovrfl = 1;
-        p->approx = 1;
-      }
-    }else if( type==SQLITE_INTEGER ){
-      i64 iVal = sqlite3_value_int64(argv[0]);
-      if( iVal!=SMALLEST_INT64 ){
-        kahanBabuskaNeumaierStepInt64(p, -iVal);
-      }else{
-        kahanBabuskaNeumaierStepInt64(p, LARGEST_INT64);
-        kahanBabuskaNeumaierStepInt64(p, 1);
-      }
-    }else{
-      kahanBabuskaNeumaierStep(p, -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->approx ){
-      if( p->ovrfl ){
-        sqlite3_result_error(context,"integer overflow",-1);
-      }else if( !sqlite3IsOverflow(p->rErr) ){
-        sqlite3_result_double(context, p->rSum+p->rErr);
-      }else{
-        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 ){
-    double r;
-    if( p->approx ){
-      r = p->rSum;
-      if( !sqlite3IsOverflow(p->rErr) ) r += p->rErr;
-    }else{
-      r = (double)(p->iSum);
-    }
-    sqlite3_result_double(context, r/(double)p->cnt);
-  }
-}
-static void totalFinalize(sqlite3_context *context){
-  SumCtx *p;
-  double r = 0.0;
-  p = sqlite3_aggregate_context(context, 0);
-  if( p ){
-    if( p->approx ){
-      r = p->rSum;
-      if( !sqlite3IsOverflow(p->rErr) ) r += p->rErr;
-    }else{
-      r = (double)(p->iSum);
-    }
-  }
-  sqlite3_result_double(context, r);
-}
-
-/*
-** 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?)
-** string_agg(EXPR, SEPARATOR)
-**
-** Content is accumulated in GroupConcatCtx.str with the SEPARATOR
-** coming before the EXPR value, except for the first entry which
-** omits the SEPARATOR.
-**
-** It is tragic that the SEPARATOR goes before the EXPR string.  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( i<nA ) pnsl[i++] = pGCC->nFirstSepLength;
-          }
-        }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 first to initialize it */
-  if( ALWAYS(pGCC) ){
-    int nVS;  /* Number of characters to remove */
-    /* 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 if( pGCC->nAccum>0 && pAccum->nChar==0 ){
-      sqlite3_result_text(context, "", 1, SQLITE_STATIC);
-    }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);
-  }
-}
-
-/*
-** 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){
-  FuncDef *pDef;
-  struct compareInfo *pInfo;
-  int flags;
-  int nArg;
-  if( caseSensitive ){
-    pInfo = (struct compareInfo*)&likeInfoAlt;
-    flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE;
-  }else{
-    pInfo = (struct compareInfo*)&likeInfoNorm;
-    flags = SQLITE_FUNC_LIKE;
-  }
-  for(nArg=2; nArg<=3; nArg++){
-    sqlite3CreateFunc(db, "like", nArg, SQLITE_UTF8, pInfo, likeFunc,
-                      0, 0, 0, 0, 0);
-    pDef = sqlite3FindFunction(db, "like", nArg, SQLITE_UTF8, 0);
-    assert( pDef!=0 ); /* The sqlite3CreateFunc() call above cannot fail
-                       ** because the "like" SQL-function already exists */
-    pDef->funcFlags |= flags;
-    pDef->funcFlags &= ~SQLITE_FUNC_UNSAFE;
-  }
-}
-
-/*
-** 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);
-}
-
-#if defined(SQLITE_ENABLE_PERCENTILE)
-/***********************************************************************
-** This section implements the percentile(Y,P) SQL function and similar.
-** Requirements:
-**
-**   (1)  The percentile(Y,P) function is an aggregate function taking
-**        exactly two arguments.
-**
-**   (2)  If the P argument to percentile(Y,P) is not the same for every
-**        row in the aggregate then an error is thrown.  The word "same"
-**        in the previous sentence means that the value differ by less
-**        than 0.001.
-**
-**   (3)  If the P argument to percentile(Y,P) evaluates to anything other
-**        than a number in the range of 0.0 to 100.0 inclusive then an
-**        error is thrown.
-**
-**   (4)  If any Y argument to percentile(Y,P) evaluates to a value that
-**        is not NULL and is not numeric then an error is thrown.
-**
-**   (5)  If any Y argument to percentile(Y,P) evaluates to plus or minus
-**        infinity then an error is thrown.  (SQLite always interprets NaN
-**        values as NULL.)
-**
-**   (6)  Both Y and P in percentile(Y,P) can be arbitrary expressions,
-**        including CASE WHEN expressions.
-**
-**   (7)  The percentile(Y,P) aggregate is able to handle inputs of at least
-**        one million (1,000,000) rows.
-**
-**   (8)  If there are no non-NULL values for Y, then percentile(Y,P)
-**        returns NULL.
-**
-**   (9)  If there is exactly one non-NULL value for Y, the percentile(Y,P)
-**        returns the one Y value.
-**
-**  (10)  If there N non-NULL values of Y where N is two or more and
-**        the Y values are ordered from least to greatest and a graph is
-**        drawn from 0 to N-1 such that the height of the graph at J is
-**        the J-th Y value and such that straight lines are drawn between
-**        adjacent Y values, then the percentile(Y,P) function returns
-**        the height of the graph at P*(N-1)/100.
-**
-**  (11)  The percentile(Y,P) function always returns either a floating
-**        point number or NULL.
-**
-**  (12)  The percentile(Y,P) is implemented as a single C99 source-code
-**        file that compiles into a shared-library or DLL that can be loaded
-**        into SQLite using the sqlite3_load_extension() interface.
-**
-**  (13)  A separate median(Y) function is the equivalent percentile(Y,50).
-**
-**  (14)  A separate percentile_cont(Y,P) function is equivalent to
-**        percentile(Y,P/100.0).  In other words, the fraction value in
-**        the second argument is in the range of 0 to 1 instead of 0 to 100.
-**
-**  (15)  A separate percentile_disc(Y,P) function is like
-**        percentile_cont(Y,P) except that instead of returning the weighted
-**        average of the nearest two input values, it returns the next lower
-**        value.  So the percentile_disc(Y,P) will always return a value
-**        that was one of the inputs.
-**
-**  (16)  All of median(), percentile(Y,P), percentile_cont(Y,P) and
-**        percentile_disc(Y,P) can be used as window functions.
-**
-** Differences from standard SQL:
-**
-**  *  The percentile_cont(X,P) function is equivalent to the following in
-**     standard SQL:
-**
-**         (percentile_cont(P) WITHIN GROUP (ORDER BY X))
-**
-**     The SQLite syntax is much more compact.  The standard SQL syntax
-**     is also supported if SQLite is compiled with the
-**     -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES option.
-**
-**  *  No median(X) function exists in the SQL standard.  App developers
-**     are expected to write "percentile_cont(0.5)WITHIN GROUP(ORDER BY X)".
-**
-**  *  No percentile(Y,P) function exists in the SQL standard.  Instead of
-**     percential(Y,P), developers must write this:
-**     "percentile_cont(P/100.0) WITHIN GROUP (ORDER BY Y)".  Note that
-**     the fraction parameter to percentile() goes from 0 to 100 whereas
-**     the fraction parameter in SQL standard percentile_cont() goes from
-**     0 to 1.
-**
-** Implementation notes as of 2024-08-31:
-**
-**  *  The regular aggregate-function versions of these routines work
-**     by accumulating all values in an array of doubles, then sorting
-**     that array using quicksort before computing the answer. Thus
-**     the runtime is O(NlogN) where N is the number of rows of input.
-**
-**  *  For the window-function versions of these routines, the array of
-**     inputs is sorted as soon as the first value is computed.  Thereafter,
-**     the array is kept in sorted order using an insert-sort.  This
-**     results in O(N*K) performance where K is the size of the window.
-**     One can imagine alternative implementations that give O(N*logN*logK)
-**     performance, but they require more complex logic and data structures.
-**     The developers have elected to keep the asymptotically slower
-**     algorithm for now, for simplicity, under the theory that window
-**     functions are seldom used and when they are, the window size K is
-**     often small.  The developers might revisit that decision later,
-**     should the need arise.
-*/
-
-/* The following object is the group context for a single percentile()
-** aggregate.  Remember all input Y values until the very end.
-** Those values are accumulated in the Percentile.a[] array.
-*/
-typedef struct Percentile Percentile;
-struct Percentile {
-  u64 nAlloc;          /* Number of slots allocated for a[] */
-  u64 nUsed;           /* Number of slots actually used in a[] */
-  char bSorted;        /* True if a[] is already in sorted order */
-  char bKeepSorted;    /* True if advantageous to keep a[] sorted */
-  char bPctValid;      /* True if rPct is valid */
-  double rPct;         /* Fraction.  0.0 to 1.0 */
-  double *a;           /* Array of Y values */
-};
-
-/*
-** Return TRUE if the input floating-point number is an infinity.
-*/
-static int percentIsInfinity(double r){
-  sqlite3_uint64 u;
-  assert( sizeof(u)==sizeof(r) );
-  memcpy(&u, &r, sizeof(u));
-  return ((u>>52)&0x7ff)==0x7ff;
-}
-
-/*
-** Return TRUE if two doubles differ by 0.001 or less.
-*/
-static int percentSameValue(double a, double b){
-  a -= b;
-  return a>=-0.001 && a<=0.001;
-}
-
-/*
-** Search p (which must have p->bSorted) looking for an entry with
-** value y.  Return the index of that entry.
-**
-** If bExact is true, return -1 if the entry is not found.
-**
-** If bExact is false, return the index at which a new entry with
-** value y should be insert in order to keep the values in sorted
-** order.  The smallest return value in this case will be 0, and
-** the largest return value will be p->nUsed.
-*/
-static i64 percentBinarySearch(Percentile *p, double y, int bExact){
-  i64 iFirst = 0;                   /* First element of search range */
-  i64 iLast = (i64)p->nUsed - 1;    /* Last element of search range */
-  while( iLast>=iFirst ){
-    i64 iMid = (iFirst+iLast)/2;
-    double x = p->a[iMid];
-    if( x<y ){
-      iFirst = iMid + 1;
-    }else if( x>y ){
-      iLast = iMid - 1;
-    }else{
-      return iMid;
-    }
-  }
-  if( bExact ) return -1;
-  return iFirst;
-}
-
-/*
-** Generate an error for a percentile function.
-**
-** The error format string must have exactly one occurrence of "%%s()"
-** (with two '%' characters).  That substring will be replaced by the name
-** of the function.
-*/
-static void percentError(sqlite3_context *pCtx, const char *zFormat, ...){
-  char *zMsg1;
-  char *zMsg2;
-  va_list ap;
-
-  va_start(ap, zFormat);
-  zMsg1 = sqlite3_vmprintf(zFormat, ap);
-  va_end(ap);
-  zMsg2 = zMsg1 ? sqlite3_mprintf(zMsg1, sqlite3VdbeFuncName(pCtx)) : 0;
-  sqlite3_result_error(pCtx, zMsg2, -1);
-  sqlite3_free(zMsg1);
-  sqlite3_free(zMsg2);
-}
-
-/*
-** The "step" function for percentile(Y,P) is called once for each
-** input row.
-*/
-static void percentStep(sqlite3_context *pCtx, int argc, sqlite3_value **argv){
-  Percentile *p;
-  double rPct;
-  int eType;
-  double y;
-  assert( argc==2 || argc==1 );
-
-  if( argc==1 ){
-    /* Requirement 13:  median(Y) is the same as percentile(Y,50). */
-    rPct = 0.5;
-  }else{
-    /* P must be a number between 0 and 100 for percentile() or between
-    ** 0.0 and 1.0 for percentile_cont() and percentile_disc().
-    **
-    ** The user-data is an integer which is 10 times the upper bound.
-    */
-    double mxFrac = (SQLITE_PTR_TO_INT(sqlite3_user_data(pCtx))&2)? 100.0 : 1.0;
-    eType = sqlite3_value_numeric_type(argv[1]);
-    rPct = sqlite3_value_double(argv[1])/mxFrac;
-    if( (eType!=SQLITE_INTEGER && eType!=SQLITE_FLOAT)
-     || rPct<0.0 || rPct>1.0
-    ){
-      percentError(pCtx, "the fraction argument to %%s()"
-                        " is not between 0.0 and %.1f",
-                        (double)mxFrac);
-      return;
-    }
-  }
-
-  /* Allocate the session context. */
-  p = (Percentile*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p==0 ) return;
-
-  /* Remember the P value.  Throw an error if the P value is different
-  ** from any prior row, per Requirement (2). */
-  if( !p->bPctValid ){
-    p->rPct = rPct;
-    p->bPctValid = 1;
-  }else if( !percentSameValue(p->rPct,rPct) ){
-    percentError(pCtx, "the fraction argument to %%s()"
-                      " is not the same for all input rows");
-    return;
-  }
-
-  /* Ignore rows for which Y is NULL */
-  eType = sqlite3_value_type(argv[0]);
-  if( eType==SQLITE_NULL ) return;
-
-  /* If not NULL, then Y must be numeric.  Otherwise throw an error.
-  ** Requirement 4 */
-  if( eType!=SQLITE_INTEGER && eType!=SQLITE_FLOAT ){
-    percentError(pCtx, "input to %%s() is not numeric");
-    return;
-  }
-
-  /* Throw an error if the Y value is infinity or NaN */
-  y = sqlite3_value_double(argv[0]);
-  if( percentIsInfinity(y) ){
-    percentError(pCtx, "Inf input to %%s()");
-    return;
-  }
-
-  /* Allocate and store the Y */
-  if( p->nUsed>=p->nAlloc ){
-    u64 n = p->nAlloc*2 + 250;
-    double *a = sqlite3_realloc64(p->a, sizeof(double)*n);
-    if( a==0 ){
-      sqlite3_free(p->a);
-      memset(p, 0, sizeof(*p));
-      sqlite3_result_error_nomem(pCtx);
-      return;
-    }
-    p->nAlloc = n;
-    p->a = a;
-  }
-  if( p->nUsed==0 ){
-    p->a[p->nUsed++] = y;
-    p->bSorted = 1;
-  }else if( !p->bSorted || y>=p->a[p->nUsed-1] ){
-    p->a[p->nUsed++] = y;
-  }else if( p->bKeepSorted ){
-    i64 i;
-    i = percentBinarySearch(p, y, 0);
-    if( i<(int)p->nUsed ){
-      memmove(&p->a[i+1], &p->a[i], (p->nUsed-i)*sizeof(p->a[0]));
-    }
-    p->a[i] = y;
-    p->nUsed++;
-  }else{
-    p->a[p->nUsed++] = y;
-    p->bSorted = 0;
-  }
-}
-
-/*
-** Interchange two doubles.
-*/
-#define SWAP_DOUBLE(X,Y)  {double ttt=(X);(X)=(Y);(Y)=ttt;}
-
-/*
-** Sort an array of doubles.
-**
-** Algorithm: quicksort
-**
-** This is implemented separately rather than using the qsort() routine
-** from the standard library because:
-**
-**    (1)  To avoid a dependency on qsort()
-**    (2)  To avoid the function call to the comparison routine for each
-**         comparison.
-*/
-static void percentSort(double *a, unsigned int n){
-  int iLt;  /* Entries before a[iLt] are less than rPivot */
-  int iGt;  /* Entries at or after a[iGt] are greater than rPivot */
-  int i;         /* Loop counter */
-  double rPivot; /* The pivot value */
-
-  assert( n>=2 );
-  if( a[0]>a[n-1] ){
-    SWAP_DOUBLE(a[0],a[n-1])
-  }
-  if( n==2 ) return;
-  iGt = n-1;
-  i = n/2;
-  if( a[0]>a[i] ){
-    SWAP_DOUBLE(a[0],a[i])
-  }else if( a[i]>a[iGt] ){
-    SWAP_DOUBLE(a[i],a[iGt])
-  }
-  if( n==3 ) return;
-  rPivot = a[i];
-  iLt = i = 1;
-  do{
-    if( a[i]<rPivot ){
-      if( i>iLt ) SWAP_DOUBLE(a[i],a[iLt])
-      iLt++;
-      i++;
-    }else if( a[i]>rPivot ){
-      do{
-        iGt--;
-      }while( iGt>i && a[iGt]>rPivot );
-      SWAP_DOUBLE(a[i],a[iGt])
-    }else{
-      i++;
-    }
-  }while( i<iGt );
-  if( iLt>=2 ) percentSort(a, iLt);
-  if( n-iGt>=2 ) percentSort(a+iGt, n-iGt);
-
-/* Uncomment for testing */
-#if 0
-  for(i=0; i<n-1; i++){
-    assert( a[i]<=a[i+1] );
-  }
-#endif
-}
-
-
-/*
-** The "inverse" function for percentile(Y,P) is called to remove a
-** row that was previously inserted by "step".
-*/
-static void percentInverse(sqlite3_context *pCtx,int argc,sqlite3_value **argv){
-  Percentile *p;
-  int eType;
-  double y;
-  i64 i;
-  assert( argc==2 || argc==1 );
-
-  /* Allocate the session context. */
-  p = (Percentile*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  assert( p!=0 );
-
-  /* Ignore rows for which Y is NULL */
-  eType = sqlite3_value_type(argv[0]);
-  if( eType==SQLITE_NULL ) return;
-
-  /* If not NULL, then Y must be numeric.  Otherwise throw an error.
-  ** Requirement 4 */
-  if( eType!=SQLITE_INTEGER && eType!=SQLITE_FLOAT ){
-    return;
-  }
-
-  /* Ignore the Y value if it is infinity or NaN */
-  y = sqlite3_value_double(argv[0]);
-  if( percentIsInfinity(y) ){
-    return;
-  }
-  if( p->bSorted==0 ){
-    assert( p->nUsed>1 );
-    percentSort(p->a, p->nUsed);
-    p->bSorted = 1;
-  }
-  p->bKeepSorted = 1;
-
-  /* Find and remove the row */
-  i = percentBinarySearch(p, y, 1);
-  if( i>=0 ){
-    p->nUsed--;
-    if( i<(int)p->nUsed ){
-      memmove(&p->a[i], &p->a[i+1], (p->nUsed - i)*sizeof(p->a[0]));
-    }
-  }
-}
-
-/*
-** Compute the final output of percentile().  Clean up all allocated
-** memory if and only if bIsFinal is true.
-*/
-static void percentCompute(sqlite3_context *pCtx, int bIsFinal){
-  Percentile *p;
-  int settings = SQLITE_PTR_TO_INT(sqlite3_user_data(pCtx))&1; /* Discrete? */
-  unsigned i1, i2;
-  double v1, v2;
-  double ix, vx;
-  p = (Percentile*)sqlite3_aggregate_context(pCtx, 0);
-  if( p==0 ) return;
-  if( p->a==0 ) return;
-  if( p->nUsed ){
-    if( p->bSorted==0 ){
-      assert( p->nUsed>1 );
-      percentSort(p->a, p->nUsed);
-      p->bSorted = 1;
-    }
-    ix = p->rPct*(p->nUsed-1);
-    i1 = (unsigned)ix;
-    if( settings & 1 ){
-      vx = p->a[i1];
-    }else{
-      i2 = ix==(double)i1 || i1==p->nUsed-1 ? i1 : i1+1;
-      v1 = p->a[i1];
-      v2 = p->a[i2];
-      vx = v1 + (v2-v1)*(ix-i1);
-    }
-    sqlite3_result_double(pCtx, vx);
-  }
-  if( bIsFinal ){
-    sqlite3_free(p->a);
-    memset(p, 0, sizeof(*p));
-  }else{
-    p->bKeepSorted = 1;
-  }
-}
-static void percentFinal(sqlite3_context *pCtx){
-  percentCompute(pCtx, 1);
-}
-static void percentValue(sqlite3_context *pCtx){
-  percentCompute(pCtx, 0);
-}
-/****** End of percentile family of functions ******/
-#endif /* SQLITE_ENABLE_PERCENTILE */
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_FILESTAT)
-/*
-** Implementation of sqlite_filestat(SCHEMA).
-**
-** Return JSON text that describes low-level debug/diagnostic information
-** about the sqlite3_file object associated with SCHEMA.
-*/
-static void filestatFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  const char *zDbName;
-  sqlite3_str *pStr;
-  Btree *pBtree;
-
-  zDbName = (const char*)sqlite3_value_text(argv[0]);
-  pBtree = sqlite3DbNameToBtree(db, zDbName);
-  if( pBtree ){
-    Pager *pPager;
-    sqlite3_file *fd;
-    int rc;
-    sqlite3BtreeEnter(pBtree);
-    pPager = sqlite3BtreePager(pBtree);
-    assert( pPager!=0 );
-    fd = sqlite3PagerFile(pPager);
-    pStr = sqlite3_str_new(db);
-    if( pStr==0 ){
-      sqlite3_result_error_nomem(context);
-    }else{
-      sqlite3_str_append(pStr, "{\"db\":", 6);
-      rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_FILESTAT, pStr);
-      if( rc ) sqlite3_str_append(pStr, "null", 4);
-      fd = sqlite3PagerJrnlFile(pPager);
-      if( fd && fd->pMethods!=0 ){
-        sqlite3_str_appendall(pStr, ",\"journal\":");
-        rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_FILESTAT, pStr);
-        if( rc ) sqlite3_str_append(pStr, "null", 4);
-      }
-      sqlite3_str_append(pStr, "}", 1);
-      sqlite3_result_text(context, sqlite3_str_finish(pStr), -1,
-                          sqlite3_free);
-    }
-    sqlite3BtreeLeave(pBtree);
-  }else{
-    sqlite3_result_text(context, "{}", 2, SQLITE_STATIC);
-  }
-}
-#endif /* SQLITE_DEBUG || SQLITE_ENABLE_FILESTAT */
-
-#ifdef SQLITE_DEBUG
-/*
-** Implementation of fpdecode(x,y,z) function.
-**
-** x is a real number that is to be decoded.  y is the precision.
-** z is the maximum real precision.  Return a string that shows the
-** results of the sqlite3FpDecode() function.
-**
-** Used for testing and debugging only, specifically testing and debugging
-** of the sqlite3FpDecode() function.  This SQL function does not appear
-** in production builds.  This function is not an API and is subject to
-** modification or removal in future versions of SQLite.
-*/
-static void fpdecodeFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  FpDecode s;
-  double x;
-  int y, z;
-  char zBuf[100];
-  UNUSED_PARAMETER(argc);
-  assert( argc==3 );
-  x = sqlite3_value_double(argv[0]);
-  y = sqlite3_value_int(argv[1]);
-  z = sqlite3_value_int(argv[2]);
-  if( z<=0 ) z = 1;
-  sqlite3FpDecode(&s, x, y, z);
-  if( s.isSpecial==2 ){
-    sqlite3_snprintf(sizeof(zBuf), zBuf, "NaN");
-  }else{
-    sqlite3_snprintf(sizeof(zBuf), zBuf, "%c%.*s/%d", s.sign, s.n, s.z, s.iDP);
-  }
-  sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
-}
-#endif /* SQLITE_DEBUG */
-
-#ifdef SQLITE_DEBUG
-/*
-** Implementation of parseuri(uri,flags) function.
-**
-** Required Arguments:
-**    "uri"        The URI to parse.
-**    "flags"      Bitmask of flags, as if to sqlite3_open_v2().
-**
-** Additional arguments beyond the first two make calls to
-** sqlite3_uri_key() for integers and sqlite3_uri_parameter for
-** anything else.
-**
-** The result is a string showing the results of calling sqlite3ParseUri().
-**
-** Used for testing and debugging only, specifically testing and debugging
-** of the sqlite3ParseUri() function.  This SQL function does not appear
-** in production builds.  This function is not an API and is subject to
-** modification or removal in future versions of SQLite.
-*/
-static void parseuriFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  sqlite3_str *pResult;
-  const char *zVfs;
-  const char *zUri;
-  unsigned int flgs;
-  int rc;
-  sqlite3_vfs *pVfs = 0;
-  char *zFile = 0;
-  char *zErr = 0;
-
-  if( argc<2 ) return;
-  pVfs = sqlite3_vfs_find(0);
-  assert( pVfs );
-  zVfs = pVfs->zName;
-  zUri = (const char*)sqlite3_value_text(argv[0]);
-  if( zUri==0 ) return;
-  flgs = (unsigned int)sqlite3_value_int(argv[1]);
-  rc = sqlite3ParseUri(zVfs, zUri, &flgs, &pVfs, &zFile, &zErr);
-  pResult = sqlite3_str_new(0);
-  if( pResult ){
-    int i;
-    sqlite3_str_appendf(pResult, "rc=%d", rc);
-    sqlite3_str_appendf(pResult, ", flags=0x%x", flgs);
-    sqlite3_str_appendf(pResult, ", vfs=%Q", pVfs ? pVfs->zName: 0);
-    sqlite3_str_appendf(pResult, ", err=%Q", zErr);
-    sqlite3_str_appendf(pResult, ", file=%Q", zFile);
-    if( zFile ){
-      const char *z = zFile;
-      z += sqlite3Strlen30(z)+1;
-      while( z[0] ){
-        sqlite3_str_appendf(pResult, ", %Q", z);
-        z += sqlite3Strlen30(z)+1;
-      }
-      for(i=2; i<argc; i++){
-        const char *zArg;
-        if( sqlite3_value_type(argv[i])==SQLITE_INTEGER ){
-          int k = sqlite3_value_int(argv[i]);
-          sqlite3_str_appendf(pResult, ", '%d:%q'",k,sqlite3_uri_key(zFile, k));
-        }else if( (zArg = (const char*)sqlite3_value_text(argv[i]))!=0 ){
-          sqlite3_str_appendf(pResult, ", '%q:%q'",
-                 zArg, sqlite3_uri_parameter(zFile,zArg));
-        }else{
-          sqlite3_str_appendf(pResult, ", NULL");
-        }
-      }
-    }
-    sqlite3_result_text(ctx, sqlite3_str_finish(pResult), -1, sqlite3_free);
-  }
-  sqlite3_free_filename(zFile);
-  sqlite3_free(zErr);
-}
-#endif /* SQLITE_DEBUG */
-
-/*
-** 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
-#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
-#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_FILESTAT)
-    FUNCTION(sqlite_filestat,    1, 0, 0, filestatFunc     ),
-#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,               -3, 0, 1, minmaxFunc       ),
-    WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
-                                 SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
-    FUNCTION(max,               -3, 1, 1, minmaxFunc       ),
-    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|SQLITE_SUBTYPE),
-    FUNCTION2(length,            1, 0, 0, lengthFunc,  SQLITE_FUNC_LENGTH),
-    FUNCTION2(octet_length,      1, 0, 0, bytelengthFunc,SQLITE_FUNC_BYTELEN),
-    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          ),
-#ifdef SQLITE_DEBUG
-    FUNCTION(fpdecode,           3, 0, 0, fpdecodeFunc     ),
-    FUNCTION(parseuri,          -1, 0, 0, parseuriFunc     ),
-#endif
-#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        ),
-    FUNCTION(concat,            -3, 0, 0, concatFunc       ),
-    FUNCTION(concat_ws,         -4, 0, 0, concatwsFunc     ),
-    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(unistr,             1, 0, 0, unistrFunc       ),
-    FUNCTION(quote,              1, 0, 0, quoteFunc        ),
-    FUNCTION(unistr_quote,       1, 1, 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),
-    WAGGREGATE(string_agg,   2, 0, 0, groupConcatStep,
-        groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
-
-#ifdef SQLITE_ENABLE_PERCENTILE
-    WAGGREGATE(median,          1,   0,0, percentStep,
-        percentFinal, percentValue, percentInverse,
-        SQLITE_INNOCUOUS|SQLITE_SELFORDER1),
-    WAGGREGATE(percentile,      2, 0x2,0, percentStep,
-        percentFinal, percentValue, percentInverse,
-        SQLITE_INNOCUOUS|SQLITE_SELFORDER1),
-    WAGGREGATE(percentile_cont, 2,   0,0, percentStep,
-        percentFinal, percentValue, percentInverse,
-        SQLITE_INNOCUOUS|SQLITE_SELFORDER1),
-    WAGGREGATE(percentile_disc, 2, 0x1,0, percentStep,
-        percentFinal, percentValue, percentInverse,
-        SQLITE_INNOCUOUS|SQLITE_SELFORDER1),
-#endif /* SQLITE_ENABLE_PERCENTILE */
-
-    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
-#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   ),
-    MFUNCTION(pi,                0, 0,         piFunc      ),
-#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
-    FUNCTION(sign,               1, 0, 0,      signFunc    ),
-    INLINE_FUNC(coalesce,       -4, INLINEFUNC_coalesce, 0 ),
-    INLINE_FUNC(iif,            -4, INLINEFUNC_iif,      0 ),
-    INLINE_FUNC(if,             -4, 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; i<SQLITE_FUNC_HASH_SZ; i++){
-      printf("FUNC-HASH %02d:", i);
-      for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.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; i<nCol; i++) aiCol[i] = pFKey->aCol[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; i<nCol; i++){
-          i16 iCol = pIdx->aiColumn[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; j<nCol; j++){
-            if( sqlite3StrICmp(pFKey->aCol[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; i<pFKey->nCol; 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; i<nCol; i++){
-        sqlite3VdbeAddOp2(v, OP_Copy,
-               sqlite3TableColumnToStorage(pFKey->pFrom, 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; i<nCol; i++){
-          int iChild = sqlite3TableColumnToStorage(pFKey->pFrom,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:
-  **
-  **   <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ...
-  **
-  ** 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; i<pFKey->nCol; 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; i<pIdx->nKeyCol; 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;
-    sqlite3SrcListDelete(dbMem, pStep->pSrc);
-    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 <tbl>" 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; i<p->nCol; 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; i<p->nCol; i++){
-    char *zKey = p->aCol[i].zCol;
-    int iKey;
-    for(iKey=0; iKey<pTab->nCol; 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)
-    ){
-      assert( (pTop->db->flags & SQLITE_FkNoAction)==0 );
-      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);
-  assert( iDb>=00 && iDb<db->nDb );
-  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; i<pFKey->nCol; 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; i<pFKey->nCol; 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->pSTab = pFKey->pFrom;
-      pItem->zName = pFKey->pFrom->zName;
-      pItem->pSTab->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];
-        if( (db->flags & SQLITE_FkNoAction) ) eAction = OE_None;
-
-        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; i<p->nCol; 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; i<pIdx->nKeyCol; 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( (pParse->db->flags & SQLITE_FkNoAction)==0
-           && 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( (db->flags & SQLITE_FkNoAction) ) action = OE_None;
-  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; i<pFKey->nCol; 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->iPKey<pTab->nCol) );
-      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 ){
-      SrcList *pSrc;
-      Expr *pRaise;
-
-      pRaise = sqlite3Expr(db, TK_STRING, "FOREIGN KEY constraint failed"),
-      pRaise = sqlite3PExpr(pParse, TK_RAISE, pRaise, 0);
-      if( pRaise ){
-        pRaise->affExpr = OE_Abort;
-      }
-      pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
-      if( pSrc ){
-        SrcItem *pItem = &pSrc->a[0];
-        pItem->zName = sqlite3DbStrDup(db, zFrom);
-        pItem->fg.fixedSchema = 1;
-        pItem->u4.pSchema = pTab->pSchema;
-      }
-      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 */
-    );
-    if( pTrigger ){
-      pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1];
-      pStep->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
-      if( pStep->pSrc ){
-        SrcItem *pItem = &pStep->pSrc->a[0];
-        pItem->zName = sqlite3DbStrNDup(db, zFrom, nFrom);
-        pItem->u4.pSchema = pTab->pSchema;
-        pItem->fg.fixedSchema = 1;
-      }
-      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{
-        const char *z = (pFKey->pNextTo ? pFKey->pNextTo->zTo : pFKey->zTo);
-        sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, pFKey->pNextTo);
-      }
-      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 );
-  if( !pParse->db->noSharedCache ){
-    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; n<pIdx->nColumn; 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( aff<SQLITE_AFF_BLOB ) aff = SQLITE_AFF_BLOB;
-    if( aff>SQLITE_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; i<pTab->nCol; 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 appropriate 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;
-      int p3;
-      sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
-      pPrev = sqlite3VdbeGetLastOp(v);
-      assert( pPrev!=0 );
-      assert( pPrev->opcode==OP_MakeRecord || sqlite3VdbeDb(v)->mallocFailed );
-      pPrev->opcode = OP_TypeCheck;
-      p3 = pPrev->p3;
-      pPrev->p3 = 0;
-      sqlite3VdbeAddOp3(v, OP_MakeRecord, pPrev->p1, pPrev->p2, 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 <iDb, pTab> 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; i<iEnd; i++){
-    VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
-    assert( pOp!=0 );
-    if( pOp->opcode==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; i<pTab->nCol; 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; i<pTab->nCol; 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 */
-
-/*
-** If argument pVal is a Select object returned by an sqlite3MultiValues()
-** that was able to use the co-routine optimization, finish coding the
-** co-routine.
-*/
-SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal){
-  if( ALWAYS(pVal) && pVal->pSrc->nSrc>0 ){
-    SrcItem *pItem = &pVal->pSrc->a[0];
-    assert( (pItem->fg.isSubquery && pItem->u4.pSubq!=0) || pParse->nErr );
-    if( pItem->fg.isSubquery ){
-      sqlite3VdbeEndCoroutine(pParse->pVdbe, pItem->u4.pSubq->regReturn);
-      sqlite3VdbeJumpHere(pParse->pVdbe, pItem->u4.pSubq->addrFillSub - 1);
-    }
-  }
-}
-
-/*
-** Return true if all expressions in the expression-list passed as the
-** only argument are constant.
-*/
-static int exprListIsConstant(Parse *pParse, ExprList *pRow){
-  int ii;
-  for(ii=0; ii<pRow->nExpr; ii++){
-    if( 0==sqlite3ExprIsConstant(pParse, pRow->a[ii].pExpr) ) return 0;
-  }
-  return 1;
-}
-
-/*
-** Return true if all expressions in the expression-list passed as the
-** only argument are both constant and have no affinity.
-*/
-static int exprListIsNoAffinity(Parse *pParse, ExprList *pRow){
-  int ii;
-  if( exprListIsConstant(pParse,pRow)==0 ) return 0;
-  for(ii=0; ii<pRow->nExpr; ii++){
-    Expr *pExpr = pRow->a[ii].pExpr;
-    assert( pExpr->op!=TK_RAISE );
-    assert( pExpr->affExpr==0 );
-    if( 0!=sqlite3ExprAffinity(pExpr) ) return 0;
-  }
-  return 1;
-
-}
-
-/*
-** This function is called by the parser for the second and subsequent
-** rows of a multi-row VALUES clause. Argument pLeft is the part of
-** the VALUES clause already parsed, argument pRow is the vector of values
-** for the new row. The Select object returned represents the complete
-** VALUES clause, including the new row.
-**
-** There are two ways in which this may be achieved - by incremental
-** coding of a co-routine (the "co-routine" method) or by returning a
-** Select object equivalent to the following (the "UNION ALL" method):
-**
-**        "pLeft UNION ALL SELECT pRow"
-**
-** If the VALUES clause contains a lot of rows, this compound Select
-** object may consume a lot of memory.
-**
-** When the co-routine method is used, each row that will be returned
-** by the VALUES clause is coded into part of a co-routine as it is
-** passed to this function. The returned Select object is equivalent to:
-**
-**     SELECT * FROM (
-**       Select object to read co-routine
-**     )
-**
-** The co-routine method is used in most cases. Exceptions are:
-**
-**    a) If the current statement has a WITH clause. This is to avoid
-**       statements like:
-**
-**            WITH cte AS ( VALUES('x'), ('y') ... )
-**            SELECT * FROM cte AS a, cte AS b;
-**
-**       This will not work, as the co-routine uses a hard-coded register
-**       for its OP_Yield instructions, and so it is not possible for two
-**       cursors to iterate through it concurrently.
-**
-**    b) The schema is currently being parsed (i.e. the VALUES clause is part
-**       of a schema item like a VIEW or TRIGGER). In this case there is no VM
-**       being generated when parsing is taking place, and so generating
-**       a co-routine is not possible.
-**
-**    c) There are non-constant expressions in the VALUES clause (e.g.
-**       the VALUES clause is part of a correlated sub-query).
-**
-**    d) One or more of the values in the first row of the VALUES clause
-**       has an affinity (i.e. is a CAST expression). This causes problems
-**       because the complex rules SQLite uses (see function
-**       sqlite3SubqueryColumnTypes() in select.c) to determine the effective
-**       affinity of such a column for all rows require access to all values in
-**       the column simultaneously.
-*/
-SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow){
-
-  if( pParse->bHasWith                   /* condition (a) above */
-   || pParse->db->init.busy              /* condition (b) above */
-   || exprListIsConstant(pParse,pRow)==0 /* condition (c) above */
-   || (pLeft->pSrc->nSrc==0 &&
-       exprListIsNoAffinity(pParse,pLeft->pEList)==0) /* condition (d) above */
-   || IN_SPECIAL_PARSE
-  ){
-    /* The co-routine method cannot be used. Fall back to UNION ALL. */
-    Select *pSelect = 0;
-    int f = SF_Values | SF_MultiValue;
-    if( pLeft->pSrc->nSrc ){
-      sqlite3MultiValuesEnd(pParse, pLeft);
-      f = SF_Values;
-    }else if( pLeft->pPrior ){
-      /* In this case set the SF_MultiValue flag only if it was set on pLeft */
-      f = (f & pLeft->selFlags);
-    }
-    pSelect = sqlite3SelectNew(pParse, pRow, 0, 0, 0, 0, 0, f, 0);
-    pLeft->selFlags &= ~(u32)SF_MultiValue;
-    if( pSelect ){
-      pSelect->op = TK_ALL;
-      pSelect->pPrior = pLeft;
-      pLeft = pSelect;
-    }
-  }else{
-    SrcItem *p = 0;               /* SrcItem that reads from co-routine */
-
-    if( pLeft->pSrc->nSrc==0 ){
-      /* Co-routine has not yet been started and the special Select object
-      ** that accesses the co-routine has not yet been created. This block
-      ** does both those things. */
-      Vdbe *v = sqlite3GetVdbe(pParse);
-      Select *pRet = sqlite3SelectNew(pParse, 0, 0, 0, 0, 0, 0, 0, 0);
-
-      /* Ensure the database schema has been read. This is to ensure we have
-      ** the correct text encoding.  */
-      if( (pParse->db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ){
-        sqlite3ReadSchema(pParse);
-      }
-
-      if( pRet ){
-        SelectDest dest;
-        Subquery *pSubq;
-        pRet->pSrc->nSrc = 1;
-        pRet->pPrior = pLeft->pPrior;
-        pRet->op = pLeft->op;
-        if( pRet->pPrior ) pRet->selFlags |= SF_Values;
-        pLeft->pPrior = 0;
-        pLeft->op = TK_SELECT;
-        assert( pLeft->pNext==0 );
-        assert( pRet->pNext==0 );
-        p = &pRet->pSrc->a[0];
-        p->fg.viaCoroutine = 1;
-        p->iCursor = -1;
-        assert( !p->fg.isIndexedBy && !p->fg.isTabFunc );
-        p->u1.nRow = 2;
-        if( sqlite3SrcItemAttachSubquery(pParse, p, pLeft, 0) ){
-          pSubq = p->u4.pSubq;
-          pSubq->addrFillSub = sqlite3VdbeCurrentAddr(v) + 1;
-          pSubq->regReturn = ++pParse->nMem;
-          sqlite3VdbeAddOp3(v, OP_InitCoroutine,
-                            pSubq->regReturn, 0, pSubq->addrFillSub);
-          sqlite3SelectDestInit(&dest, SRT_Coroutine, pSubq->regReturn);
-
-          /* Allocate registers for the output of the co-routine. Do so so
-          ** that there are two unused registers immediately before those
-          ** used by the co-routine. This allows the code in sqlite3Insert()
-          ** to use these registers directly, instead of copying the output
-          ** of the co-routine to a separate array for processing.  */
-          dest.iSdst = pParse->nMem + 3;
-          dest.nSdst = pLeft->pEList->nExpr;
-          pParse->nMem += 2 + dest.nSdst;
-
-          pLeft->selFlags |= SF_MultiValue;
-          sqlite3Select(pParse, pLeft, &dest);
-          pSubq->regResult = dest.iSdst;
-          assert( pParse->nErr || dest.iSdst>0 );
-        }
-        pLeft = pRet;
-      }
-    }else{
-      p = &pLeft->pSrc->a[0];
-      assert( !p->fg.isTabFunc && !p->fg.isIndexedBy );
-      p->u1.nRow++;
-    }
-
-    if( pParse->nErr==0 ){
-      Subquery *pSubq;
-      assert( p!=0 );
-      assert( p->fg.isSubquery );
-      pSubq = p->u4.pSubq;
-      assert( pSubq!=0 );
-      assert( pSubq->pSelect!=0 );
-      assert( pSubq->pSelect->pEList!=0 );
-      if( pSubq->pSelect->pEList->nExpr!=pRow->nExpr ){
-        sqlite3SelectWrongNumTermsError(pParse, pSubq->pSelect);
-      }else{
-        sqlite3ExprCodeExprList(pParse, pRow, pSubq->regResult, 0, 0);
-        sqlite3VdbeAddOp1(pParse->pVdbe, OP_Yield, pSubq->regReturn);
-      }
-    }
-    sqlite3ExprListDelete(pParse->db, pRow);
-  }
-
-  return pLeft;
-}
-
-/* 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 <table> and its indices
-**         put VALUES clause expressions into registers
-**         write the resulting record into <table>
-**         cleanup
-**
-** The three remaining templates assume the statement is of the form
-**
-**   INSERT INTO <table> SELECT ...
-**
-** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
-** 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 <table2> and <table1> are distinct tables but have identical
-** schemas, including all the same indices, then a special optimization
-** is invoked that copies raw records from <table2> over to <table1>.
-** See the xferOptimization() function for the implementation of this
-** template.  This is the 2nd template.
-**
-**         open a write cursor to <table>
-**         open read cursor on <table2>
-**         transfer all records in <table2> over to <table>
-**         close cursors
-**         foreach index on <table>
-**           open a write cursor on the <table> index
-**           open a read cursor on the corresponding <table2> 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 <table> 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 <table> and its indices
-**      C: yield X, at EOF goto D
-**         insert the select result into <table> 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 <table> and its indices
-**         rewind temp table
-**      C: loop over rows of intermediate table
-**           transfer values form intermediate table into <table>
-**         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 */
-  int *aTabColMap = 0;  /* Mapping from pTab columns to pCol entries */
-
-#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( iDb<db->nDb );
-  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 <table1> SELECT * FROM <table2>;
-  **
-  ** 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 ){
-    aTabColMap = sqlite3DbMallocZero(db, pTab->nCol*sizeof(int));
-    if( aTabColMap==0 ) goto insert_cleanup;
-    for(i=0; i<pColumn->nId; i++){
-      j = sqlite3ColumnIndex(pTab, pColumn->a[i].zName);
-      if( j>=0 ){
-        if( aTabColMap[j]==0 ) aTabColMap[j] = i+1;
-        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
-      }else{
-        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 rc;             /* Result code */
-
-    if( pSelect->pSrc->nSrc==1
-     && pSelect->pSrc->a[0].fg.viaCoroutine
-     && pSelect->pPrior==0
-    ){
-      SrcItem *pItem = &pSelect->pSrc->a[0];
-      Subquery *pSubq;
-      assert( pItem->fg.isSubquery );
-      pSubq = pItem->u4.pSubq;
-      dest.iSDParm = pSubq->regReturn;
-      regFromSelect = pSubq->regResult;
-      assert( pSubq->pSelect!=0 );
-      assert( pSubq->pSelect->pEList!=0 );
-      nColumn = pSubq->pSelect->pEList->nExpr;
-      ExplainQueryPlan((pParse, 0, "SCAN %S", pItem));
-      if( bIdListInOrder && nColumn==pTab->nCol ){
-        regData = regFromSelect;
-        regRowid = regData - 1;
-        regIns = regRowid - (IsVirtual(pTab) ? 1 : 0);
-      }
-    }else{
-      int addrTop;        /* Top of the co-routine */
-      int 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; i<pTab->nCol; 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; i<nIdx; pIdx=pIdx->pNext, 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, pUpsert) ){
-          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 <table>
-    **         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 <table> 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; i<pTab->nCol; 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 their default value */
-        sqlite3ExprCodeFactorable(pParse,
-            sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
-            iRegStore);
-        continue;
-      }
-    }
-    if( pColumn ){
-      j = aTabColMap[i];
-      assert( j>=0 && j<=pColumn->nId );
-      if( j==0 ){
-        /* A column not named in the insert column list gets its
-        ** default value */
-        sqlite3ExprCodeFactorable(pParse,
-            sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
-            iRegStore);
-        continue;
-      }
-      k = j - 1;
-    }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);
-  if( pColumn ){
-    sqlite3IdListDelete(db, pColumn);
-    sqlite3DbFree(db, aTabColMap);
-  }
-  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 modified 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 construction */
-  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; i<nCol; i++){
-        int iReg;                        /* Register holding column value */
-        Column *pCol = &pTab->aCol[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; i<pCheck->nExpr; 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://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 holding content 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; i<pIdx->nColumn; 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; i<pPk->nKeyCol; 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; i<pPk->nKeyCol; 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 );
-  assert( piDataCur!=0 );
-  assert( piIdxCur!=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++;
-  *piDataCur = iDataCur;
-  if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){
-    sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
-  }else if( pParse->db->noSharedCache==0 ){
-    sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
-  }
-  *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) ){
-      *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; i<pSrc->nKeyCol; 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].fg.isSubquery ){
-    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; i<pDest->nCol; 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
-   && (db->mDbFlags & DBFLAG_Vacuum)==0
-   && 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 contains
-  ** 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; i<pSrcIdx->nColumn; 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; i<nCol; i++){
-            azCols[i] = (char *)sqlite3_column_name(pStmt, i);
-            /* sqlite3VdbeSetColName() installs column names as UTF8
-            ** strings so there is no way for sqlite3_column_name() to fail. */
-            assert( azCols[i]!=0 );
-          }
-          callbackIsInit = 1;
-        }
-        if( rc==SQLITE_ROW ){
-          azVals = &azCols[nCol];
-          for(i=0; i<nCol; i++){
-            azVals[i] = (char *)sqlite3_column_text(pStmt, i);
-            if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
-              sqlite3OomFault(db);
-              goto exec_out;
-            }
-          }
-          azVals[i] = 0;
-        }
-        if( xCallback(pArg, nCol, azVals, azCols) ){
-          /* EVIDENCE-OF: R-38229-40159 If the callback function to
-          ** sqlite3_exec() returns non-zero, then sqlite3_exec() will
-          ** return SQLITE_ABORT. */
-          rc = SQLITE_ABORT;
-          sqlite3VdbeFinalize((Vdbe *)pStmt);
-          pStmt = 0;
-          sqlite3Error(db, SQLITE_ABORT);
-          goto exec_out;
-        }
-      }
-
-      if( rc!=SQLITE_ROW ){
-        rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
-        pStmt = 0;
-        zSql = zLeftover;
-        while( sqlite3Isspace(zSql[0]) ) zSql++;
-        break;
-      }
-    }
-
-    sqlite3DbFree(db, azCols);
-    azCols = 0;
-  }
-
-exec_out:
-  if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
-  sqlite3DbFree(db, azCols);
-
-  rc = sqlite3ApiExit(db, rc);
-  if( rc!=SQLITE_OK && pzErrMsg ){
-    *pzErrMsg = sqlite3DbStrDup(0, sqlite3_errmsg(db));
-    if( *pzErrMsg==0 ){
-      rc = SQLITE_NOMEM_BKPT;
-      sqlite3Error(db, SQLITE_NOMEM);
-    }
-  }else if( pzErrMsg ){
-    *pzErrMsg = 0;
-  }
-
-  assert( (rc&db->errMask)==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*);
-  /* Version 3.43.0 and later */
-  int (*stmt_explain)(sqlite3_stmt*,int);
-  /* Version 3.44.0 and later */
-  void *(*get_clientdata)(sqlite3*,const char*);
-  int (*set_clientdata)(sqlite3*, const char*, void*, void(*)(void*));
-  /* Version 3.50.0 and later */
-  int (*setlk_timeout)(sqlite3*,int,int);
-  /* Version 3.51.0 and later */
-  int (*set_errmsg)(sqlite3*,int,const char*);
-  int (*db_status64)(sqlite3*,int,sqlite3_int64*,sqlite3_int64*,int);
-  /* Version 3.52.0 and later */
-  void (*str_truncate)(sqlite3_str*,int);
-  void (*str_free)(sqlite3_str*);
-  int (*carray_bind)(sqlite3_stmt*,int,void*,int,int,void(*)(void*));
-  int (*carray_bind_v2)(sqlite3_stmt*,int,void*,int,int,void(*)(void*),void*);
-};
-
-/*
-** 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
-/* Version 3.43.0 and later */
-#define sqlite3_stmt_explain           sqlite3_api->stmt_explain
-/* Version 3.44.0 and later */
-#define sqlite3_get_clientdata         sqlite3_api->get_clientdata
-#define sqlite3_set_clientdata         sqlite3_api->set_clientdata
-/* Version 3.50.0 and later */
-#define sqlite3_setlk_timeout          sqlite3_api->setlk_timeout
-/* Version 3.51.0 and later */
-#define sqlite3_set_errmsg             sqlite3_api->set_errmsg
-#define sqlite3_db_status64            sqlite3_api->db_status64
-/* Version 3.52.0 and later */
-#define sqlite3_str_truncate           sqlite3_api->str_truncate
-#define sqlite3_str_free               sqlite3_api->str_free
-#define sqlite3_carray_bind            sqlite3_api->carray_bind
-#define sqlite3_carray_bind_v2         sqlite3_api->carray_bind_v2
-#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,
-  /* Version 3.43.0 and later */
-  sqlite3_stmt_explain,
-  /* Version 3.44.0 and later */
-  sqlite3_get_clientdata,
-  sqlite3_set_clientdata,
-  /* Version 3.50.0 and later */
-  sqlite3_setlk_timeout,
-  /* Version 3.51.0 and later */
-  sqlite3_set_errmsg,
-  sqlite3_db_status64,
-  /* Version 3.52.0 and later */
-  sqlite3_str_truncate,
-  sqlite3_str_free,
-#ifdef SQLITE_ENABLE_CARRAY
-  sqlite3_carray_bind,
-  sqlite3_carray_bind_v2
-#else
-  0,
-  0
-#endif
-};
-
-/* 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;
-
-  /* Do not allow sqlite3_load_extension() to link to a copy of the
-  ** running application, by passing in an empty filename. */
-  if( nMsg==0 ) goto extension_not_found;
-
-  handle = sqlite3OsDlOpen(pVfs, zFile);
-#if SQLITE_OS_UNIX || SQLITE_OS_WIN
-  for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){
-    char *zAltFile = sqlite3_mprintf("%s.%s", zFile, azEndings[ii]);
-    if( zAltFile==0 ) return SQLITE_NOMEM_BKPT;
-    if( nMsg+strlen(azEndings[ii])+1<=SQLITE_MAX_PATHLEN ){
-      handle = sqlite3OsDlOpen(pVfs, zAltFile);
-    }
-    sqlite3_free(zAltFile);
-  }
-#endif
-  if( handle==0 ) goto extension_not_found;
-  xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);
-
-  /* If no entry point was specified and the default legacy
-  ** entry point name "sqlite3_extension_init" was not found, then
-  ** construct an entry point name "sqlite3_X_init" where the X is
-  ** replaced by the lowercase value of every ASCII alphabetic
-  ** character in the filename after the last "/" up to the first ".",
-  ** and skipping the first three characters if they are "lib".
-  ** Examples:
-  **
-  **    /usr/local/lib/libExample5.4.3.so ==>  sqlite3_example_init
-  **    C:/lib/mathfuncs.dll              ==>  sqlite3_mathfuncs_init
-  **
-  ** If that still finds no entry point, repeat a second time but this
-  ** time include both alphabetic and numeric characters up to the first
-  ** ".".  Example:
-  **
-  **    /usr/local/lib/libExample5.4.3.so ==>  sqlite3_example5_init
-  */
-  if( xInit==0 && zProc==0 ){
-    int iFile, iEntry, c;
-    int ncFile = sqlite3Strlen30(zFile);
-    int cnt = 0;
-    zAltEntry = sqlite3_malloc64(ncFile+30);
-    if( zAltEntry==0 ){
-      sqlite3OsDlClose(pVfs, handle);
-      return SQLITE_NOMEM_BKPT;
-    }
-    do{
-      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) || (cnt && sqlite3Isdigit(c)) ){
-          zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c];
-        }
-      }
-      memcpy(zAltEntry+iEntry, "_init", 6);
-      zEntry = zAltEntry;
-      xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);
-    }while( xInit==0 && (++cnt)<2 );
-  }
-  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; i<db->nExtension; 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){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
-#endif
-  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;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( xInit==0 ) return SQLITE_MISUSE_BKPT;
-#endif
-#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<wsdAutoext.nExt; i++){
-      if( wsdAutoext.aExt[i]==xInit ) break;
-    }
-    if( i==wsdAutoext.nExt ){
-      u64 nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
-      void (**aNew)(void);
-      aNew = sqlite3_realloc64(wsdAutoext.aExt, nByte);
-      if( aNew==0 ){
-        rc = SQLITE_NOMEM_BKPT;
-      }else{
-        wsdAutoext.aExt = aNew;
-        wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
-        wsdAutoext.nExt++;
-      }
-    }
-    sqlite3_mutex_leave(mutex);
-    assert( (rc&0xff)==rc );
-    return rc;
-  }
-}
-
-/*
-** Cancel a prior call to sqlite3_auto_extension.  Remove xInit from the
-** set of routines that is invoked for each new database connection, if it
-** is currently on the list.  If xInit is not on the list, then this
-** routine is a no-op.
-**
-** Return 1 if xInit was found on the list and removed.  Return 0 if xInit
-** was not on the list.
-*/
-SQLITE_API int sqlite3_cancel_auto_extension(
-  void (*xInit)(void)
-){
-#if SQLITE_THREADSAFE
-  sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
-#endif
-  int i;
-  int n = 0;
-  wsdAutoextInit;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( xInit==0 ) return 0;
-#endif
-  sqlite3_mutex_enter(mutex);
-  for(i=(int)wsdAutoext.nExt-1; 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_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 */ "name",        /* Used by: function_list */
-  /*  16 */ "builtin",
-  /*  17 */ "type",
-  /*  18 */ "enc",
-  /*  19 */ "narg",
-  /*  20 */ "flags",
-  /*  21 */ "schema",      /* Used by: table_list */
-  /*  22 */ "name",
-  /*  23 */ "type",
-  /*  24 */ "ncol",
-  /*  25 */ "wr",
-  /*  26 */ "strict",
-  /*  27 */ "seqno",       /* Used by: index_xinfo */
-  /*  28 */ "cid",
-  /*  29 */ "name",
-  /*  30 */ "desc",
-  /*  31 */ "coll",
-  /*  32 */ "key",
-  /*  33 */ "seq",         /* Used by: index_list */
-  /*  34 */ "name",
-  /*  35 */ "unique",
-  /*  36 */ "origin",
-  /*  37 */ "partial",
-  /*  38 */ "tbl",         /* Used by: stats */
-  /*  39 */ "idx",
-  /*  40 */ "wdth",
-  /*  41 */ "hght",
-  /*  42 */ "flgs",
-  /*  43 */ "table",       /* Used by: foreign_key_check */
-  /*  44 */ "rowid",
-  /*  45 */ "parent",
-  /*  46 */ "fkid",
-  /*  47 */ "busy",        /* Used by: wal_checkpoint */
-  /*  48 */ "log",
-  /*  49 */ "checkpointed",
-  /*  50 */ "seq",         /* Used by: database_list */
-  /*  51 */ "name",
-  /*  52 */ "file",
-                           /* index_info reuses 27 */
-  /*  53 */ "database",    /* Used by: lock_status */
-  /*  54 */ "status",
-                           /* collation_list reuses 33 */
-  /*  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:  */ 33, 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:  */ 50, 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:  */ 15, 6,
-  /* iArg:      */ 0 },
-#endif
-#endif
- {/* zName:     */ "hard_heap_limit",
-  /* ePragTyp:  */ PragTyp_HARD_HEAP_LIMIT,
-  /* ePragFlg:  */ PragFlg_Result0,
-  /* ColNames:  */ 0, 0,
-  /* iArg:      */ 0 },
-#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:  */ 27, 3,
-  /* iArg:      */ 0 },
- {/* zName:     */ "index_list",
-  /* ePragTyp:  */ PragTyp_INDEX_LIST,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
-  /* ColNames:  */ 33, 5,
-  /* iArg:      */ 0 },
- {/* zName:     */ "index_xinfo",
-  /* ePragTyp:  */ PragTyp_INDEX_INFO,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
-  /* ColNames:  */ 27, 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
-#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 },
- {/* 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:  */ 38, 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:  */ 21, 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
- {/* 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:  */ 47, 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 *********************/
-
-/*
-** When the 0x10 bit of PRAGMA optimize is set, any ANALYZE commands
-** will be run with an analysis_limit set to the lessor of the value of
-** the following macro or to the actual analysis_limit if it is non-zero,
-** in order to prevent PRAGMA optimize from running for too long.
-**
-** The value of 2000 is chosen empirically so that the worst-case run-time
-** for PRAGMA optimize does not exceed 100 milliseconds against a variety
-** of test databases on a RaspberryPI-4 compiled using -Os and without
-** -DSQLITE_DEBUG.  Of course, your mileage may vary.  For the purpose of
-** this paragraph, "worst-case" means that ANALYZE ends up being
-** run on every table in the database.  The worst case typically only
-** happens if PRAGMA optimize is run on a database file for which ANALYZE
-** has not been previously run and the 0x10000 flag is included so that
-** all tables are analyzed.  The usual case for PRAGMA optimize is that
-** no ANALYZE commands will be run at all, or if any ANALYZE happens it
-** will be against a single table, so that expected timing for PRAGMA
-** optimize on a PI-4 is more like 1 millisecond or less with the 0x10000
-** flag or less than 100 microseconds without the 0x10000 flag.
-**
-** An analysis limit of 2000 is almost always sufficient for the query
-** planner to fully characterize an index.  The additional accuracy from
-** a larger analysis is not usually helpful.
-*/
-#ifndef SQLITE_DEFAULT_OPTIMIZE_LIMIT
-# define SQLITE_DEFAULT_OPTIMIZE_LIMIT 2000
-#endif
-
-/*
-** 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<ArraySize(iLength); i++){
-    if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0
-     && (!omitFull || iValue[i]<=1)
-    ){
-      return iValue[i];
-    }
-  }
-  return dflt;
-}
-
-/*
-** Interpret the given string as a boolean value.
-*/
-SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z, u8 dflt){
-  return getSafetyLevel(z,1,dflt)!=0;
-}
-
-/* The sqlite3GetBoolean() function is used by other modules but the
-** remainder of this file is specific to PRAGMA processing.  So omit
-** the rest of the file if PRAGMAs are omitted from the build.
-*/
-#if !defined(SQLITE_OMIT_PRAGMA)
-
-/*
-** Interpret the given string as a locking mode value.
-*/
-static int getLockingMode(const char *z){
-  if( z ){
-    if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
-    if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
-  }
-  return PAGER_LOCKINGMODE_QUERY;
-}
-
-#ifndef SQLITE_OMIT_AUTOVACUUM
-/*
-** Interpret the given string as an auto-vacuum mode value.
-**
-** The following strings, "none", "full" and "incremental" are
-** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
-*/
-static int getAutoVacuum(const char *z){
-  int i;
-  if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
-  if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
-  if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
-  i = sqlite3Atoi(z);
-  return (u8)((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; i<n; i++, j++){
-      sqlite3VdbeSetColName(v, i, COLNAME_NAME, pragCName[j], SQLITE_STATIC);
-    }
-  }
-}
-
-/*
-** Generate code to return a single integer value.
-*/
-static void returnSingleInt(Vdbe *v, i64 value){
-  sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, 1, 0, (const u8*)&value, P4_INT64);
-  sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
-}
-
-/*
-** Generate code to return a single text value.
-*/
-static void returnSingleText(
-  Vdbe *v,                /* Prepared statement under construction */
-  const char *zValue      /* Value to be returned */
-){
-  if( zValue ){
-    sqlite3VdbeLoadString(v, 1, (const char*)zValue);
-    sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
-  }
-}
-
-
-/*
-** Set the safety_level and pager flags for pager iDb.  Or if iDb<0
-** set these values for all pagers.
-*/
-#ifndef SQLITE_OMIT_PAGER_PRAGMAS
-static void setAllPagerFlags(sqlite3 *db){
-  if( db->autoCommit ){
-    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;
-}
-
-/*
-** Should table pTab be skipped when doing an integrity_check?
-** Return true or false.
-**
-** If pObjTab is not null, the return true if pTab matches pObjTab.
-**
-** If pObjTab is null, then return true only if pTab is an imposter table.
-*/
-static int tableSkipIntegrityCheck(const Table *pTab, const Table *pObjTab){
-  if( pObjTab ){
-    return pTab!=pObjTab;
-  }else{
-    return (pTab->tabFlags & TF_Imposter)!=0;
-  }
-}
-
-/*
-** 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 <value>, or NULL */
-  int minusFlag       /* True if a '-' sign preceded <value> */
-){
-  char *zLeft = 0;       /* Nul-terminated UTF-8 string <id> */
-  char *zRight = 0;      /* Nul-terminated UTF-8 string <value>, or NULL */
-  const char *zDb = 0;   /* The database name */
-  Token *pId;            /* Pointer to <id> token */
-  char *aFcntl[4];       /* Argument to SQLITE_FCNTL_PRAGMA */
-  int iDb;               /* Database index for <database> */
-  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 */
-
-  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;
-  }
-
-  /* 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; ii<db->nDb; 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; ii<db->nDb; 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 turning 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( sqlite3GetBoolean(zRight, 0) ){
-        if( (mask & SQLITE_WriteSchema)==0
-         || (db->flags & SQLITE_Defensive)==0
-        ){
-          db->flags |= mask;
-        }
-      }else{
-        db->flags &= ~mask;
-        if( mask==SQLITE_DeferFKs ){
-          db->nDeferredImmCons = 0;
-          db->nDeferredCons = 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(<table>)
-  **
-  ** 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; i<pTab->nCol; 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; ii<db->nDb; 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_v3(db, zSql, -1, SQLITE_PREPARE_DONT_LOG,
-                                       &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; i<mx; i++){
-        i16 cnum = pIdx->aiColumn[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],
-            i<pIdx->nKeyCol);
-        }
-        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; i<db->nDb; 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; i<SQLITE_FUNC_HASH_SZ; i++){
-      for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.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; i<ArraySize(aPragmaName); i++){
-      sqlite3VdbeMultiLoad(v, 1, "s", aPragmaName[i].zName);
-    }
-  }
-  break;
-#endif /* SQLITE_INTROSPECTION_PRAGMAS */
-
-#endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
-
-#ifndef SQLITE_OMIT_FOREIGN_KEY
-  case PragTyp_FOREIGN_KEY_LIST: if( zRight ){
-    FKey *pFK;
-    Table *pTab;
-    pTab = sqlite3FindTable(db, zRight, zDb);
-    if( pTab && IsOrdinaryTable(pTab) ){
-      pFK = pTab->u.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; j<pFK->nCol; 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->nTab<i ) pParse->nTab = 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; j<pFK->nCol; 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 whereas integrity_check is O(NlogN).
-  **
-  ** The maximum number 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 <db>.integrity_check",
-    ** then iDb is set to the index of the database identified by <db>.
-    ** 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(pValue->z, &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; i<db->nDb; 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[] */
-
-      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( tableSkipIntegrityCheck(pTab,pObjTab) ) continue;
-        if( HasRowid(pTab) ) cnt++;
-        for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; }
-      }
-      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( tableSkipIntegrityCheck(pTab,pObjTab) ) 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+cnt);
-      sqlite3VdbeAddOp3(v, OP_Null, 0, 8, 8+cnt);
-      sqlite3ClearTempRegCache(pParse);
-
-      /* Do the b-tree integrity checks */
-      sqlite3VdbeAddOp4(v, OP_IntegrityCk, 1, cnt, 8, (char*)aRoot,P4_INTARRAY);
-      sqlite3VdbeChangeP5(v, (u16)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);
-
-      /* Check that the indexes all have the right number of rows */
-      cnt = pObjTab ? 1 : 0;
-      sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
-      for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
-        int iTab = 0;
-        Table *pTab = sqliteHashData(x);
-        Index *pIdx;
-        if( tableSkipIntegrityCheck(pTab,pObjTab) ) continue;
-        if( HasRowid(pTab) ){
-          iTab = cnt++;
-        }else{
-          iTab = cnt;
-          for(pIdx=pTab->pIndex; ALWAYS(pIdx); pIdx=pIdx->pNext){
-            if( IsPrimaryKeyIndex(pIdx) ) break;
-            iTab++;
-          }
-        }
-        for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
-          if( pIdx->pPartIdxWhere==0 ){
-            addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+cnt, 0, 8+iTab);
-            VdbeCoverageNeverNull(v);
-            sqlite3VdbeLoadString(v, 4, pIdx->zName);
-            sqlite3VdbeAddOp3(v, OP_Concat, 4, 2, 3);
-            integrityCheckResultRow(v);
-            sqlite3VdbeJumpHere(v, addr);
-          }
-          cnt++;
-        }
-      }
-
-      /* 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( tableSkipIntegrityCheck(pTab,pObjTab) ) continue;
-        if( !IsOrdinaryTable(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; j<pTab->nCol; 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; j<pPk->nKeyCol; 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; j<pTab->nCol; 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);
-              sqlite3ColumnDefault(v, pTab, j, 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 */
-            sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1,
-                                        pIdx->nColumn); VdbeCoverage(v);
-            jmp2 = sqlite3VdbeAddOp3(v, OP_IFindKey, iIdxCur+j, ckUniq, r1);
-            VdbeCoverage(v);
-            sqlite3VdbeChangeP4(v, -1, (const char*)pIdx, P4_INDEX);
-            sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
-              sqlite3MPrintf(db, "index %s stores an imprecise floating-point "
-                                 "value for row ", pIdx->zName),
-              P4_DYNAMIC);
-            sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
-            integrityCheckResultRow(v);
-            sqlite3VdbeAddOp2(v, OP_Goto, 0, ckUniq);
-
-            sqlite3VdbeJumpHere(v, jmp2);
-            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);
-            sqlite3VdbeResolveLabel(v, ckUniq);
-
-            /* 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; kk<pIdx->nKeyCol; 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; kk<pIdx->nKeyCol; kk++){
-                int iCol = pIdx->aiColumn[kk];
-                assert( iCol!=XN_ROWID && iCol<pTab->nCol );
-                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( pPk ){
-          assert( !isQuick );
-          sqlite3ReleaseTempRange(pParse, r2, pPk->nKeyCol);
-        }
-      }
-
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-      /* Second pass to invoke the xIntegrity method on all virtual
-      ** tables.
-      */
-      for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
-        Table *pTab = sqliteHashData(x);
-        sqlite3_vtab *pVTab;
-        int a1;
-        if( tableSkipIntegrityCheck(pTab,pObjTab) ) continue;
-        if( IsOrdinaryTable(pTab) ) continue;
-        if( !IsVirtual(pTab) ) continue;
-        if( pTab->nCol<=0 ){
-          const char *zMod = pTab->u.vtab.azArg[0];
-          if( sqlite3HashFind(&db->aModule, zMod)==0 ) continue;
-        }
-        sqlite3ViewGetColumnNames(pParse, pTab);
-        if( pTab->u.vtab.p==0 ) continue;
-        pVTab = pTab->u.vtab.p->pVtab;
-        if( NEVER(pVTab==0) ) continue;
-        if( NEVER(pVTab->pModule==0) ) continue;
-        if( pVTab->pModule->iVersion<4 ) continue;
-        if( pVTab->pModule->xIntegrity==0 ) continue;
-        sqlite3VdbeAddOp3(v, OP_VCheck, i, 3, isQuick);
-        pTab->nTabRef++;
-        sqlite3VdbeAppendP4(v, pTab, P4_TABLEREF);
-        a1 = sqlite3VdbeAddOp1(v, OP_IsNull, 3); VdbeCoverage(v);
-        integrityCheckResultRow(v);
-        sqlite3VdbeJumpHere(v, a1);
-        continue;
-      }
-#endif
-    }
-    {
-      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 = <integer>
-  **
-  **   PRAGMA [schema.]user_version
-  **   PRAGMA [schema.]user_version = <integer>
-  **
-  **   PRAGMA [schema.]freelist_count
-  **
-  **   PRAGMA [schema.]data_version
-  **
-  **   PRAGMA [schema.]application_id
-  **   PRAGMA [schema.]application_id = <integer>
-  **
-  ** 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;
-      }else if( sqlite3StrICmp(zRight, "noop")==0 ){
-        eMode = SQLITE_CHECKPOINT_NOOP;
-      }
-    }
-    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:
-  **
-  **    0x00001    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.
-  **
-  **    0x00002    Run ANALYZE on tables that might benefit.  On by default.
-  **               See below for additional information.
-  **
-  **    0x00010    Run all ANALYZE operations using an analysis_limit that
-  **               is the lessor of the current analysis_limit and the
-  **               SQLITE_DEFAULT_OPTIMIZE_LIMIT compile-time option.
-  **               The default value of SQLITE_DEFAULT_OPTIMIZE_LIMIT is
-  **               currently (2024-02-19) set to 2000, which is such that
-  **               the worst case run-time for PRAGMA optimize on a 100MB
-  **               database will usually be less than 100 milliseconds on
-  **               a RaspberryPI-4 class machine.  On by default.
-  **
-  **    0x10000    Look at tables to see if they need to be reanalyzed
-  **               due to growth or shrinkage even if they have not been
-  **               queried during the current connection.  Off by default.
-  **
-  ** The default MASK is and always shall be 0x0fffe.  In the current
-  ** implementation, the default mask only covers the 0x00002 optimization,
-  ** though additional optimizations that are covered by 0x0fffe might be
-  ** added in the future.  Optimizations that are off by default and must
-  ** be explicitly requested have masks of 0x10000 or greater.
-  **
-  ** 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 0x00002 is set.
-  **
-  ** (2) The table is an ordinary table, not a virtual table or view.
-  **
-  ** (3) The table name does not begin with "sqlite_".
-  **
-  ** (4) One or more of the following is true:
-  **      (4a) The 0x10000 MASK bit is set.
-  **      (4b) One or more indexes on the table lacks an entry
-  **           in the sqlite_stat1 table.
-  **      (4c) 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.
-  **
-  ** (5) One or more of the following is true:
-  **      (5a) One or more indexes on the table lacks an entry
-  **           in the sqlite_stat1 table.  (Same as 4a)
-  **      (5b) The number of rows in the table has increased or decreased by
-  **           10-fold.  In other words, the current size of the table is
-  **           10 times larger than the size in sqlite_stat1 or else the
-  **           current size is less than 1/10th the size in sqlite_stat1.
-  **
-  ** The rules for when tables are analyzed are likely to change in
-  ** future releases.  Future versions of SQLite might accept a string
-  ** literal argument to this pragma that contains a mnemonic description
-  ** of the options rather than a bitmap.
-  */
-  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 needed */
-    char *zSubSql;         /* SQL statement for the OP_SqlExec opcode */
-    u32 opMask;            /* Mask of operations to perform */
-    int nLimit;            /* Analysis limit to use */
-    int nCheck = 0;        /* Number of tables to be optimized */
-    int nBtree = 0;        /* Number of btrees to scan */
-    int nIndex;            /* Number of indexes on the current table */
-
-    if( zRight ){
-      opMask = (u32)sqlite3Atoi(zRight);
-      if( (opMask & 0x02)==0 ) break;
-    }else{
-      opMask = 0xfffe;
-    }
-    if( (opMask & 0x10)==0 ){
-      nLimit = 0;
-    }else if( db->nAnalysisLimit>0
-           && db->nAnalysisLimit<SQLITE_DEFAULT_OPTIMIZE_LIMIT ){
-      nLimit = 0;
-    }else{
-      nLimit = SQLITE_DEFAULT_OPTIMIZE_LIMIT;
-    }
-    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);
-
-        /* This only works for ordinary tables */
-        if( !IsOrdinaryTable(pTab) ) continue;
-
-        /* Do not scan system tables */
-        if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ) continue;
-
-        /* Find the size of the table as last recorded in sqlite_stat1.
-        ** If any index is unanalyzed, then the threshold is -1 to
-        ** indicate a new, unanalyzed index
-        */
-        szThreshold = pTab->nRowLogEst;
-        nIndex = 0;
-        for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
-          nIndex++;
-          if( !pIdx->hasStat1 ){
-            szThreshold = -1; /* Always analyze if any index lacks statistics */
-          }
-        }
-
-        /* If table pTab has not been used in a way that would benefit from
-        ** having analysis statistics during the current session, then skip it,
-        ** unless the 0x10000 MASK bit is set. */
-        if( (pTab->tabFlags & TF_MaybeReanalyze)!=0 ){
-          /* Check for size change if stat1 has been used for a query */
-        }else if( opMask & 0x10000 ){
-          /* Check for size change if 0x10000 is set */
-        }else if( pTab->pIndex!=0 && szThreshold<0 ){
-          /* Do analysis if unanalyzed indexes exists */
-        }else{
-          /* Otherwise, we can skip this table */
-          continue;
-        }
-
-        nCheck++;
-        if( nCheck==2 ){
-          /* If ANALYZE might be invoked two or more times, hold a write
-          ** transaction for efficiency */
-          sqlite3BeginWriteOperation(pParse, 0, iDb);
-        }
-        nBtree += nIndex+1;
-
-        /* Reanalyze if the table is 10 times larger or smaller than
-        ** the last analysis.  Unconditional reanalysis if there are
-        ** unanalyzed indexes. */
-        sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
-        if( szThreshold>=0 ){
-          const LogEst iRange = 33;   /* 10x size change */
-          sqlite3VdbeAddOp4Int(v, OP_IfSizeBetween, iTabCur,
-                         sqlite3VdbeCurrentAddr(v)+2+(opMask&1),
-                         szThreshold>=iRange ? szThreshold-iRange : -1,
-                         szThreshold+iRange);
-          VdbeCoverage(v);
-        }else{
-          sqlite3VdbeAddOp2(v, OP_Rewind, iTabCur,
-                         sqlite3VdbeCurrentAddr(v)+2+(opMask&1));
-          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, nLimit ? 0x02 : 00, nLimit, 0,
-                            zSubSql, P4_DYNAMIC);
-        }
-      }
-    }
-    sqlite3VdbeAddOp0(v, OP_Expire);
-
-    /* In a schema with a large number of tables and indexes, scale back
-    ** the analysis_limit to avoid excess run-time in the worst case.
-    */
-    if( !db->mallocFailed && nLimit>0 && nBtree>100 ){
-      int iAddr, iEnd;
-      VdbeOp *aOp;
-      nLimit = 100*nLimit/nBtree;
-      if( nLimit<100 ) nLimit = 100;
-      aOp = sqlite3VdbeGetOp(v, 0);
-      iEnd = sqlite3VdbeCurrentAddr(v);
-      for(iAddr=0; iAddr<iEnd; iAddr++){
-        if( aOp[iAddr].opcode==OP_SqlExec ) aOp[iAddr].p2 = nLimit;
-      }
-    }
-    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; i<db->nDb; 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
-
-#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; i<pPragma->nPragCName; 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; i<pIdxInfo->nConstraint; i++, pConstraint++){
-    if( pConstraint->iColumn < pTab->iHidden ) continue;
-    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
-    if( pConstraint->usable==0 ) return SQLITE_CONSTRAINT;
-    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;
-  pIdxInfo->estimatedCost = (double)20;
-  pIdxInfo->estimatedRows = 20;
-  if( seen[1] ){
-    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;
-  pCsr->iRowid = 0;
-  for(i=0; i<ArraySize(pCsr->azArg); 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; i<argc; i++, j++){
-    const char *zText = (const char*)sqlite3_value_text(argv[i]);
-    assert( j<ArraySize(pCsr->azArg) );
-    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( i<pTab->iHidden ){
-    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 */
-  0                            /* xIntegrity */
-};
-
-/*
-** 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",
-       "drop constraint"
-    };
-    *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 && iDb<db->nDb );
-  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 && iDb<db->nDb );
-  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; i<ArraySize(meta); i++){
-    sqlite3BtreeGetMeta(pDb->pBt, 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
-      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; iDb<db->nDb; 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( i<db->nDb );
-      if( db->aDb[i].pSchema==pSchema ){
-        break;
-      }
-    }
-    assert( i>=0 && i<db->nDb );
-  }
-  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;
-}
-
-/*
-** 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 mechanism (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;
-  if( sqlite3FaultSim(300) ){
-    pCleanup = 0;
-    sqlite3OomFault(pParse->db);
-  }else{
-    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;
-  if( pReprepare ){
-    sParse.pReprepare = pReprepare;
-    sParse.explain = sqlite3_stmt_isexplain((sqlite3_stmt*)pReprepare);
-  }else{
-    assert( sParse.pReprepare==0 );
-  }
-  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; i<db->nDb; 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;
-    cnt++;
-  }while( (rc==SQLITE_ERROR_RETRY && ALWAYS(cnt<=SQLITE_MAX_PREPARE_RETRY))
-       || (rc==SQLITE_SCHEMA && (sqlite3ResetOneSchema(db,-1), cnt)==1) );
-  sqlite3BtreeLeaveAll(db);
-  assert( rc!=SQLITE_ERROR_RETRY );
-  rc = sqlite3ApiExit(db, rc);
-  assert( (rc&db->errMask)==rc );
-  db->busyHandler.nBusy = 0;
-  sqlite3_mutex_leave(db->mutex);
-  assert( rc==SQLITE_OK || (*ppStmt)==0 );
-  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;
-  }
-
-  /* Make sure nBytes is non-negative and correct.  It should be the
-  ** number of bytes until the end of the input buffer or until the first
-  ** U+0000 character.  If the input nBytes is odd, convert it into
-  ** an even number.  If the input nBytes is negative, then the input
-  ** must be terminated by at least one U+0000 character */
-  if( nBytes>=0 ){
-    int sz;
-    const char *z = (const char*)zSql;
-    for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){}
-    nBytes = sz;
-  }else{
-    int sz;
-    const char *z = (const char*)zSql;
-    for(sz=0; z[sz]!=0 || z[sz+1]!=0; sz += 2){}
-    nBytes = sz;
-  }
-
-  sqlite3_mutex_enter(db->mutex);
-  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, nBytes, 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: DISTINCT  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->nSelectRow = 0;
-  if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, SZ_SRCLIST_1);
-  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);
-}
-SQLITE_PRIVATE void sqlite3SelectDeleteGeneric(sqlite3 *db, void *p){
-  if( ALWAYS(p) ) clearSelect(db, (Select*)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 nonsensical 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; j<ArraySize(aKeyword); j++){
-      if( p->n==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;
-  const Column *aCol;
-  int nCol;
-
-  h = sqlite3StrIHash(zCol);
-  aCol = pTab->aCol;
-  nCol = pTab->nCol;
-
-  /* See if the aHx gives us a lucky match */
-  i = pTab->aHx[h % sizeof(pTab->aHx)];
-  assert( i<nCol );
-  if( aCol[i].hName==h
-   && sqlite3StrICmp(aCol[i].zCnName, zCol)==0
-  ){
-    return i;
-  }
-
-  /* No lucky match from the hash table.  Do a full search. */
-  i = 0;
-  while( 1 /*exit-by-break*/ ){
-    if( aCol[i].hName==h
-     && sqlite3StrICmp(aCol[i].zCnName, zCol)==0
-    ){
-      return i;
-    }
-    i++;
-    if( i>=nCol ) break;
-  }
-  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) );
-  if( pItem->fg.isNestedFrom ){
-    ExprList *pResults;
-    assert( pItem->fg.isSubquery );
-    assert( pItem->u4.pSubq!=0 );
-    assert( pItem->u4.pSubq->pSelect!=0 );
-    pResults = pItem->u4.pSubq->pSelect->pEList;
-    assert( pResults!=0 );
-    assert( iCol>=0 && iCol<pResults->nExpr );
-    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].pSTab->aCol[] here */
-  int bIgnoreHidden    /* Ignore hidden columns */
-){
-  int i;               /* For looping over tables in pSrc */
-  int iCol;            /* Index of column matching zCol */
-
-  assert( iEnd<pSrc->nSrc );
-  assert( iStart>=0 );
-  assert( (piTab==0)==(piCol==0) );  /* Both or neither are NULL */
-
-  for(i=iStart; i<=iEnd; i++){
-    iCol = sqlite3ColumnIndex(pSrc->a[i].pSTab, zCol);
-    if( iCol>=0
-     && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pSTab->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( ExprUseXList(p) ){
-      if( p->x.pList ){
-        int i;
-        for(i=0; i<p->x.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) );
-      assert( p->pLeft==0 );
-      if( p->x.pList ){
-        int i;
-        for(i=0; i<p->x.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; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
-    Table *pRightTab = pRight->pSTab;
-    u32 joinType;
-
-    if( NEVER(pLeft->pSTab==0 || pRightTab==0) ) continue;
-    joinType = (pRight->fg.jointype & JT_OUTER)!=0 ? EP_OuterON : EP_InnerON;
-
-    /* If this is a NATURAL join, synthesize an appropriate 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; j<pRightTab->nCol; 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; j<pList->nId; 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 && pParse->nErr==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 };
-          assert( pE1!=0 );
-          ExprSetProperty(pE1, EP_CanBeNull);
-          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);
-            if( pE1 ){
-              pE1->affExpr = SQLITE_AFF_DEFER;
-            }
-          }
-        }else if( (pSrc->a[i+1].fg.jointype & JT_LEFT)!=0 && pParse->nErr==0 ){
-          assert( pE1!=0 );
-          ExprSetProperty(pE1, EP_CanBeNull);
-        }
-        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;
-      p->selFlags |= SF_OnToWhere;
-    }
-
-    if( IsVirtual(pRightTab) && joinType==EP_OuterON && pRight->u1.pFuncArg ){
-      p->selFlags |= SF_OnToWhere;
-    }
-  }
-  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 optimization.  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 sqlite3VdbeAddOp3() */
-    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 <expr>) ..."). 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 ephemeral
-**     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; i<nResultCol; i++){
-        CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
-        if( i<nResultCol-1 ){
-          sqlite3VdbeAddOp3(v, OP_Ne, regElem+i, iJump, regPrev+i);
-          VdbeCoverage(v);
-        }else{
-          sqlite3VdbeAddOp3(v, OP_Eq, regElem+i, addrRepeat, regPrev+i);
-          VdbeCoverage(v);
-         }
-        sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
-        sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
-      }
-      assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->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; i<pEList->nExpr; 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; j<nDefer; j++){
-          if( pSort->aDefer[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; k<nKey; k++){
-              Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0);
-              if( pNew ){
-                pNew->iTable = 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; i<nResultCol; i++){
-      sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
-      VdbeComment((v, "%s", p->pEList->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; i<pSort->pOrderBy->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; i<pEList->nExpr; 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 ){
-    /* 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);
-#if !defined(SQLITE_ENABLE_NULL_TRIM) && defined(SQLITE_DEBUG)
-      /* A destination of SRT_Table and a non-zero iSDParm2 parameter means
-      ** that this is an "UPDATE ... FROM" on a virtual table or view. In this
-      ** case set the p5 parameter of the OP_MakeRecord to OPFLAG_NOCHNG_MAGIC.
-      ** This does not affect operation in any way - it just allows MakeRecord
-      ** to process OPFLAG_NOCHANGE values without an assert() failing. */
-      if( eDest==SRT_Table && pDest->iSDParm2 ){
-        sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
-      }
-#endif
-#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);
-        pDest->iSDParm2 = 0; /* Signal that any Bloom filter is unpopulated */
-      }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);
-        if( pDest->iSDParm2 ){
-          sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pDest->iSDParm2, 0,
-                               regResult, nResultCol);
-          ExplainQueryPlan((pParse, 0, "CREATE BLOOM FILTER"));
-        }
-        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);
-        pDest->iSDParm = regResult;
-      }else{
-        assert( nResultCol==pDest->nSdst );
-        if( regResult!=iParm ){
-          /* This occurs in cases where the SELECT had both a DISTINCT and
-          ** an OFFSET clause.  */
-          sqlite3VdbeAddOp3(v, OP_Copy, regResult, iParm, nResultCol-1);
-        }
-        /* 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; i<nKey; i++){
-        sqlite3VdbeAddOp2(v, OP_SCopy,
-                          regResult + pSO->a[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);
-  KeyInfo *p;
-  assert( X>=0 );
-  if( NEVER(N+X>0xffff) ) return (KeyInfo*)sqlite3OomFault(db);
-  p = sqlite3DbMallocRawNN(db, SZ_KEYINFO(0) + 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->aColl, 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; i<nExpr; i++, pItem++){
-      pInfo->aColl[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
-
-  nKey = pOrderBy->nExpr - pSort->nOBSat;
-  if( pSort->nOBSat==0 || nKey==1 ){
-    ExplainQueryPlan2(addrExplain, (pParse, 0,
-      "USE TEMP B-TREE FOR %sORDER BY", pSort->nOBSat?"LAST TERM OF ":""
-    ));
-  }else{
-    ExplainQueryPlan2(addrExplain, (pParse, 0,
-      "USE TEMP B-TREE FOR LAST %d TERMS OF ORDER BY", nKey
-    ));
-  }
-  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; i<pSort->nDefer; 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);
-    }
-  }
-  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; i<nColumn; i++){
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    if( aOutEx[i].fg.bSorterRef ) continue;
-#endif
-    if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
-  }
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-  if( pSort->nDefer ){
-    int iKey = iCol+1;
-    int regKey = sqlite3GetTempRange(pParse, nRefKey);
-
-    for(i=0; i<pSort->nDefer; 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<nKey; k++){
-          sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey+k);
-        }
-        iJmp = sqlite3VdbeCurrentAddr(v);
-        sqlite3VdbeAddOp4Int(v, OP_SeekGE, iCsr, iJmp+2, regKey, nKey);
-        sqlite3VdbeAddOp4Int(v, OP_IdxLE, iCsr, iJmp+3, regKey, nKey);
-        sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
-      }
-    }
-    sqlite3ReleaseTempRange(pParse, regKey, nRefKey);
-  }
-#endif
-  for(i=nColumn-1; i>=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;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
-        if( j<pTabList->nSrc ){
-          pTab = pTabList->a[j].pSTab;
-          if( pTabList->a[j].fg.isSubquery ){
-            pS = pTabList->a[j].u4.pSubq->pSelect;
-          }else{
-            pS = 0;
-          }
-        }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( iCol<pS->pEList->nExpr
-         && (!ViewCanHaveRowid || iCol>=0)
-        ){
-          /* 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 && iCol<pTab->nCol) );
-        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 && iCol<pTab->nCol) );
-        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; i<pEList->nExpr; 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);
-  }
-#else
-  UNUSED_PARAMETER(pParse);
-  UNUSED_PARAMETER(pTabList);
-  UNUSED_PARAMETER(pEList);
-#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 */
-
-  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; i<pEList->nExpr; 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 && iCol<pTab->nCol) );
-      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; i<nCol && !pParse->nErr; 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 <name>" phrase, use <name> 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; j<i; j++){
-      sqlite3DbFree(db, aCol[j].zCnName);
-    }
-    sqlite3DbFree(db, aCol);
-    *paCol = 0;
-    *pnCol = 0;
-    return pParse->rc;
-  }
-  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 information" 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; i<pTab->nCol; i++, pCol++){
-    const char *zType;
-    i64 n;
-    int m = 0;
-    Select *pS2 = pSelect;
-    pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT);
-    p = a[i].pExpr;
-    /* pCol->szEst = ... // Column size est for SELECT tables never used */
-    pCol->affinity = sqlite3ExprAffinity(p);
-    while( pCol->affinity<=SQLITE_AFF_NONE && pS2->pNext!=0 ){
-      m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
-      pS2 = pS2->pNext;
-      pCol->affinity = sqlite3ExprAffinity(pS2->pEList->a[i].pExpr);
-    }
-    if( pCol->affinity<=SQLITE_AFF_NONE ){
-      pCol->affinity = aff;
-    }
-    if( pCol->affinity>=SQLITE_AFF_TEXT && (pS2->pNext || pS2!=pSelect) ){
-      for(pS2=pS2->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; j<SQLITE_N_STDTYPE; j++){
-          if( sqlite3StdTypeAffinity[j]==pCol->affinity ){
-            zType = sqlite3StdType[j];
-            break;
-          }
-        }
-      }
-    }
-    if( zType ){
-      const i64 k = strlen(zType);
-      n = strlen(pCol->zCnName);
-      pCol->zCnName = sqlite3DbReallocOrFree(db, pCol->zCnName, n+k+2);
-      pCol->colFlags &= ~(COLFLAG_HASTYPE|COLFLAG_HASCOLL);
-      if( pCol->zCnName ){
-        memcpy(&pCol->zCnName[n+1], zType, k+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, pParse) ){
-      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(iCol<p->pEList->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 *multiSelectByMergeKeyInfo(Parse *pParse, Select *p, int nExtra){
-  ExprList *pOrderBy = p->pOrderBy;
-  int nOrderBy = (pOrderBy!=0) ? pOrderBy->nExpr : 0;
-  sqlite3 *db = pParse->db;
-  KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1);
-  if( pRet ){
-    int i;
-    for(i=0; i<nOrderBy; i++){
-      struct ExprList_item *pItem = &pOrderBy->a[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:
-**
-**   <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>)
-**                         \___________/             \_______________/
-**                           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 targeting 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(i<pSrc->nSrc); 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 = multiSelectByMergeKeyInfo(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 ){
-    /* Generate an ephemeral table used to enforce distinctness on the
-    ** output of the recursive part of the CTE.
-    */
-    KeyInfo *pKeyInfo;            /* Collating sequence for the result set */
-    CollSeq **apColl;             /* For looping through pKeyInfo->aColl[] */
-
-    assert( p->pNext==0 );
-    assert( p->pEList!=0 );
-    nCol = p->pEList->nExpr;
-    pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nCol, 1);
-    if( pKeyInfo ){
-      for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
-        *apColl = multiSelectCollSeq(pParse, p, i);
-        if( 0==*apColl ){
-          *apColl = pParse->db->pDfltColl;
-        }
-      }
-      sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iDistinct, nCol, 0,
-                           (void*)pKeyInfo, P4_KEYINFO);
-    }else{
-      assert( pParse->nErr>0 );
-    }
-  }
-
-  /* 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 multiSelectByMerge(
-  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
-  if( p->pOrderBy ){
-    /* If the compound has an ORDER BY clause, then always use the merge
-    ** algorithm. */
-    return multiSelectByMerge(pParse, p, pDest);
-  }else if( p->op!=TK_ALL ){
-    /* If the compound is EXCEPT, INTERSECT, or UNION (anything other than
-    ** UNION ALL) then also always use the merge algorithm.  However, the
-    ** multiSelectByMerge() routine requires that the compound have an
-    ** ORDER BY clause, and it doesn't right now.  So invent one first. */
-    Expr *pOne = sqlite3ExprInt32(db, 1);
-    p->pOrderBy = sqlite3ExprListAppend(pParse, 0, pOne);
-    if( pParse->nErr ) goto multi_select_end;
-    assert( p->pOrderBy!=0 );
-    p->pOrderBy->a[0].u.x.iOrderByCol = 1;
-    return multiSelectByMerge(pParse, p, pDest);
-  }else{
-    /* For a UNION ALL compound without ORDER BY, simply run the left
-    ** query, then run the right query */
-    int addr = 0;
-    int nLimit = 0;  /* Initialize to suppress harmless compiler warning */
-
-#ifndef SQLITE_OMIT_EXPLAIN
-    if( pPrior->pPrior==0 ){
-      ExplainQueryPlan((pParse, 1, "COMPOUND QUERY"));
-      ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY"));
-    }
-#endif
-    assert( !pPrior->pLimit );
-    pPrior->iLimit = p->iLimit;
-    pPrior->iOffset = p->iOffset;
-    pPrior->pLimit = sqlite3ExprDup(db, p->pLimit, 0);
-    TREETRACE(0x200, pParse, p, ("multiSelect UNION ALL left...\n"));
-    rc = sqlite3Select(pParse, pPrior, &dest);
-    sqlite3ExprDelete(db, pPrior->pLimit);
-    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, pParse)
-     && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit)
-    ){
-      p->nSelectRow = sqlite3LogEst((u64)nLimit);
-    }
-    if( addr ){
-      sqlite3VdbeJumpHere(v, addr);
-    }
-#ifndef SQLITE_OMIT_EXPLAIN
-    if( p->pNext==0 ){
-      ExplainQueryPlanPop(pParse);
-    }
-#endif
-  }
-
-multi_select_end:
-  pDest->iSdst = dest.iSdst;
-  pDest->nSdst = dest.nSdst;
-  pDest->iSDParm2 = dest.iSDParm2;
-  if( pDelete ){
-    sqlite3ParserAddCleanup(pParse, sqlite3SelectDeleteGeneric, 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 statement.
-**
-** The data to be output is contained in an array of pIn->nSdst registers
-** starting at register pIn->iSdst.  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;
-
-  assert( pIn->eDest==SRT_Coroutine );
-
-  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);
-
-  switch( pDest->eDest ){
-    /* Store the result as data using a unique key.
-    */
-    case SRT_Fifo:
-    case SRT_DistFifo:
-    case SRT_Table:
-    case SRT_EphemTab: {
-      int r1 = sqlite3GetTempReg(pParse);
-      int r2 = sqlite3GetTempReg(pParse);
-      int iParm = pDest->iSDParm;
-      testcase( pDest->eDest==SRT_Table );
-      testcase( pDest->eDest==SRT_EphemTab );
-      testcase( pDest->eDest==SRT_Fifo );
-      testcase( pDest->eDest==SRT_DistFifo );
-      sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1);
-#if !defined(SQLITE_ENABLE_NULL_TRIM) && defined(SQLITE_DEBUG)
-      /* A destination of SRT_Table and a non-zero iSDParm2 parameter means
-      ** that this is an "UPDATE ... FROM" on a virtual table or view. In this
-      ** case set the p5 parameter of the OP_MakeRecord to OPFLAG_NOCHNG_MAGIC.
-      ** This does not affect operation in any way - it just allows MakeRecord
-      ** to process OPFLAG_NOCHANGE values without an assert() failing. */
-      if( pDest->eDest==SRT_Table && pDest->iSDParm2 ){
-        sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
-      }
-#endif
-#ifndef SQLITE_OMIT_CTE
-      if( pDest->eDest==SRT_DistFifo ){
-        /* If the destination is DistFifo, then cursor (iParm+1) is open
-        ** on an ephemeral index that is used to enforce uniqueness on the
-        ** total result.  At this point, we are processing the setup portion
-        ** of the recursive CTE using the merge algorithm, so the results are
-        ** guaranteed to be unique anyhow.  But we still need to populate the
-        ** (iParm+1) cursor for use by the subsequent recursive phase.
-        */
-        sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,
-                             pIn->iSdst, pIn->nSdst);
-      }
-#endif
-      sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
-      sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
-      sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
-      sqlite3ReleaseTempReg(pParse, r2);
-      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, pDest->iSDParm);
-      /* The LIMIT clause will terminate the loop for us */
-      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);
-      if( pDest->iSDParm2>0 ){
-        sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pDest->iSDParm2, 0,
-                             pIn->iSdst, pIn->nSdst);
-        ExplainQueryPlan((pParse, 0, "CREATE BLOOM FILTER"));
-      }
-      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;
-    }
-
-#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, ii;
-      ExprList *pSO;
-      int iParm = pDest->iSDParm;
-      pSO = pDest->pOrderBy;
-      assert( pSO );
-      nKey = pSO->nExpr;
-      r1 = sqlite3GetTempReg(pParse);
-      r2 = sqlite3GetTempRange(pParse, nKey+2);
-      r3 = r2+nKey+1;
-
-      sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r3);
-      if( pDest->eDest==SRT_DistQueue ){
-        sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3);
-      }
-      for(ii=0; ii<nKey; ii++){
-        sqlite3VdbeAddOp2(v, OP_SCopy,
-                          pIn->iSdst + pSO->a[ii].u.x.iOrderByCol - 1,
-                          r2+ii);
-      }
-      sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey);
-      sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1);
-      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2);
-      sqlite3ReleaseTempReg(pParse, r1);
-      sqlite3ReleaseTempRange(pParse, r2, nKey+2);
-      break;
-    }
-#endif /* SQLITE_OMIT_CTE */
-
-    /* Ignore the output */
-    case SRT_Discard: {
-      break;
-    }
-
-    /* If none of the above, then the result destination must be
-    ** 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;
-}
-
-/*
-** Generate code for a compound SELECT statement using a merge
-** algorithm.  The compound must have an ORDER BY clause for this
-** to work.
-**
-** We assume a query of the following form:
-**
-**      <selectA>  <operator>  <selectB>  ORDER BY <orderbylist>
-**
-** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT.  The idea
-** is to code both <selectA> and <selectB> 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 INTERSECT never output a row that
-**             appears only in B.)
-**
-**    AltB:    Called when there is data from both coroutines and A<B.
-**
-**    AeqB:    Called when there is data from both coroutines and A==B.
-**
-**    AgtB:    Called when there is data from both coroutines and A>B.
-**
-**    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
-** <operator> 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, on eof goto EofA
-**          yield coB, on eof 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" label.  AltB, AeqB,
-** and AgtB jump to either Cmpr or to one of EofA or EofB.
-*/
-#ifndef SQLITE_OMIT_COMPOUND_SELECT
-static int multiSelectByMerge(
-  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 A<B subroutine */
-  int addrAeqB;         /* Address of the A==B subroutine */
-  int addrAgtB;         /* Address of the A>B 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 retargeted */
-  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; j<nOrderBy; j++, pItem++){
-        assert( pItem!=0 );
-        assert( pItem->u.x.iOrderByCol>0 );
-        if( pItem->u.x.iOrderByCol==i ) break;
-      }
-      if( j==nOrderBy ){
-        Expr *pNew = sqlite3ExprInt32(db, i);
-        if( pNew==0 ) return SQLITE_NOMEM_BKPT;
-        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 to determine if the next row of results comes
-  ** from selectA or selectB.  Also add literal collations to the
-  ** ORDER BY clause terms so that when selectA and selectB are
-  ** evaluated, they use the correct collation.
-  */
-  aPermute = sqlite3DbMallocRawNN(db, sizeof(u32)*(nOrderBy + 1));
-  if( aPermute ){
-    struct ExprList_item *pItem;
-    int bKeep = 0;
-    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;
-      if( aPermute[i]!=(u32)i-1 ) bKeep = 1;
-    }
-     if( bKeep==0 ){
-      sqlite3DbFreeNN(db, aPermute);
-      aPermute = 0;
-    }
-  }
-  pKeyMerge = multiSelectByMergeKeyInfo(pParse, p, 1);
-
-  /* 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; i<nExpr; i++){
-        pKeyDup->aColl[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; i<nSelect; i+=2){ pSplit = pSplit->pPrior; }
-  }
-  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, "SUBR: next-A"));
-  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, "SUBR: next-B"));
-  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, "SUBR: out-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, "SUBR: out-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, "SUBR: eof-A"));
-    addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
-    VdbeComment((v, "out-B"));
-    addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd);
-                                     VdbeCoverage(v);
-    VdbeComment((v, "next-B"));
-    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, "SUBR: eof-B"));
-    addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
-    VdbeComment((v, "out-A"));
-    sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v);
-    VdbeComment((v, "next-A"));
-    sqlite3VdbeGoto(v, addrEofB);
-  }
-
-  /* Generate code to handle the case of A<B
-  */
-  addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
-  VdbeComment((v, "out-A"));
-  sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
-  VdbeComment((v, "next-A"));
-  sqlite3VdbeGoto(v, labelCmpr);
-
-  /* Generate code to handle the case of A==B
-  */
-  if( op==TK_ALL ){
-    addrAeqB = addrAltB;
-  }else if( op==TK_INTERSECT ){
-    addrAeqB = addrAltB;
-    addrAltB++;
-  }else{
-    addrAeqB = addrAltB + 1;
-  }
-
-  /* Generate code to handle the case of A>B
-  */
-  addrAgtB = sqlite3VdbeCurrentAddr(v);
-  if( op==TK_ALL || op==TK_UNION ){
-    sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
-    VdbeComment((v, "out-B"));
-    sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
-    VdbeComment((v, "next-B"));
-    sqlite3VdbeGoto(v, labelCmpr);
-  }else{
-    addrAgtB++; /* Just do next-B.  Might as well use the next-B call
-                ** in the next code block */
-  }
-
-  /* This code runs once to initialize everything.
-  */
-  sqlite3VdbeJumpHere(v, addr1);
-  sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v);
-  VdbeComment((v, "next-A"));
-  /* v---  Also the A>B case for EXCEPT and INTERSECT */
-  sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
-  VdbeComment((v, "next-B"));
-
-  /* Implement the main merge loop
-  */
-  if( aPermute!=0 ){
-    sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
-  }
-  sqlite3VdbeResolveLabel(v, labelCmpr);
-  sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
-                         (char*)pKeyMerge, P4_KEYINFO);
-  if( aPermute!=0 ){
-    sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
-  }
-  sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB);
-  VdbeCoverageIf(v, op==TK_ALL);
-  VdbeCoverageIf(v, op==TK_UNION);
-  VdbeCoverageIf(v, op==TK_EXCEPT);
-  VdbeCoverageIf(v, op==TK_INTERSECT);
-
-  /* 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, sqlite3SelectDeleteGeneric, 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 is 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 */
-  int nSelDepth;            /* Depth of sub-query recursion.  Top==1 */
-  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;
-      Expr *pCopy;
-      Expr ifNullRow;
-      iColumn = pExpr->iColumn;
-      assert( iColumn>=0 );
-      assert( pSubst->pEList!=0 && iColumn<pSubst->pEList->nExpr );
-      assert( pExpr->pRight==0 );
-      pCopy = pSubst->pEList->a[iColumn].pExpr;
-      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( pNew->op==TK_TRUEFALSE ){
-          pNew->u.iValue = sqlite3ExprTruthValue(pNew);
-          pNew->op = TK_INTEGER;
-          ExprSetProperty(pNew, 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, pNew);
-          CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse,
-                pSubst->pCList->a[iColumn].pExpr
-          );
-          if( pNat!=pColl || (pNew->op!=TK_COLUMN && pNew->op!=TK_COLLATE) ){
-            pNew = sqlite3ExprAddCollateString(pSubst->pParse, pNew,
-                (pColl ? pColl->zName : "BINARY")
-            );
-          }
-        }
-        ExprClearProperty(pNew, EP_Collate);
-        if( ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) ){
-          sqlite3SetJoinExpr(pNew, pExpr->w.iJoin,
-                             pExpr->flags & (EP_OuterON|EP_InnerON));
-        }
-        sqlite3ExprDelete(db, pExpr);
-        pExpr = pNew;
-      }
-    }
-  }else{
-    if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
-      pExpr->iTable = pSubst->iNewTable;
-    }
-    if( pExpr->op==TK_AGG_FUNCTION && pExpr->op2>=pSubst->nSelDepth ){
-      pExpr->op2--;
-    }
-    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; i<pList->nExpr; 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;
-  pSubst->nSelDepth++;
-  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++){
-      if( pItem->fg.isSubquery ){
-        substSelect(pSubst, pItem->u4.pSubq->pSelect, 1);
-      }
-      if( pItem->fg.isTabFunc ){
-        substExprList(pSubst, pItem->u1.pFuncArg);
-      }
-    }
-  }while( doPrior && (p = p->pPrior)!=0 );
-  pSubst->nSelDepth--;
-}
-#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->pSTab==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; i<pSrc->nSrc; 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];
-      if( pItem->fg.isSubquery ){
-        for(p=pItem->u4.pSubq->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; ii<pList->nExpr; 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
-**        (**) Was (3b): "the FROM clause of the subquery may not contain
-**             a virtual table"
-**        (**) 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
-**        accidentally 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.  (This is handled
-**        in the caller before ever reaching this routine.)
-**
-**
-** 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 && iFrom<pSrc->nSrc );
-  pSubitem = &pSrc->a[iFrom];
-  iParent = pSubitem->iCursor;
-  assert( pSubitem->fg.isSubquery );
-  pSub = pSubitem->u4.pSubq->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].pSTab)      (3b)-omitted */
-     || (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) */
-  }
-
-  /* Condition (28) is blocked by the caller */
-  assert( !pSubitem->fg.isCte || pSubitem->u2.pCteUse->eM10d!=M10d_Yes );
-
-  /* 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; ii<p->pOrderBy->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 the subquery */
-
-  if( ALWAYS(pSubitem->fg.isSubquery) ){
-    pSub1 = sqlite3SubqueryDetach(db, pSubitem);
-  }else{
-    pSub1 = 0;
-  }
-  assert( pSubitem->fg.isSubquery==0 );
-  assert( pSubitem->fg.fixedSchema==0 );
-  sqlite3DbFree(db, pSubitem->zName);
-  sqlite3DbFree(db, pSubitem->zAlias);
-  pSubitem->zName = 0;
-  pSubitem->zAlias = 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 <expr-list> FROM (<sub-query>) <where-clause>
-  **
-  ** 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->pSTab;
-    pSubitem->pSTab = 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->pSTab = 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->fg.isSubquery==0 );
-  }
-  sqlite3DbFree(db, aCsrMap);
-  if( db->mallocFailed ){
-    assert( pSubitem->fg.fixedSchema==0 );
-    assert( pSubitem->fg.isSubquery==0 );
-    assert( pSubitem->u4.zDatabase==0 );
-    sqlite3SrcItemAttachSubquery(pParse, pSubitem, pSub1, 0);
-    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->pSTab is always non-NULL by test restrictions and tests above.
-  */
-  if( ALWAYS(pSubitem->pSTab!=0) ){
-    Table *pTabToDel = pSubitem->pSTab;
-    if( pTabToDel->nTabRef==1 ){
-      Parse *pToplevel = sqlite3ParseToplevel(pParse);
-      sqlite3ParserAddCleanup(pToplevel, sqlite3DeleteTableGeneric, pTabToDel);
-      testcase( pToplevel->earlyCleanup );
-    }else{
-      pTabToDel->nTabRef--;
-    }
-    pSubitem->pSTab = 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 = pSubitem->fg.jointype;
-    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 */
-
-    /* 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;
-      pSubitem = &pSrc->a[iFrom];
-    }
-
-    /* Transfer the FROM clause terms from the subquery into the
-    ** outer query.
-    */
-    iNewParent = pSubSrc->a[0].iCursor;
-    for(i=0; i<nSubSrc; i++){
-      SrcItem *pItem = &pSrc->a[i+iFrom];
-      assert( pItem->fg.isTabFunc==0 );
-      assert( pItem->fg.isSubquery
-           || pItem->fg.fixedSchema
-           || pItem->u4.zDatabase==0 );
-      if( pItem->fg.isUsing ) sqlite3IdListDelete(db, pItem->u3.pUsing);
-      *pItem = pSubSrc->a[i];
-      pItem->fg.jointype |= (jointype & JT_LTORJ);
-      memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
-    }
-    pSubitem->fg.jointype |= jointype;
-
-    /* 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 ){
-      /* 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 transferring 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.
-      ** See ticket [d11a6e908f].
-      */
-      ExprList *pOrderBy = pSub->pOrderBy;
-      for(i=0; i<pOrderBy->nExpr; 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 ){
-      assert( pSubSrc->nSrc==1 );
-      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.nSelDepth = 0;
-      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; i<nSubSrc; i++){
-      recomputeColumnsUsed(pParent, &pSrc->a[i+iFrom]);
-    }
-  }
-
-  /* Finally, 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 entries.  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(pConst->pParse, 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; i<pConst->nConst; 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. */
-    }
-  }
-  assert( SQLITE_AFF_NONE<SQLITE_AFF_BLOB );
-  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(pConst->pParse, pLeft) ){
-    constInsert(pConst,pRight,pLeft,pExpr);
-  }
-  if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, 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; i<pConst->nConst; i++){
-    Expr *pColumn = pConst->apExpr[i*2];
-    if( pColumn==pExpr ) continue;
-    if( pColumn->iTable!=pExpr->iTable ) continue;
-    if( pColumn->iColumn!=pExpr->iColumn ) continue;
-    assert( SQLITE_AFF_NONE<SQLITE_AFF_BLOB );
-    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 always 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 clause.
-*/
-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.
-**
-** NAME AMBIGUITY
-**
-** This optimization is called the "WHERE-clause push-down optimization"
-** or sometimes the "predicate push-down optimization".
-**
-** Do not confuse this optimization with another unrelated optimization
-** with a similar name:  The "MySQL push-down optimization" causes WHERE
-** clause terms that can be evaluated using only the index and without
-** reference to the table are run first, so that if they are false,
-** unnecessary table seeks are avoided.
-**
-** RULES
-**
-** 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 WHERE-clause 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
-**
-**  (12) The WHERE clause is not "rowid ISNULL" or the equivalent.  This
-**       case only comes up if SQLite is compiled using
-**       SQLITE_ALLOW_ROWID_IN_VIEW.
-**
-** 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; ii<pList->nExpr; 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; jj<iSrc; jj++){
-      if( pWhere->w.iJoin==pSrcList->a[jj].iCursor ){
-        /* If we reach this point, both (9a) and (9b) are satisfied.
-        ** The following loop checks (9c):
-        */
-        for(jj++; jj<iSrc; jj++){
-          if( (pSrcList->a[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
-
-#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
-  if( ViewCanHaveRowid && (pWhere->op==TK_ISNULL || pWhere->op==TK_NOTNULL) ){
-    Expr *pLeft = pWhere->pLeft;
-    if( ALWAYS(pLeft)
-     && pLeft->op==TK_COLUMN
-     && pLeft->iColumn < 0
-    ){
-      return 0;  /* Restriction (12) */
-    }
-  }
-#endif
-
-  if( sqlite3ExprIsSingleTableConstraint(pWhere, pSrcList, iSrc, 1) ){
-    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.nSelDepth = 0;
-      x.pEList = pSubq->pEList;
-      x.pCList = findLeftmostExprlist(pSubq);
-      pNew = substExpr(&x, pNew);
-      assert( pNew!=0 || pParse->nErr!=0 );
-      if( pParse->nErr==0 && pNew->op==TK_IN && ExprUseXSelect(pNew) ){
-        assert( pNew->x.pSelect!=0 );
-        pNew->x.pSelect->selFlags |= SF_ClonedRhsIn;
-        assert( pWhere!=0 );
-        assert( pWhere->op==TK_IN );
-        assert( ExprUseXSelect(pWhere) );
-        assert( pWhere->x.pSelect!=0 );
-        pWhere->x.pSelect->selFlags |= SF_ClonedRhsIn;
-      }
-#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->pSTab!=0 );
-  pTab = pItem->pSTab;
-  assert( pItem->fg.isSubquery );
-  pSub = pItem->u4.pSubq->pSelect;
-  assert( pSub->pEList->nExpr==pTab->nCol );
-  for(pX=pSub; pX; pX=pX->pPrior){
-    if( (pX->selFlags & (SF_Distinct|SF_Aggregate))!=0 ){
-      testcase( pX->selFlags & SF_Distinct );
-      testcase( pX->selFlags & SF_Aggregate );
-      return 0;
-    }
-    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; j<pList->nExpr; 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; j<nCol; j++){
-    Bitmask m = j<BMS-1 ? MASKBIT(j) : TOPBIT;
-    if( (m & colUsed)!=0 ) continue;
-    for(pX=pSub; pX; pX=pX->pPrior) {
-      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 <tbl>
-**
-** 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
-** <tbl> 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].fg.isSubquery
-   || pAggInfo->nFunc!=1
-   || p->pHaving
-  ){
-    return 0;
-  }
-  pTab = p->pSrc->a[0].pSTab;
-  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->pSTab;
-  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 multiSelectByMerge() 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://sqlite.org/src/info/6709574d2a
-**
-** This transformation is only needed for EXCEPT, INTERSECT, and UNION.
-** The UNION ALL operator works fine with multiSelectByMerge() 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);
-  assert( pNewSrc!=0 || pParse->nErr );
-  if( pParse->nErr ){
-    sqlite3SrcListDelete(db, pNewSrc);
-    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 &= ~(u32)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->fg.fixedSchema || pItem->u4.zDatabase==0 );
-  assert( zName!=0 );
-  for(p=pWith; p; p=p->pOuter){
-    int i;
-    for(i=0; i<p->nCte; 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, sqlite3WithDeleteGeneric,
-                      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->pSTab
-** 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->pSTab==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;
-  }
-  assert( pFrom->fg.hadSchema==0 || pFrom->fg.notCte!=0 );
-  if( pFrom->fg.fixedSchema==0 && pFrom->u4.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->pSTab==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->pSTab = 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;
-    sqlite3SrcItemAttachSubquery(pParse, pFrom, pCte->pSelect, 1);
-    if( db->mallocFailed ) return 2;
-    assert( pFrom->fg.isSubquery && pFrom->u4.pSubq );
-    pSel = pFrom->u4.pSubq->pSelect;
-    assert( pSel!=0 );
-    pSel->selFlags |= SF_CopyCte;
-    if( pFrom->fg.isIndexedBy ){
-      sqlite3ErrorMsg(pParse, "no such index: \"%s\"", pFrom->u1.zIndexedBy);
-      return 2;
-    }
-    assert( !pFrom->fg.isIndexedBy );
-    pFrom->fg.isCte = 1;
-    pFrom->u2.pCteUse = pCteUse;
-    pCteUse->nUse++;
-
-    /* Check if this is a recursive CTE. */
-    pRecTerm = pSel;
-    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; i<pSrc->nSrc; i++){
-        SrcItem *pItem = &pSrc->a[i];
-        if( pItem->zName!=0
-         && !pItem->fg.hadSchema
-         && ALWAYS( !pItem->fg.isSubquery )
-         && (pItem->fg.fixedSchema || pItem->u4.zDatabase==0)
-         && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
-        ){
-          pItem->pSTab = 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;
-  Table *pTab;
-
-  assert( pFrom->fg.isSubquery );
-  assert( pFrom->u4.pSubq!=0 );
-  pSel = pFrom->u4.pSubq->pSelect;
-  assert( pSel );
-  pFrom->pSTab = 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->eTabType = TABTYP_VIEW;
-  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
-  /* Legacy compatibility mode */
-  pTab->tabFlags |= TF_Ephemeral | sqlite3Config.mNoVisibleRowid;
-#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, SZ_WITH(1) );
-      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; i<pTabList->nSrc; i++, pFrom++){
-    Table *pTab;
-    assert( pFrom->fg.isRecursive==0 || pFrom->pSTab!=0 );
-    if( pFrom->pSTab ) continue;
-    assert( pFrom->fg.isRecursive==0 );
-    if( pFrom->zName==0 ){
-#ifndef SQLITE_OMIT_SUBQUERY
-      Select *pSel;
-      assert( pFrom->fg.isSubquery && pFrom->u4.pSubq!=0 );
-      pSel = pFrom->u4.pSubq->pSelect;
-      /* A sub-query in the FROM clause of a SELECT */
-      assert( pSel!=0 );
-      assert( pFrom->pSTab==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->pSTab;
-      assert( pTab!=0 );
-#endif
-    }else{
-      /* An ordinary table or view name in the FROM clause */
-      assert( pFrom->pSTab==0 );
-      pFrom->pSTab = 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->pSTab = 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->fg.isSubquery==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);
-          }
-          sqlite3SrcItemAttachSubquery(pParse, pFrom, pTab->u.view.pSelect, 1);
-        }
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-        else if( ALWAYS(IsVirtual(pTab))
-         && (pFrom->fg.fromDDL || (pParse->prepFlags & SQLITE_PREPARE_FROM_DDL))
-         && 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 */
-        if( pFrom->fg.isSubquery ){
-          sqlite3WalkSelect(pWalker, pFrom->u4.pSubq->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; k<pEList->nExpr; 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( k<pEList->nExpr ){
-    /*
-    ** 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; k<pEList->nExpr; 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 */
-        int iErrOfst;
-        if( pE->op==TK_DOT ){
-          assert( (selFlags & SF_NestedFrom)==0 );
-          assert( pE->pLeft!=0 );
-          assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
-          zTName = pE->pLeft->u.zToken;
-          assert( ExprUseWOfst(pE->pLeft) );
-          iErrOfst = pE->pRight->w.iOfst;
-        }else{
-          assert( ExprUseWOfst(pE) );
-          iErrOfst = pE->w.iOfst;
-        }
-        for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
-          int nAdd;                    /* Number of cols including rowid */
-          Table *pTab = pFrom->pSTab;  /* 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) );
-          if( pFrom->fg.isNestedFrom ){
-            assert( pFrom->fg.isSubquery && pFrom->u4.pSubq );
-            assert( pFrom->u4.pSubq->pSelect!=0 );
-            pNestedFrom = pFrom->u4.pSubq->pSelect->pEList;
-            assert( pNestedFrom!=0 );
-            assert( pNestedFrom->nExpr==pTab->nCol );
-            assert( VisibleRowid(pTab)==0 || ViewCanHaveRowid );
-          }else{
-            if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){
-              continue;
-            }
-            pNestedFrom = 0;
-            iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-            zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
-          }
-          if( i+1<pTabList->nSrc
-           && pFrom[1].fg.isUsing
-           && (selFlags & SF_NestedFrom)!=0
-          ){
-            int ii;
-            pUsing = pFrom[1].u3.pUsing;
-            for(ii=0; ii<pUsing->nId; ii++){
-              const char *zUName = pUsing->a[ii].zName;
-              pRight = sqlite3Expr(db, TK_ID, zUName);
-              sqlite3ExprSetErrorOffset(pRight, iErrOfst);
-              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;
-          }
-
-          nAdd = pTab->nCol;
-          if( VisibleRowid(pTab) && (selFlags & SF_NestedFrom)!=0 ) nAdd++;
-          for(j=0; j<nAdd; j++){
-            const char *zName;
-            struct ExprList_item *pX; /* Newly added ExprList term */
-
-            if( j==pTab->nCol ){
-              zName = sqlite3RowidAlias(pTab);
-              if( zName==0 ) continue;
-            }else{
-              zName = pTab->aCol[j].zCnName;
-
-              /* If pTab is actually an SF_NestedFrom sub-select, do not
-              ** expand any ENAME_ROWID columns.  */
-              if( pNestedFrom && pNestedFrom->a[j].fg.eEName==ENAME_ROWID ){
-                continue;
-              }
-
-              if( zTName
-               && pNestedFrom
-               && sqlite3MatchEName(&pNestedFrom->a[j], 0, zTName, 0, 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;
-              }
-            }
-            assert( zName );
-            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;
-            }
-            sqlite3ExprSetErrorOffset(pExpr, iErrOfst);
-            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 && (!ViewCanHaveRowid || j<pNestedFrom->nExpr) ){
-                assert( j<pNestedFrom->nExpr );
-                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 = (j==pTab->nCol ? ENAME_ROWID : ENAME_TAB);
-              if( (pFrom->fg.isUsing
-                   && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0)
-               || (pUsing && sqlite3IdListIndex(pUsing, zName)>=0)
-               || (j<pTab->nCol && (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND))
-              ){
-                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;
-
-  if( p->selFlags & SF_HasTypeInfo ) return;
-  p->selFlags |= SF_HasTypeInfo;
-  pParse = pWalker->pParse;
-  assert( (p->selFlags & SF_Resolved) );
-  pTabList = p->pSrc;
-  for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
-    Table *pTab = pFrom->pSTab;
-    assert( pTab!=0 );
-    if( (pTab->tabFlags & TF_Ephemeral)!=0 && pFrom->fg.isSubquery ){
-      /* A sub-query in the FROM clause of a SELECT */
-      Select *pSel = pFrom->u4.pSubq->pSelect;
-      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;
-  sqlite3DebugPrintf("AggInfo %d/%p:\n",
-     pAggInfo->selId, pAggInfo);
-  for(ii=0; ii<pAggInfo->nColumn; 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; ii<pAggInfo->nFunc; 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; i<pAggInfo->nFunc; i++){
-    Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
-    assert( pExpr->op==TK_FUNCTION || pExpr->op==TK_AGG_FUNCTION );
-    assert( ExprUseXList(pExpr) );
-    sqlite3ExprAnalyzeAggList(pNC, pExpr->x.pList);
-    if( pExpr->pLeft ){
-      assert( pExpr->pLeft->op==TK_ORDER );
-      assert( ExprUseXList(pExpr->pLeft) );
-      sqlite3ExprAnalyzeAggList(pNC, pExpr->pLeft->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; j<pAggInfo->nColumn; 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|EP_Unlikely);
-  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; i<pAggInfo->nFunc; 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 calling 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; i<pAggInfo->nFunc; 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));
-      }
-    }
-    if( pFunc->iOBTab>=0 ){
-      ExprList *pOBList;
-      KeyInfo *pKeyInfo;
-      int nExtra = 0;
-      assert( pFunc->pFExpr->pLeft!=0 );
-      assert( pFunc->pFExpr->pLeft->op==TK_ORDER );
-      assert( ExprUseXList(pFunc->pFExpr->pLeft) );
-      assert( pFunc->pFunc!=0 );
-      pOBList = pFunc->pFExpr->pLeft->x.pList;
-      if( !pFunc->bOBUnique ){
-        nExtra++;  /* One extra column for the OP_Sequence */
-      }
-      if( pFunc->bOBPayload ){
-        /* extra columns for the function arguments */
-        assert( ExprUseXList(pFunc->pFExpr) );
-        assert( pFunc->pFExpr->x.pList!=0 );
-        nExtra += pFunc->pFExpr->x.pList->nExpr;
-      }
-      if( pFunc->bUseSubtype ){
-        nExtra += pFunc->pFExpr->x.pList->nExpr;
-      }
-      pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOBList, 0, nExtra);
-      if( !pFunc->bOBUnique && pParse->nErr==0 ){
-        pKeyInfo->nKeyField++;
-      }
-      sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
-            pFunc->iOBTab, pOBList->nExpr+nExtra, 0,
-            (char*)pKeyInfo, P4_KEYINFO);
-      ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s(ORDER BY)",
-                          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; i<pAggInfo->nFunc; i++, pF++){
-    ExprList *pList;
-    assert( ExprUseXList(pF->pFExpr) );
-    if( pParse->nErr ) return;
-    pList = pF->pFExpr->x.pList;
-    if( pF->iOBTab>=0 ){
-      /* For an ORDER BY aggregate, calls to OP_AggStep were deferred.  Inputs
-      ** were stored in emphermal table pF->iOBTab.  Here, we extract those
-      ** inputs (in ORDER BY order) and make all calls to OP_AggStep
-      ** before doing the OP_AggFinal call. */
-      int iTop;        /* Start of loop for extracting columns */
-      int nArg;        /* Number of columns to extract */
-      int nKey;        /* Key columns to be skipped */
-      int regAgg;      /* Extract into this array */
-      int j;           /* Loop counter */
-
-      assert( pF->pFunc!=0 );
-      nArg = pList->nExpr;
-      regAgg = sqlite3GetTempRange(pParse, nArg);
-
-      if( pF->bOBPayload==0 ){
-        nKey = 0;
-      }else{
-        assert( pF->pFExpr->pLeft!=0 );
-        assert( ExprUseXList(pF->pFExpr->pLeft) );
-        assert( pF->pFExpr->pLeft->x.pList!=0 );
-        nKey = pF->pFExpr->pLeft->x.pList->nExpr;
-        if( ALWAYS(!pF->bOBUnique) ) nKey++;
-      }
-      iTop = sqlite3VdbeAddOp1(v, OP_Rewind, pF->iOBTab); VdbeCoverage(v);
-      for(j=nArg-1; j>=0; j--){
-        sqlite3VdbeAddOp3(v, OP_Column, pF->iOBTab, nKey+j, regAgg+j);
-      }
-      if( pF->bUseSubtype ){
-        int regSubtype = sqlite3GetTempReg(pParse);
-        int iBaseCol = nKey + nArg + (pF->bOBPayload==0 && pF->bOBUnique==0);
-        for(j=nArg-1; j>=0; j--){
-          sqlite3VdbeAddOp3(v, OP_Column, pF->iOBTab, iBaseCol+j, regSubtype);
-          sqlite3VdbeAddOp2(v, OP_SetSubtype, regSubtype, regAgg+j);
-        }
-        sqlite3ReleaseTempReg(pParse, regSubtype);
-      }
-      sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, AggInfoFuncReg(pAggInfo,i));
-      sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
-      sqlite3VdbeChangeP5(v, (u16)nArg);
-      sqlite3VdbeAddOp2(v, OP_Next, pF->iOBTab, iTop+1); VdbeCoverage(v);
-      sqlite3VdbeJumpHere(v, iTop);
-      sqlite3ReleaseTempRange(pParse, regAgg, nArg);
-    }
-    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.
-**
-** For an ORDER BY aggregate, the actual accumulator memory cell update
-** is deferred until after all input rows have been received, so that they
-** can be run in the requested order.  In that case, instead of invoking
-** OP_AggStep to update the accumulator, just add the arguments that would
-** have been passed into OP_AggStep into the sorting ephemeral table
-** (along with the appropriate sort key).
-*/
-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; i<pAggInfo->nFunc; i++, pF++){
-    int nArg;
-    int addrNext = 0;
-    int regAgg;
-    int regAggSz = 0;
-    int regDistinct = 0;
-    ExprList *pList;
-    assert( ExprUseXList(pF->pFExpr) );
-    assert( !IsWindowFunc(pF->pFExpr) );
-    assert( pF->pFunc!=0 );
-    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( pF->iOBTab>=0 ){
-      /* Instead of invoking AggStep, we must push the arguments that would
-      ** have been passed to AggStep onto the sorting table. */
-      int jj;                /* Registered used so far in building the record */
-      ExprList *pOBList;     /* The ORDER BY clause */
-      assert( pList!=0 );
-      nArg = pList->nExpr;
-      assert( nArg>0 );
-      assert( pF->pFExpr->pLeft!=0 );
-      assert( pF->pFExpr->pLeft->op==TK_ORDER );
-      assert( ExprUseXList(pF->pFExpr->pLeft) );
-      pOBList = pF->pFExpr->pLeft->x.pList;
-      assert( pOBList!=0 );
-      assert( pOBList->nExpr>0 );
-      regAggSz = pOBList->nExpr;
-      if( !pF->bOBUnique ){
-        regAggSz++;   /* One register for OP_Sequence */
-      }
-      if( pF->bOBPayload ){
-        regAggSz += nArg;
-      }
-      if( pF->bUseSubtype ){
-        regAggSz += nArg;
-      }
-      regAggSz++;  /* One extra register to hold result of MakeRecord */
-      regAgg = sqlite3GetTempRange(pParse, regAggSz);
-      regDistinct = regAgg;
-      sqlite3ExprCodeExprList(pParse, pOBList, regAgg, 0, SQLITE_ECEL_DUP);
-      jj = pOBList->nExpr;
-      if( !pF->bOBUnique ){
-        sqlite3VdbeAddOp2(v, OP_Sequence, pF->iOBTab, regAgg+jj);
-        jj++;
-      }
-      if( pF->bOBPayload ){
-        regDistinct = regAgg+jj;
-        sqlite3ExprCodeExprList(pParse, pList, regDistinct, 0, SQLITE_ECEL_DUP);
-        jj += nArg;
-      }
-      if( pF->bUseSubtype ){
-        int kk;
-        int regBase = pF->bOBPayload ? regDistinct : regAgg;
-        for(kk=0; kk<nArg; kk++, jj++){
-          sqlite3VdbeAddOp2(v, OP_GetSubtype, regBase+kk, regAgg+jj);
-        }
-      }
-    }else if( pList ){
-      nArg = pList->nExpr;
-      regAgg = sqlite3GetTempRange(pParse, nArg);
-      regDistinct = regAgg;
-      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, regDistinct);
-    }
-    if( pF->iOBTab>=0 ){
-      /* Insert a new record into the ORDER BY table */
-      sqlite3VdbeAddOp3(v, OP_MakeRecord, regAgg, regAggSz-1,
-                        regAgg+regAggSz-1);
-      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pF->iOBTab, regAgg+regAggSz-1,
-                           regAgg, regAggSz-1);
-      sqlite3ReleaseTempRange(pParse, regAgg, regAggSz);
-    }else{
-      /* Invoke the AggStep function */
-      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 && j<nArg; j++, pItem++){
-          pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
-        }
-        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, (u16)nArg);
-      sqlite3ReleaseTempRange(pParse, regAgg, nArg);
-    }
-    if( addrNext ){
-      sqlite3VdbeResolveLabel(v, addrNext);
-    }
-    if( pParse->nErr ) return;
-  }
-  if( regHit==0 && pAggInfo->nAccumulator ){
-    regHit = regAcc;
-  }
-  if( regHit ){
-    addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);
-  }
-  for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
-    sqlite3ExprCode(pParse, pC->pCExpr, AggInfoColumnReg(pAggInfo,i));
-    if( pParse->nErr ) return;
-  }
-
-  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 = sqlite3ExprInt32(db, 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 <tables> WHERE a=? GROUP BY b HAVING b=? AND c=?
-**
-** can be rewritten as:
-**
-**   SELECT * FROM <tables> 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;
-  Select *pSel;
-  assert( pThis->fg.isSubquery );
-  pSel = pThis->u4.pSubq->pSelect;
-  assert( pSel!=0 );
-  if( pSel->selFlags & SF_PushDown ) return 0;
-  while( iFirst<iEnd ){
-    Select *pS1;
-    pItem = &pTabList->a[iFirst++];
-    if( !pItem->fg.isSubquery ) continue;
-    if( pItem->fg.viaCoroutine ) continue;
-    if( pItem->zName==0 ) continue;
-    assert( pItem->pSTab!=0 );
-    assert( pThis->pSTab!=0 );
-    if( pItem->pSTab->pSchema!=pThis->pSTab->pSchema ) continue;
-    if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
-    pS1 = pItem->u4.pSubq->pSelect;
-    if( pItem->pSTab->pSchema==0 && pSel->selId!=pS1->selId ){
-      /* The query flattener left two different CTE tables with identical
-      ** names in the same FROM clause. */
-      continue;
-    }
-    if( pS1->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, void *pArg){
-  AggInfo *p = (AggInfo*)pArg;
-  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.
-**   *  None of the subqueries are DISTINCT (forumpost/a860f5fb2e 2025-03-10)
-**
-** Return TRUE if the optimization is undertaken.
-*/
-static int countOfViewOptimization(Parse *pParse, Select *p){
-  Select *pSub, *pPrior;
-  Expr *pExpr;
-  Expr *pCount;
-  sqlite3 *db;
-  SrcItem *pFrom;
-  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 */
-  pFrom = p->pSrc->a;
-  if( pFrom->fg.isSubquery==0 ) return 0;    /* FROM is a subquery */
-  pSub = pFrom->u4.pSubq->pSelect;
-  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|SF_Distinct) ){
-       testcase( pSub->selFlags & SF_Aggregate );
-       testcase( pSub->selFlags & SF_Distinct );
-       return 0;     /* Not an aggregate nor DISTINCT */
-    }
-    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 = sqlite3SubqueryDetach(db, pFrom);
-  sqlite3SrcListDelete(db, p->pSrc);
-  p->pSrc = sqlite3DbMallocZero(pParse->db, SZ_SRCLIST_1);
-  while( pSub ){
-    Expr *pTerm;
-    pPrior = pSub->pPrior;
-    pSub->pPrior = 0;
-    pSub->pNext = 0;
-    pSub->selFlags |= SF_Aggregate;
-    pSub->selFlags &= ~(u32)SF_Compound;
-    pSub->nSelectRow = 0;
-    sqlite3ParserAddCleanup(pParse, sqlite3ExprListDeleteGeneric, 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 &= ~(u32)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; i<pSrc->nSrc; i++){
-    SrcItem *p1 = &pSrc->a[i];
-    if( p1==p0 ) continue;
-    if( p0->pSTab==p1->pSTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){
-      return 1;
-    }
-    if( p1->fg.isSubquery
-     && (p1->u4.pSubq->pSelect->selFlags & SF_NestedFrom)!=0
-     && sameSrcAlias(p0, p1->u4.pSubq->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->fg.isSubquery ) return 0;                          /* (1c-i) */
-  }
-  return 1;
-}
-
-/*
-** Argument pWhere is the WHERE clause belonging to SELECT statement p. This
-** function attempts to transform expressions of the form:
-**
-**     EXISTS (SELECT ...)
-**
-** into joins. For example, given
-**
-**    CREATE TABLE sailors(sid INTEGER PRIMARY KEY, name TEXT);
-**    CREATE TABLE reserves(sid INT, day DATE, PRIMARY KEY(sid, day));
-**
-**    SELECT name FROM sailors AS S WHERE EXISTS (
-**      SELECT * FROM reserves AS R WHERE S.sid = R.sid AND R.day = '2022-10-25'
-**    );
-**
-** the SELECT statement may be transformed as follows:
-**
-**    SELECT name FROM sailors AS S, reserves AS R
-**      WHERE S.sid = R.sid AND R.day = '2022-10-25';
-**
-** **Approximately**.  Really, we have to ensure that the FROM-clause term
-** that was formerly inside the EXISTS is only executed once.  This is handled
-** by setting the SrcItem.fg.fromExists flag, which then causes code in
-** the where.c file to exit the corresponding loop after the first successful
-** match (if any).
-*/
-static SQLITE_NOINLINE void existsToJoin(
-  Parse *pParse,  /* Parsing context */
-  Select *p,      /* The SELECT statement being optimized */
-  Expr *pWhere    /* part of the WHERE clause currently being examined */
-){
-  if( pParse->nErr==0
-   && pWhere!=0
-   && !ExprHasProperty(pWhere, EP_OuterON|EP_InnerON)
-   && ALWAYS(p->pSrc!=0)
-   && p->pSrc->nSrc<BMS
-   && (p->pLimit==0 || p->pLimit->pRight==0)
-  ){
-    if( pWhere->op==TK_AND ){
-      Expr *pRight = pWhere->pRight;
-      existsToJoin(pParse, p, pWhere->pLeft);
-      existsToJoin(pParse, p, pRight);
-    }
-    else if( pWhere->op==TK_EXISTS ){
-      Select *pSub = pWhere->x.pSelect;
-      Expr *pSubWhere = pSub->pWhere;
-      if( pSub->pSrc->nSrc==1
-       && (pSub->selFlags & SF_Aggregate)==0
-       && !pSub->pSrc->a[0].fg.isSubquery
-       && pSub->pLimit==0
-       && pSub->pPrior==0
-      ){
-        /* Before combining the sub-select with the parent, renumber the
-        ** cursor used by the subselect. This is because the EXISTS expression
-        ** might be a copy of another EXISTS expression from somewhere
-        ** else in the tree, and in this case it is important that it use
-        ** a unique cursor number.  */
-        sqlite3 *db = pParse->db;
-        int *aCsrMap = sqlite3DbMallocZero(db, (pParse->nTab+2)*sizeof(int));
-        if( aCsrMap==0 ) return;
-        aCsrMap[0] = (pParse->nTab+1);
-        renumberCursors(pParse, pSub, -1, aCsrMap);
-        sqlite3DbFree(db, aCsrMap);
-
-        memset(pWhere, 0, sizeof(*pWhere));
-        pWhere->op = TK_INTEGER;
-        pWhere->u.iValue = 1;
-        ExprSetProperty(pWhere, EP_IntValue);
-        assert( p->pWhere!=0 );
-        pSub->pSrc->a[0].fg.fromExists = 1;
-        p->pSrc = sqlite3SrcListAppendList(pParse, p->pSrc, pSub->pSrc);
-        if( pSubWhere ){
-          p->pWhere = sqlite3PExpr(pParse, TK_AND, p->pWhere, pSubWhere);
-          pSub->pWhere = 0;
-        }
-        pSub->pSrc = 0;
-        sqlite3ParserAddCleanup(pParse, sqlite3SelectDeleteGeneric, pSub);
-#if TREETRACE_ENABLED
-        if( sqlite3TreeTrace & 0x100000 ){
-          TREETRACE(0x100000,pParse,p,
-                    ("After EXISTS-to-JOIN optimization:\n"));
-          sqlite3TreeViewSelect(0, p, 0);
-        }
-#endif
-      }
-    }
-  }
-}
-
-/*
-** Type used for Walker callbacks by selectCheckOnClauses().
-*/
-typedef struct CheckOnCtx CheckOnCtx;
-struct CheckOnCtx {
-  SrcList *pSrc;                  /* SrcList for this context */
-  int iJoin;                      /* Cursor numbers must be =< than this */
-  int bFuncArg;                   /* True for table-function arg */
-  CheckOnCtx *pParent;            /* Parent context */
-};
-
-/*
-** True if the SrcList passed as the only argument contains at least
-** one RIGHT or FULL JOIN. False otherwise.
-*/
-#define hasRightJoin(pSrc) (((pSrc)->a[0].fg.jointype & JT_LTORJ)!=0)
-
-/*
-** The xExpr callback for the search of invalid ON clause terms.
-*/
-static int selectCheckOnClausesExpr(Walker *pWalker, Expr *pExpr){
-  CheckOnCtx *pCtx = pWalker->u.pCheckOnCtx;
-
-  /* Check if pExpr is root or near-root of an ON clause constraint that needs
-  ** to be checked to ensure that it does not refer to tables in its FROM
-  ** clause to the right of itself. i.e. it is either:
-  **
-  **   + an ON clause on an OUTER join, or
-  **   + an ON clause on an INNER join within a FROM that features at
-  **     least one RIGHT or FULL join.
-  */
-  if( (ExprHasProperty(pExpr, EP_OuterON))
-   || (ExprHasProperty(pExpr, EP_InnerON) && hasRightJoin(pCtx->pSrc))
-  ){
-    /* If CheckOnCtx.iJoin is already set, then fall through and process
-    ** this expression node as normal. Or, if CheckOnCtx.iJoin is still 0,
-    ** set it to the cursor number of the RHS of the join to which this
-    ** ON expression was attached and then iterate through the entire
-    ** expression.  */
-    assert( pCtx->iJoin==0 || pCtx->iJoin==pExpr->w.iJoin );
-    if( pCtx->iJoin==0 ){
-      pCtx->iJoin = pExpr->w.iJoin;
-      sqlite3WalkExprNN(pWalker, pExpr);
-      pCtx->iJoin = 0;
-      return WRC_Prune;
-    }
-  }
-
-  if( pExpr->op==TK_COLUMN ){
-    /* A column expression. Find the SrcList (if any) to which it refers.
-    ** Then, if CheckOnCtx.iJoin indicates that this expression is part of an
-    ** ON clause from that SrcList (i.e. if iJoin is non-zero), check that it
-    ** does not refer to a table to the right of CheckOnCtx.iJoin. */
-    do {
-      SrcList *pSrc = pCtx->pSrc;
-      int iTab = pExpr->iTable;
-      if( iTab>=pSrc->a[0].iCursor && iTab<=pSrc->a[pSrc->nSrc-1].iCursor ){
-        if( pCtx->iJoin && iTab>pCtx->iJoin ){
-          sqlite3ErrorMsg(pWalker->pParse,
-              "%s references tables to its right",
-              (pCtx->bFuncArg ? "table-function argument" : "ON clause")
-          );
-          return WRC_Abort;
-        }
-        break;
-      }
-      pCtx = pCtx->pParent;
-    }while( pCtx );
-  }
-  return WRC_Continue;
-}
-
-/*
-** The xSelect callback for the search of invalid ON clause terms.
-*/
-static int selectCheckOnClausesSelect(Walker *pWalker, Select *pSelect){
-  CheckOnCtx *pCtx = pWalker->u.pCheckOnCtx;
-  if( pSelect->pSrc==pCtx->pSrc || pSelect->pSrc->nSrc==0 ){
-    return WRC_Continue;
-  }else{
-    CheckOnCtx sCtx;
-    memset(&sCtx, 0, sizeof(sCtx));
-    sCtx.pSrc = pSelect->pSrc;
-    sCtx.pParent = pCtx;
-    pWalker->u.pCheckOnCtx = &sCtx;
-    sqlite3WalkSelect(pWalker, pSelect);
-    pWalker->u.pCheckOnCtx = pCtx;
-    pSelect->selFlags &= ~SF_OnToWhere;
-    return WRC_Prune;
-  }
-}
-
-/*
-** Check all ON clauses in pSelect to verify that they do not reference
-** columns to the right.
-*/
-SQLITE_PRIVATE void sqlite3SelectCheckOnClauses(Parse *pParse, Select *pSelect){
-  Walker w;
-  CheckOnCtx sCtx;
-  int ii;
-  assert( pSelect->selFlags & SF_OnToWhere );
-  assert( pSelect->pSrc!=0 && pSelect->pSrc->nSrc>=2 );
-  memset(&w, 0, sizeof(w));
-  w.pParse = pParse;
-  w.xExprCallback = selectCheckOnClausesExpr;
-  w.xSelectCallback = selectCheckOnClausesSelect;
-  w.u.pCheckOnCtx = &sCtx;
-  memset(&sCtx, 0, sizeof(sCtx));
-  sCtx.pSrc = pSelect->pSrc;
-  sqlite3WalkExpr(&w, pSelect->pWhere);
-  pSelect->selFlags &= ~SF_OnToWhere;
-
-  /* Check for any table-function args that are attached to virtual tables
-  ** on the RHS of an outer join. They are subject to the same constraints
-  ** as ON clauses. */
-  sCtx.bFuncArg = 1;
-  for(ii=0; ii<pSelect->pSrc->nSrc; ii++){
-    SrcItem *pItem = &pSelect->pSrc->a[ii];
-    if( pItem->fg.isTabFunc
-     && (pItem->fg.jointype & JT_OUTER)
-    ){
-      sCtx.iJoin = pItem->iCursor;
-      sqlite3WalkExprList(&w, pItem->u1.pFuncArg);
-    }
-  }
-}
-
-/*
-** If p2 exists and p1 and p2 have the same number of terms, then change
-** every term of p1 to have the same sort order as p2 and return true.
-**
-** If p2 is NULL or p1 and p2 are different lengths, then make no changes
-** and return false.
-**
-** p1 must be non-NULL.
-*/
-static int sqlite3CopySortOrder(ExprList *p1, ExprList *p2){
-  assert( p1 );
-  if( p2 && p1->nExpr==p2->nExpr ){
-    int ii;
-    for(ii=0; ii<p1->nExpr; ii++){
-      u8 sortFlags;
-      sortFlags = p2->a[ii].fg.sortFlags & KEYINFO_ORDER_DESC;
-      p1->a[ii].fg.sortFlags = sortFlags;
-    }
-    return 1;
-  }else{
-    return 0;
-  }
-}
-
-/*
-** Generate byte-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.
-**
-** This is a long function.  The following is an outline of the processing
-** steps, with tags referencing various milestones:
-**
-**  *  Resolve names and similar preparation                tag-select-0100
-**  *  Scan of the FROM clause                              tag-select-0200
-**      +  OUTER JOIN strength reduction                      tag-select-0220
-**      +  Sub-query ORDER BY removal                         tag-select-0230
-**      +  Query flattening                                   tag-select-0240
-**  *  Separate subroutine for compound-SELECT              tag-select-0300
-**  *  WHERE-clause constant propagation                    tag-select-0330
-**  *  Count()-of-VIEW optimization                         tag-select-0350
-**  *  Scan of the FROM clause again                        tag-select-0400
-**      +  Authorize unreferenced tables                      tag-select-0410
-**      +  Predicate push-down optimization                   tag-select-0420
-**      +  Omit unused subquery columns optimization          tag-select-0440
-**      +  Generate code to implement subqueries              tag-select-0480
-**         -  Co-routines                                       tag-select-0482
-**         -  Reuse previously computed CTE                     tag-select-0484
-**         -  REuse previously computed VIEW                    tag-select-0486
-**         -  Materialize a VIEW or CTE                         tag-select-0488
-**  *  DISTINCT ORDER BY -> GROUP BY optimization           tag-select-0500
-**  *  Set up for ORDER BY                                  tag-select-0600
-**  *  Create output table                                  tag-select-0630
-**  *  Prepare registers for LIMIT                          tag-select-0650
-**  *  Setup for DISTINCT                                   tag-select-0680
-**  *  Generate code for non-aggregate and non-GROUP BY     tag-select-0700
-**  *  Generate code for aggregate and/or GROUP BY          tag-select-0800
-**      +  GROUP BY queries                                   tag-select-0810
-**      +  non-GROUP BY queries                               tag-select-0820
-**         -  Special case of count() w/o GROUP BY              tag-select-0821
-**         -  General case of non-GROUP BY aggregates           tag-select-0822
-**  *  Sort results, as needed                              tag-select-0900
-**  *  Internal self-checks                                 tag-select-1000
-*/
-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
-
-  /* tag-select-0100 */
-  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_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, sqlite3ExprListDeleteGeneric,
-                              p->pOrderBy);
-      testcase( pParse->earlyCleanup );
-      p->pOrderBy = 0;
-    }
-    p->selFlags &= ~(u32)SF_Distinct;
-  }
-  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->pSTab->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 &= ~(u32)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
-  ** tag-select-0200
-  */
-#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
-  for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
-    SrcItem *pItem = &pTabList->a[i];
-    Select *pSub = pItem->fg.isSubquery ? pItem->u4.pSubq->pSelect : 0;
-    Table *pTab = pItem->pSTab;
-
-    /* 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 );
-
-    /* Try to simplify joins:
-    **
-    **      LEFT JOIN  ->  JOIN
-    **     RIGHT JOIN  ->  JOIN
-    **      FULL JOIN  ->  RIGHT JOIN
-    **
-    ** If terms of the i-th table are used in the WHERE clause in such a
-    ** way that the i-th table cannot be the NULL row of a join, then
-    ** perform the appropriate simplification. This is called
-    ** "OUTER JOIN strength reduction" in the SQLite documentation.
-    ** tag-select-0220
-    */
-    if( (pItem->fg.jointype & (JT_LEFT|JT_LTORJ))!=0
-     && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor,
-                                     pItem->fg.jointype & JT_LTORJ)
-     && OptimizationEnabled(db, SQLITE_SimplifyJoin)
-    ){
-      if( pItem->fg.jointype & JT_LEFT ){
-        if( pItem->fg.jointype & JT_RIGHT ){
-          TREETRACE(0x1000,pParse,p,
-                    ("FULL-JOIN simplifies to RIGHT-JOIN on term %d\n",i));
-          pItem->fg.jointype &= ~JT_LEFT;
-        }else{
-          TREETRACE(0x1000,pParse,p,
-                    ("LEFT-JOIN simplifies to JOIN on term %d\n",i));
-          pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER);
-          unsetJoinExpr(p->pWhere, pItem->iCursor, 0);
-        }
-      }
-      if( pItem->fg.jointype & JT_LTORJ ){
-        for(j=i+1; j<pTabList->nSrc; j++){
-          SrcItem *pI2 = &pTabList->a[j];
-          if( pI2->fg.jointype & JT_RIGHT ){
-            if( pI2->fg.jointype & JT_LEFT ){
-              TREETRACE(0x1000,pParse,p,
-                        ("FULL-JOIN simplifies to LEFT-JOIN on term %d\n",j));
-              pI2->fg.jointype &= ~JT_RIGHT;
-            }else{
-              TREETRACE(0x1000,pParse,p,
-                        ("RIGHT-JOIN simplifies to JOIN on term %d\n",j));
-              pI2->fg.jointype &= ~(JT_RIGHT|JT_OUTER);
-              unsetJoinExpr(p->pWhere, pI2->iCursor, 1);
-            }
-          }
-        }
-        for(j=pTabList->nSrc-1; j>=0; j--){
-          pTabList->a[j].fg.jointype &= ~JT_LTORJ;
-          if( pTabList->a[j].fg.jointype & JT_RIGHT ) break;
-        }
-      }
-    }
-
-    /* No further 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 attempt the usual optimizations (flattening and ORDER BY
-    ** elimination) on a MATERIALIZED common table expression because
-    ** a MATERIALIZED common table expression is an optimization fence.
-    */
-    if( pItem->fg.isCte && pItem->u2.pCteUse->eM10d==M10d_Yes ){
-      continue;
-    }
-
-    /* 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 );
-
-    /* tag-select-0230:
-    ** 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
-    **    (6)   The subquery is not a recursive CTE.  ORDER BY has a different
-    **          meaning for recursive CTEs and this optimization does not
-    **          apply.
-    **
-    ** Also retain the ORDER BY if the OmitOrderBy optimization is disabled.
-    */
-    if( pSub->pOrderBy!=0
-     && (p->pOrderBy!=0 || pTabList->nSrc>1)      /* Condition (5) */
-     && pSub->pLimit==0                           /* Condition (1) */
-     && (pSub->selFlags & (SF_OrderByReqd|SF_Recursive))==0  /* (2) and (6) */
-     && (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, sqlite3ExprListDeleteGeneric,
-                              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;
-    }
-
-    /* tag-select-0240 */
-    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.  tag-select-0300
-  */
-  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
-
-  /* If there may be an "EXISTS (SELECT ...)" in the WHERE clause, attempt
-  ** to change it into a join.  */
-  if( pParse->bHasExists && OptimizationEnabled(db,SQLITE_ExistsToJoin) ){
-    existsToJoin(pParse, p, p->pWhere);
-    pTabList = p->pSrc;
-  }
-
-  /* Do the WHERE-clause constant propagation optimization if this is
-  ** a join.  No need to spend time on this operation for non-join queries
-  ** as the equivalent optimization will be handled by query planner in
-  ** sqlite3WhereBegin().  tag-select-0330
-  */
-  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"));
-  }
-
-  /* tag-select-0350 */
-  if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView)
-   && countOfViewOptimization(pParse, p)
-  ){
-    if( db->mallocFailed ) goto select_end;
-    pTabList = p->pSrc;
-  }
-
-  /* Loop over all terms in the FROM clause and do two things for each term:
-  **
-  **   (1) Authorize unreferenced tables
-  **   (2) Generate code for all sub-queries
-  **
-  ** tag-select-0400
-  */
-  for(i=0; i<pTabList->nSrc; i++){
-    SrcItem *pItem = &pTabList->a[i];
-    SrcItem *pPrior;
-    SelectDest dest;
-    Subquery *pSubq;
-    Select *pSub;
-#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
-    const char *zSavedAuthContext;
-#endif
-
-    /* Authorized unreferenced tables.  tag-select-0410
-    **
-    ** 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 ){
-      const char *zDb;
-      if( pItem->fg.fixedSchema ){
-        int iDb = sqlite3SchemaToIndex(pParse->db, pItem->u4.pSchema);
-        zDb = db->aDb[iDb].zDbSName;
-      }else if( pItem->fg.isSubquery ){
-        zDb = 0;
-      }else{
-        zDb = pItem->u4.zDatabase;
-      }
-      sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", zDb);
-    }
-
-#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
-    /* Generate code for all sub-queries in the FROM clause
-    */
-    if( pItem->fg.isSubquery==0 ) continue;
-    pSubq = pItem->u4.pSubq;
-    assert( pSubq!=0 );
-    pSub = pSubq->pSelect;
-
-    /* The code for a subquery should only be generated once. */
-    if( pSubq->addrFillSub!=0 ) continue;
-
-    /* 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.
-    ** This is the "predicate push-down optimization".  tag-select-0420
-    */
-    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( pSubq->pSelect && (pSub->selFlags & SF_PushDown)!=0 );
-    }else{
-      TREETRACE(0x4000,pParse,p,("WHERE-clause push-down not possible\n"));
-    }
-
-    /* Convert unused result columns of the subquery into simple NULL
-    ** expressions, to avoid unneeded searching and computation.
-    ** tag-select-0440
-    */
-    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 byte-code to implement the subquery  tag-select-0480
-    */
-    if( fromClauseTermCanBeCoroutine(pParse, pTabList, i, p->selFlags) ){
-      /* Implement a co-routine that will return a single row of the result
-      ** set on each invocation.  tag-select-0482
-      */
-      int addrTop = sqlite3VdbeCurrentAddr(v)+1;
-
-      pSubq->regReturn = ++pParse->nMem;
-      sqlite3VdbeAddOp3(v, OP_InitCoroutine, pSubq->regReturn, 0, addrTop);
-      VdbeComment((v, "%!S", pItem));
-      pSubq->addrFillSub = addrTop;
-      sqlite3SelectDestInit(&dest, SRT_Coroutine, pSubq->regReturn);
-      ExplainQueryPlan((pParse, 1, "CO-ROUTINE %!S", pItem));
-      sqlite3Select(pParse, pSub, &dest);
-      pItem->pSTab->nRowLogEst = pSub->nSelectRow;
-      pItem->fg.viaCoroutine = 1;
-      pSubq->regResult = dest.iSdst;
-      sqlite3VdbeEndCoroutine(v, pSubq->regReturn);
-      VdbeComment((v, "end %!S", pItem));
-      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,
-      ** then make the pItem->iCursor be a copy of the ephemeral table that
-      ** holds the result of the materialization. tag-select-0484 */
-      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.  tag-select-0486 */
-      Subquery *pPriorSubq;
-      assert( pPrior->fg.isSubquery );
-      pPriorSubq = pPrior->u4.pSubq;
-      assert( pPriorSubq!=0 );
-      if( pPriorSubq->addrFillSub ){
-        sqlite3VdbeAddOp2(v, OP_Gosub, pPriorSubq->regReturn,
-                                       pPriorSubq->addrFillSub);
-      }
-      sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
-      pSub->nSelectRow = pPriorSubq->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.  tag-select-0488 */
-      int topAddr;
-      int onceAddr = 0;
-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
-      int addrExplain;
-#endif
-
-      pSubq->regReturn = ++pParse->nMem;
-      topAddr = sqlite3VdbeAddOp0(v, OP_Goto);
-      pSubq->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->pSTab->nRowLogEst = pSub->nSelectRow;
-      if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
-      sqlite3VdbeAddOp2(v, OP_Return, pSubq->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 = pSubq->addrFillSub;
-        pCteUse->regRtn = pSubq->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
-
-  /* tag-select-0500
-  **
-  ** 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
-   && sqlite3CopySortOrder(pEList, sSort.pOrderBy)
-   && sqlite3ExprListCompare(pEList, sSort.pOrderBy, -1)==0
-   && OptimizationEnabled(db, SQLITE_GroupByOrder)
-#ifndef SQLITE_OMIT_WINDOWFUNC
-   && p->pWin==0
-#endif
-  ){
-    p->selFlags &= ~(u32)SF_Distinct;
-    pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0);
-    if( pGroupBy ){
-      for(i=0; i<pGroupBy->nExpr; i++){
-        pGroupBy->a[i].u.x.iOrderByCol = i+1;
-      }
-    }
-    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.  tag-select-0600
-  */
-  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.
-  ** tag-select-0630
-  */
-  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; ii<pEList->nExpr; ii++){
-        if( pEList->a[ii].fg.bUsed==0 ) pEList->a[ii].pExpr->op = TK_NULL;
-      }
-    }
-  }
-
-  /* Set the limiter.  tag-select-0650
-  */
-  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. tag-select-0680
-  */
-  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.  tag-select-0700 */
-    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( pDest->eDest<=SRT_DistQueue && pDest->eDest>=SRT_DistFifo ){
-        /* TUNING: For a UNION CTE, because UNION is implies DISTINCT,
-        ** reduce the estimated output row count by 8 (LogEst 30).
-        ** Search for tag-20250414a to see other cases */
-        p->nSelectRow -= 30;
-      }
-    }
-    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 is for when there exist aggregate functions or a GROUP BY
-    ** clause or both.  tag-select-0800 */
-    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( sqlite3CopySortOrder(pGroupBy, sSort.pOrderBy)
-       && 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, 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.  tag-select-0810
-    */
-    if( pGroupBy ){
-      KeyInfo *pKeyInfo;  /* Keying information for the group by clause */
-      int addr1;          /* A-vs-B comparison 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);
-      sqlite3ExprNullRegisterRange(pParse, iAMem, pGroupBy->nExpr);
-
-      /* 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;
-
-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
-        int addrExp;              /* Address of OP_Explain instruction */
-#endif
-        ExplainQueryPlan2(addrExp, (pParse, 0, "USE TEMP B-TREE FOR %s",
-            (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ?
-                    "DISTINCT" : "GROUP BY"
-        ));
-
-        groupBySort = 1;
-        nGroupBy = pGroupBy->nExpr;
-        nCol = nGroupBy;
-        j = nGroupBy;
-        for(i=0; i<pAggInfo->nColumn; 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; i<pAggInfo->nColumn; 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);
-        sqlite3VdbeScanStatusCounters(v, addrExp, 0, sqlite3VdbeCurrentAddr(v));
-        sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
-        sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord);
-        sqlite3VdbeScanStatusRange(v, addrExp, sqlite3VdbeCurrentAddr(v)-2, -1);
-        sqlite3ReleaseTempReg(pParse, regRecord);
-        sqlite3ReleaseTempRange(pParse, regBase, nCol);
-        TREETRACE(0x2,pParse,p,("WhereEnd\n"));
-        sqlite3WhereEnd(pWInfo);
-        pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++;
-        sortOut = sqlite3GetTempReg(pParse);
-        sqlite3VdbeScanStatusCounters(v, addrExp, sqlite3VdbeCurrentAddr(v), 0);
-        sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
-        sqlite3VdbeAddOp2(v, OP_SorterSort, pAggInfo->sortingIdx, addrEnd);
-        VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v);
-        pAggInfo->useSortingIdx = 1;
-        sqlite3VdbeScanStatusRange(v, addrExp, -1, sortPTab);
-        sqlite3VdbeScanStatusRange(v, addrExp, -1, pAggInfo->sortingIdx);
-      }
-
-      /* 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; j<pGroupBy->nExpr; j++){
-        int iOrderByCol = pGroupBy->a[j].u.x.iOrderByCol;
-
-        if( groupBySort ){
-          sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
-        }else{
-          pAggInfo->directMode = 1;
-          sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
-        }
-
-        if( iOrderByCol ){
-          Expr *pX = p->pEList->a[iOrderByCol-1].pExpr;
-          Expr *pBase = sqlite3ExprSkipCollateAndLikely(pX);
-          while( ALWAYS(pBase!=0) && pBase->op==TK_IF_NULL_ROW ){
-            pX = pBase->pLeft;
-            pBase = sqlite3ExprSkipCollateAndLikely(pX);
-          }
-          if( ALWAYS(pBase!=0)
-           && pBase->op!=TK_AGG_COLUMN
-           && pBase->op!=TK_REGISTER
-          ){
-            sqlite3ExprToRegister(pX, iAMem+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.
-      */
-      sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
-      VdbeComment((v, "output one row of %d", p->selId));
-      sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
-      sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v);
-      VdbeComment((v, "check abort flag"));
-      sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
-      VdbeComment((v, "reset accumulator %d", p->selId));
-
-      /* 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 %d", p->selId));
-
-      /* 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 of %d", p->selId));
-
-      /* 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 %d", p->selId));
-      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 %d", p->selId));
-
-      /* 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 %d empty", p->selId));
-      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 {
-      /* Aggregate functions without GROUP BY. tag-select-0820 */
-      Table *pTab;
-      if( (pTab = isSimpleCount(p, pAggInfo))!=0 ){
-        /* tag-select-0821
-        **
-        ** If isSimpleCount() returns a pointer to a Table structure, then
-        ** the SQL statement is of the form:
-        **
-        **   SELECT count(*) FROM <tbl>
-        **
-        ** where the Table structure returned represents table <tbl>.
-        **
-        ** 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 <tbl> 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->szIdxRow<pTab->szTabRow
-             && pIdx->pPartIdxWhere==0
-             && (!pBest || pIdx->szIdxRow<pBest->szIdxRow)
-            ){
-              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{
-        /* The general case of an aggregate query without GROUP BY
-        ** tag-select-0822 */
-        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; i<pAggInfo->nFunc; 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.  tag-select-0900
-  */
-  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
-  /* Internal self-checks.  tag-select-1000 */
-  if( pAggInfo && !db->mallocFailed ){
-#if TREETRACE_ENABLED
-    if( sqlite3TreeTrace & 0x20 ){
-      TREETRACE(0x20,pParse,p,("Finished with AggInfo\n"));
-      printAggInfo(pAggInfo);
-    }
-#endif
-    for(i=0; i<pAggInfo->nColumn; i++){
-      Expr *pExpr = pAggInfo->aCol[i].pCExpr;
-      if( pExpr==0 ) continue;
-      assert( pExpr->pAggInfo==pAggInfo );
-      assert( pExpr->iAgg==i );
-    }
-    for(i=0; i<pAggInfo->nFunc; 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; i<nCol; i++){
-      z = sqlite3_mprintf("%s", colv[i]);
-      if( z==0 ) goto malloc_failed;
-      p->azResult[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; i<nCol; i++){
-      if( argv[i]==0 ){
-        z = 0;
-      }else{
-        int n = sqlite3Strlen30(argv[i])+1;
-        z = sqlite3_malloc64( n );
-        if( z==0 ) goto malloc_failed;
-        memcpy(z, argv[i], n);
-      }
-      p->azResult[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; i<n; i++){ if( azResult[i] ) sqlite3_free(azResult[i]); }
-    sqlite3_free(azResult);
-  }
-}
-
-#endif /* SQLITE_OMIT_GET_TABLE */
-
-/************** End of table.c ***********************************************/
-/************** Begin file trigger.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 the implementation for TRIGGERs
-*/
-/* #include "sqliteInt.h" */
-
-#ifndef SQLITE_OMIT_TRIGGER
-/*
-** Delete a linked list of TriggerStep structures.
-*/
-SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
-  while( pTriggerStep ){
-    TriggerStep * pTmp = pTriggerStep;
-    pTriggerStep = pTriggerStep->pNext;
-
-    sqlite3ExprDelete(db, pTmp->pWhere);
-    sqlite3ExprListDelete(db, pTmp->pExprList);
-    sqlite3SelectDelete(db, pTmp->pSelect);
-    sqlite3IdListDelete(db, pTmp->pIdList);
-    sqlite3UpsertDelete(db, pTmp->pUpsert);
-    sqlite3SrcListDelete(db, pTmp->pSrc);
-    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->isCreate );
-      assert( &(pParse->u1.d.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 ){
-    assert( pTableName->a[0].fg.fixedSchema==0 );
-    assert( pTableName->a[0].fg.isSubquery==0 );
-    sqlite3DbFree(db, pTableName->a[0].u4.zDatabase);
-    pTableName->a[0].u4.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;
-  }
-  if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
-    sqlite3ErrorMsg(pParse, "cannot create triggers on shadow 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;
-    }
-  }
-
-  /* NB: The SQLITE_ALLOW_TRIGGERS_ON_SYSTEM_TABLES compile-time option is
-  ** experimental and unsupported. Do not use it unless understand the
-  ** implications and you cannot get by without this capability. */
-#if !defined(SQLITE_ALLOW_TRIGGERS_ON_SYSTEM_TABLES) /* Experimental */
-  /* 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;
-  }
-#endif
-
-  /* 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);
-  assert( iDb>=00 && iDb<db->nDb );
-  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->pSrc!=0
-         && sqlite3ShadowTableName(db, pStep->pSrc->a[0].zName)
-        ){
-          sqlite3ErrorMsg(pParse,
-            "trigger \"%s\" may not write to shadow table \"%s\"",
-            pTrig->zName, pStep->pSrc->a[0].zName);
-          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 */
-  SrcList *pTabList,          /* Target table */
-  const char *zStart,         /* Start of SQL text */
-  const char *zEnd            /* End of SQL text */
-){
-  Trigger *pNew = pParse->pNewTrigger;
-  sqlite3 *db = pParse->db;
-  TriggerStep *pTriggerStep = 0;
-
-  if( pParse->nErr==0 ){
-    if( pNew
-     && pNew->pSchema!=db->aDb[1].pSchema
-     && pTabList->a[0].u4.zDatabase
-    ){
-      sqlite3ErrorMsg(pParse,
-          "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
-          "statements within triggers");
-    }else{
-      pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
-      if( pTriggerStep ){
-        pTriggerStep->pSrc = sqlite3SrcListDup(db, pTabList, EXPRDUP_REDUCE);
-        pTriggerStep->op = op;
-        pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);
-        if( pTriggerStep->pSrc && IN_RENAME_OBJECT ){
-          sqlite3RenameTokenRemap(pParse,
-              pTriggerStep->pSrc->a[0].zName,
-              pTabList->a[0].zName
-          );
-        }
-      }
-    }
-  }
-
-  sqlite3SrcListDelete(db, pTabList);
-  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 */
-  SrcList *pTabList,  /* Table to INSERT into */
-  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, pTabList, 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 */
-  SrcList *pTabList,   /* 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, pTabList, zStart, zEnd);
-  if( pTriggerStep ){
-    SrcList *pFromDup = 0;
-    if( IN_RENAME_OBJECT ){
-      pTriggerStep->pExprList = pEList;
-      pTriggerStep->pWhere = pWhere;
-      pFromDup = pFrom;
-      pEList = 0;
-      pWhere = 0;
-      pFrom = 0;
-    }else{
-      pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
-      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
-      pFromDup = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE);
-    }
-    pTriggerStep->orconf = orconf;
-
-    if( pFromDup && !IN_RENAME_OBJECT){
-      Select *pSub;
-      Token as = {0, 0};
-      pSub = sqlite3SelectNew(pParse, 0, pFromDup, 0,0,0,0, SF_NestedFrom, 0);
-      pFromDup = sqlite3SrcListAppendFromTerm(pParse, 0, 0, 0, &as, pSub ,0);
-    }
-    if( pFromDup && pTriggerStep->pSrc ){
-      pTriggerStep->pSrc = sqlite3SrcListAppendList(
-          pParse, pTriggerStep->pSrc, pFromDup
-      );
-    }else{
-      sqlite3SrcListDelete(db, pFromDup);
-    }
-  }
-  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 */
-  SrcList *pTabList,      /* 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, pTabList, 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 );
-  assert( pName->a[0].fg.fixedSchema==0 && pName->a[0].fg.isSubquery==0 );
-  zDb = pName->a[0].u4.zDatabase;
-  zName = pName->a[0].zName;
-  assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
-  for(i=OMIT_TEMPDB; i<db->nDb; 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 && iDb<db->nDb );
-  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 <id>=<expr>.  If any of the entries
-** in pEList have an <id> 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; e<pEList->nExpr; 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
-     && sqlite3SchemaToIndex(pParse->db, pTab->pTrigger->pSchema)!=1
-    ){
-      /* 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);
-}
-
-/*
-** 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; i<pList->nExpr; i++){
-    Expr *pOldExpr = pList->a[i].pExpr;
-    if( NEVER(pOldExpr==0) ) continue;
-    if( isAsteriskTerm(pParse, pOldExpr) ){
-      int jj;
-      for(jj=0; jj<pTab->nCol; 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;
-}
-
-/* If the Expr node is a subquery or an EXISTS operator or an IN operator that
-** uses a subquery, and if the subquery is SF_Correlated, then mark the
-** expression as EP_VarSelect.
-*/
-static int sqlite3ReturningSubqueryVarSelect(Walker *NotUsed, Expr *pExpr){
-  UNUSED_PARAMETER(NotUsed);
-  if( ExprUseXSelect(pExpr)
-   && (pExpr->x.pSelect->selFlags & SF_Correlated)!=0
-  ){
-    testcase( ExprHasProperty(pExpr, EP_VarSelect) );
-    ExprSetProperty(pExpr, EP_VarSelect);
-  }
-  return WRC_Continue;
-}
-
-
-/*
-** If the SELECT references the table pWalker->u.pTab, then do two things:
-**
-**    (1) Mark the SELECT as as SF_Correlated.
-**    (2) Set pWalker->eCode to non-zero so that the caller will know
-**        that (1) has happened.
-*/
-static int sqlite3ReturningSubqueryCorrelated(Walker *pWalker, Select *pSelect){
-  int i;
-  SrcList *pSrc;
-  assert( pSelect!=0 );
-  pSrc = pSelect->pSrc;
-  assert( pSrc!=0 );
-  for(i=0; i<pSrc->nSrc; i++){
-    if( pSrc->a[i].pSTab==pWalker->u.pTab ){
-      testcase( pSelect->selFlags & SF_Correlated );
-      pSelect->selFlags |= SF_Correlated;
-      pWalker->eCode = 1;
-      break;
-    }
-  }
-  return WRC_Continue;
-}
-
-/*
-** Scan the expression list that is the argument to RETURNING looking
-** for subqueries that depend on the table which is being modified in the
-** statement that is hosting the RETURNING clause (pTab).  Mark all such
-** subqueries as SF_Correlated.  If the subqueries are part of an
-** expression, mark the expression as EP_VarSelect.
-**
-** https://sqlite.org/forum/forumpost/2c83569ce8945d39
-*/
-static void sqlite3ProcessReturningSubqueries(
-  ExprList *pEList,
-  Table *pTab
-){
-  Walker w;
-  memset(&w, 0, sizeof(w));
-  w.xExprCallback = sqlite3ExprWalkNoop;
-  w.xSelectCallback = sqlite3ReturningSubqueryCorrelated;
-  w.u.pTab = pTab;
-  sqlite3WalkExprList(&w, pEList);
-  if( w.eCode ){
-    w.xExprCallback = sqlite3ReturningSubqueryVarSelect;
-    w.xSelectCallback = sqlite3SelectWalkNoop;
-    sqlite3WalkExprList(&w, pEList);
-  }
-}
-
-/*
-** 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 *pFrom;
-  union {
-    SrcList sSrc;
-    u8 fromSpace[SZ_SRCLIST_1];
-  } uSrc;
-
-  assert( v!=0 );
-  if( !pParse->bReturning ){
-    /* This RETURNING trigger must be for a different statement as
-    ** this statement lacks a RETURNING clause. */
-    return;
-  }
-  assert( db->pParse==pParse );
-  assert( !pParse->isCreate );
-  pReturning = pParse->u1.d.pReturning;
-  if( pTrigger != &(pReturning->retTrig) ){
-    /* This RETURNING trigger is for a different statement */
-    return;
-  }
-  memset(&sSelect, 0, sizeof(sSelect));
-  memset(&uSrc, 0, sizeof(uSrc));
-  pFrom = &uSrc.sSrc;
-  sSelect.pEList = sqlite3ExprListDup(db, pReturning->pReturnEL, 0);
-  sSelect.pSrc = pFrom;
-  pFrom->nSrc = 1;
-  pFrom->a[0].pSTab = pTab;
-  pFrom->a[0].zName = pTab->zName; /* tag-20240424-1 */
-  pFrom->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;
-      sqlite3ProcessReturningSubqueries(pNew, pTab);
-      pParse->nMem += nCol+2;
-      pReturning->iRetReg = reg;
-      for(i=0; i<nCol; i++){
-        Expr *pCol = pNew->a[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,
-          sqlite3SrcListDup(db, pStep->pSrc, 0),
-          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,
-          sqlite3SrcListDup(db, pStep->pSrc, 0),
-          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,
-          sqlite3SrcListDup(db, pStep->pSrc, 0),
-          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;
-  sSubParse.oldmask = 0;
-  sSubParse.newmask = 0;
-
-  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, (u16)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].<col> 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( i<pTab->nCol );
-    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 <other-columns>, 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 <other-columns>, pChanges FROM pTabList
-**   WHERE pWhere
-**   GROUP BY <other-columns>
-**   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 <other-columns> 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 <other-columns> 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 <other-columns> 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 <other-columns>
-** 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 <other-columns> 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].pSTab;
-  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 ){
-    assert( pSrc->a[0].fg.notCte );
-    pSrc->a[0].iCursor = -1;
-    pSrc->a[0].pSTab->nTabRef--;
-    pSrc->a[0].pSTab = 0;
-  }
-  if( pPk ){
-    for(i=0; i<pPk->nKeyCol; 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; i<pTab->nCol; 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; i<pChanges->nExpr; 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; i<pTab->nCol; 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; i<pChanges->nExpr; i++){
-    /* 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;
-    }
-    j = sqlite3ColumnIndex(pTab, pChanges->a[i].zEName);
-    if( j>=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;
-    }else{
-      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; i<pTab->nCol; 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; i<pIdx->nKeyCol; 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
-       && (pWhere==0 || !ExprHasProperty(pWhere, EP_Subquery))
-      ){
-        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; i<nPk; i++){
-        assert( pPk->aiColumn[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;
-      int iNotUsed1 = 0;
-      int iNotUsed2 = 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, &iNotUsed1, &iNotUsed2);
-      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<nPk; i++){
-              sqlite3VdbeAddOp3(v, OP_Column, iEph, i, iPk+i);
-            }
-            sqlite3VdbeAddOp4Int(
-                v, OP_NotFound, iDataCur, labelContinue, iPk, nPk
-            ); VdbeCoverage(v);
-          }else{
-            sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
-            sqlite3VdbeAddOp3(
-                v, OP_NotExists, iDataCur, labelContinue, regOldRowid
-            ); VdbeCoverage(v);
-          }
-        }
-      }else{
-        sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey);
-        sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey,0);
-        VdbeCoverage(v);
-      }
-    }else{
-      sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
-      labelContinue = sqlite3VdbeMakeLabel(pParse);
-      addrTop = sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
-      VdbeCoverage(v);
-      sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
-      VdbeCoverage(v);
-    }
-  }
-
-  /* If the rowid value will change, set register regNewRowid to
-  ** contain the new value. If the rowid is not being modified,
-  ** then regNewRowid is the same register as regOldRowid, which is
-  ** already populated.  */
-  assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
-  if( chngRowid ){
-    assert( iRowidExpr>=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; i<pTab->nCol; 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 ){
-#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
-      if( isView ) sqlite3VdbeAddOp2(v, OP_Null, 0, regOldRowid);
-#endif
-      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; i<pTab->nCol; 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; i<pTab->nCol; 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);
-  }
-
-  if( pTrigger ){
-    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 ephemeral 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; i<pTab->nCol; i++){
-      if( aXRef[i]>=0 ){
-        pList = sqlite3ExprListAppend(pParse, pList,
-          sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
-        );
-      }else{
-        Expr *pRowExpr = exprRowColumn(pParse, i);
-        if( pRowExpr ) pRowExpr->op2 = OPFLAG_NOCHNG;
-        pList = sqlite3ExprListAppend(pParse, pList, pRowExpr);
-      }
-    }
-
-    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; i<pTab->nCol; 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 scanning 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; i<nArg; i++){
-      sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i);
-    }
-  }
-  sqlite3VtabMakeWritable(pParse, pTab);
-  sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB);
-  sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
-  sqlite3MayAbort(pParse);
-
-  /* End of the ephemeral table scan. Or, if using the onepass strategy,
-  ** jump to here if the scan visited zero rows. */
-  if( eOnePass==ONEPASS_OFF ){
-    sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
-    sqlite3VdbeJumpHere(v, addr);
-    sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
-  }else{
-    sqlite3WhereEnd(pWInfo);
-  }
-}
-#endif /* SQLITE_OMIT_VIRTUALTABLE */
-
-/************** End of update.c **********************************************/
-/************** Begin file upsert.c ******************************************/
-/*
-** 2018-04-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 to implement various aspects of UPSERT
-** processing and handling of the Upsert object.
-*/
-/* #include "sqliteInt.h" */
-
-#ifndef SQLITE_OMIT_UPSERT
-/*
-** Free a list of Upsert objects
-*/
-static void SQLITE_NOINLINE upsertDelete(sqlite3 *db, Upsert *p){
-  do{
-    Upsert *pNext = p->pNextUpsert;
-    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 */
-  Upsert *pAll       /* Complete list of all 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].pSTab!=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].pSTab;
-    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; ii<nn; ii++){
-        Expr *pExpr;
-        sCol[0].u.zToken = (char*)pIdx->azColl[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; jj<nn; jj++){
-          if( sqlite3ExprCompare(0,pTarget->a[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( ii<nn ){
-        /* Column ii of the index did not match any term of the conflict target.
-        ** Continue the search with the next index. */
-        continue;
-      }
-      pUpsert->pUpsertIdx = pIdx;
-      if( sqlite3UpsertOfIndex(pAll,pIdx)!=pUpsert ){
-        /* Really this should be an error.  The isDup ON CONFLICT clause will
-        ** never fire.  But this problem was not discovered until three years
-        ** after multi-CONFLICT upsert was added, and so we silently ignore
-        ** the problem to prevent breaking applications that might actually
-        ** have redundant ON CONFLICT clauses. */
-        pUpsert->isDup = 1;
-      }
-      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;
-  while( 1 /*exit-by-return*/ ){
-    if( pNext==0 ) return 1;
-    if( pNext->pUpsertTarget==0 ) return 1;
-    if( pNext->pUpsertIdx==0 ) return 1;
-    if( !pNext->isDup ) return 0;
-    pNext = pNext->pNextUpsert;
-  }
-  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; i<nPk; i++){
-        int k;
-        assert( pPk->aiColumn[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; i<pTab->nCol; 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://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 */
-  u64 iRandom;            /* Random value used for zDbVacuum[] */
-  char zDbVacuum[42];     /* Name of the ATTACH-ed database used for vacuum */
-
-
-  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 | SQLITE_Comments
-               | SQLITE_AttachCreate | SQLITE_AttachWrite;
-  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_XXXXXX'. 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 optimization would be to use a non-journaled pager.
-  ** (Later:) I tried setting "PRAGMA vacuum_XXXXXX.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.
-  */
-  sqlite3_randomness(sizeof(iRandom),&iRandom);
-  sqlite3_snprintf(sizeof(zDbVacuum), zDbVacuum, "vacuum_%016llx", iRandom);
-  nDb = db->nDb;
-  rc = execSqlF(db, pzErrMsg, "ATTACH %Q AS %s", zOut, zDbVacuum);
-  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,zDbVacuum)==0 );
-  pTemp = pDb->pBt;
-  nRes = sqlite3BtreeGetRequestedReserve(pMain);
-  if( pOut ){
-    sqlite3_file *id = sqlite3PagerFile(sqlite3BtreePager(pTemp));
-    i64 sz = 0;
-    const char *zFilename;
-    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);
-
-    /* If the VACUUM INTO target file is a URI filename and if the
-    ** "reserve=N" query parameter is present, reset the reserve to the
-    ** amount specified, if the amount is within range */
-    zFilename = sqlite3BtreeGetFilename(pTemp);
-    if( ALWAYS(zFilename) ){
-      int nNew = (int)sqlite3_uri_int64(zFilename, "reserve", nRes);
-      if( nNew>=0 && nNew<=255 ) nRes = nNew;
-    }
-  }
-
-  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 %s.'||quote(name)"
-      "||' SELECT*FROM\"%w\".'||quote(name)"
-      "FROM %s.sqlite_schema "
-      "WHERE type='table'AND coalesce(rootpage,1)>0",
-      zDbVacuum, zDbMain, zDbVacuum
-  );
-  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 %s.sqlite_schema"
-      " SELECT*FROM \"%w\".sqlite_schema"
-      " WHERE type IN('view','trigger')"
-      " OR(type='table'AND rootpage=0)",
-      zDbVacuum, 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; i<ArraySize(aCopy); i+=2){
-      /* GetMeta() and UpdateMeta() cannot fail in this context because
-      ** we already have page 1 loaded into cache and marked dirty. */
-      sqlite3BtreeGetMeta(pMain, aCopy[i], &meta);
-      rc = sqlite3BtreeUpdateMeta(pTemp, aCopy[i], meta+aCopy[i+1]);
-      if( NEVER(rc!=SQLITE_OK) ) goto end_of_vacuum;
-    }
-
-    if( pOut==0 ){
-      rc = sqlite3BtreeCopyFile(pMain, pTemp);
-    }
-    if( rc!=SQLITE_OK ) goto end_of_vacuum;
-    rc = sqlite3BtreeCommit(pTemp);
-    if( rc!=SQLITE_OK ) goto end_of_vacuum;
-#ifndef SQLITE_OMIT_AUTOVACUUM
-    if( pOut==0 ){
-      sqlite3BtreeSetAutoVacuum(pMain, sqlite3BtreeGetAutoVacuum(pTemp));
-    }
-#endif
-  }
-
-  assert( rc==SQLITE_OK );
-  if( pOut==0 ){
-    nRes = sqlite3BtreeGetRequestedReserve(pTemp);
-    rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes,1);
-  }
-
-end_of_vacuum:
-  /* Restore the original value of db->flags */
-  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;
-    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; i<p->u.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->u1.cr.regRowid holds the rowid of an
-    ** entry in the sqlite_schema table that was created for this vtab
-    ** by sqlite3StartTable().
-    */
-    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-    assert( pParse->isCreate );
-    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->u1.cr.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);
-  assert( pTab!=0 );
-  assert( pTab->nTabRef>1 || rc!=SQLITE_OK );
-  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, zModuleName);
-      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; iCol<pTab->nCol; iCol++){
-        char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
-        int nType;
-        int i = 0;
-        nType = sqlite3Strlen30(zType);
-        for(i=0; i<nType; i++){
-          if( 0==sqlite3StrNICmp("hidden", &zType[i], 6)
-           && (i==0 || zType[i-1]==' ')
-           && (zType[i+6]=='\0' || zType[i+6]==' ')
-          ){
-            break;
-          }
-        }
-        if( i<nType ){
-          int j;
-          int nDel = 6 + (zType[i+6] ? 1 : 0);
-          for(j=i; (j+nDel)<=nType; j++){
-            zType[j] = zType[j+nDel];
-          }
-          if( zType[i]=='\0' && i>0 ){
-            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;
-  int i;
-  const unsigned char *z;
-  static const u8 aKeyword[] = { TK_CREATE, TK_TABLE, 0 };
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
-    return SQLITE_MISUSE_BKPT;
-  }
-#endif
-
-  /* Verify that the first two keywords in the CREATE TABLE statement
-  ** really are "CREATE" and "TABLE".  If this is not the case, then
-  ** sqlite3_declare_vtab() is being misused.
-  */
-  z = (const unsigned char*)zCreateTable;
-  for(i=0; aKeyword[i]; i++){
-    int tokenType = 0;
-    do{
-      z += sqlite3GetToken(z, &tokenType);
-    }while( tokenType==TK_SPACE || tokenType==TK_COMMENT );
-    if( tokenType!=aKeyword[i] ){
-      sqlite3ErrorWithMsg(db, SQLITE_ERROR, "syntax error");
-      return SQLITE_ERROR;
-    }
-  }
-
-  sqlite3_mutex_enter(db->mutex);
-  pCtx = db->pVtabCtx;
-  if( !pCtx || pCtx->bDeclared ){
-    sqlite3Error(db, SQLITE_MISUSE_BKPT);
-    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) ){
-    assert( sParse.pNewTable!=0 );
-    assert( !db->mallocFailed );
-    assert( IsOrdinaryTable(sParse.pNewTable) );
-    assert( sParse.zErrMsg==0 );
-    if( !pTab->aCol ){
-      Table *pNew = sParse.pNewTable;
-      Index *pIdx;
-      pTab->aCol = pNew->aCol;
-      assert( IsOrdinaryTable(pNew) );
-      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; i<db->nVTrans; 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 && i<db->nVTrans; 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; i<db->nVTrans; 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 && i<db->nVTrans; 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; i<pToplevel->nVtabLock; 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 existence.  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));
-  db->nSchemaLock++;
-  rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
-  db->nSchemaLock--;
-  if( rc ){
-    sqlite3ErrorMsg(pParse, "%s", zErr);
-    pParse->rc = rc;
-    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 object 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 addrHalt;         /* Abort the query due to empty table or similar */
-  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 entries 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 */
-      ExprList *pOrderBy;    /* ORDER BY clause if this is really a subquery */
-    } 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 */
-      u32 bIdxNumHex : 1;    /* Show idxNum as hex in EXPLAIN QUERY PLAN */
-      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[] */
-#ifdef WHERETRACE_ENABLED
-  LogEst rStarDelta;    /* Cost delta due to star-schema heuristic.  Not
-                        ** initialized unless pWInfo->bStarUsed */
-#endif
-  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 rUnsort;       /* 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 <op> <expr>
-**
-** where X is a column name and <op> 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 <op> 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 <op> <expr>) OR (t1.Y <op> <expr>) 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 <op> */
-  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 <op> <expr>" */
-#ifdef SQLITE_DEBUG
-  int iTerm;              /* Which WhereTerm is this, for debug purposes */
-#endif
-  union {
-    struct {
-      int leftColumn;         /* Column number of X in "X <op> <expr>" */
-      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 clause */
-#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<<A.
-**
-** For example, if the WHERE clause expression used these VDBE
-** cursors:  4, 5, 8, 29, 57, 73.  Then the  WhereMaskSet structure
-** would map those cursor numbers into bits 0 through 5.
-**
-** Note that the mapping is not necessarily ordered.  In the example
-** above, the mapping might go like this:  4->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) */
-  unsigned bStarDone     :1;   /* True if check for star-query is complete */
-  unsigned bStarUsed     :1;   /* True if star-query heuristic is used */
-  LogEst nRowOut;           /* Estimated number of output rows */
-#ifdef WHERETRACE_ENABLED
-  LogEst rTotalCost;        /* Total cost of the solution */
-#endif
-  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[FLEXARRAY];  /* Information about each nest loop in WHERE */
-};
-
-/*
-** The size (in bytes) of a WhereInfo object that holds N WhereLevels.
-*/
-#define SZ_WHEREINFO(N) ROUND8(offsetof(WhereInfo,a)+(N)*sizeof(WhereLevel))
-
-/*
-** 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(const WhereLoop *p, const 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 */
-);
-SQLITE_PRIVATE void sqlite3WhereAddExplainText(
-  Parse *pParse,                  /* Parse context */
-  int addr,
-  SrcList *pTabList,              /* Table list this loop refers to */
-  WhereLevel *pLevel,             /* Scan to write OP_Explain opcode for */
-  u16 wctrlFlags                  /* Flags passed to sqlite3WhereBegin() */
-);
-#else
-# define sqlite3WhereExplainOneScan(u,v,w,x) 0
-# define sqlite3WhereExplainBloomFilter(u,v,w) 0
-# define  sqlite3WhereAddExplainText(u,v,w,x,y)
-#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  /* x<EXPR and/or x>EXPR */
-#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  /* x<EXPR or x<=EXPR constraint */
-#define WHERE_BTM_LIMIT    0x00000020  /* x>EXPR or x>=EXPR constraint */
-#define WHERE_BOTH_LIMIT   0x00000030  /* Both x>EXPR and x<EXPR */
-#define WHERE_IDX_ONLY     0x00000040  /* Use index only - omit table */
-#define WHERE_IPK          0x00000100  /* x is the INTEGER PRIMARY KEY */
-#define WHERE_INDEXED      0x00000200  /* WhereLoop.u.btree.pIndex is valid */
-#define WHERE_VIRTUALTABLE 0x00000400  /* WhereLoop.u.vtab is valid */
-#define WHERE_IN_ABLE      0x00000800  /* Able to support an IN operator */
-#define WHERE_ONEROW       0x00001000  /* Selects no more than one row */
-#define WHERE_MULTI_OR     0x00002000  /* OR using multiple indices */
-#define WHERE_AUTO_INDEX   0x00004000  /* Uses an ephemeral index */
-#define WHERE_SKIPSCAN     0x00008000  /* Uses the skip-scan algorithm */
-#define WHERE_UNQ_WANTED   0x00010000  /* WHERE_ONEROW would have been helpful*/
-#define WHERE_PARTIALIDX   0x00020000  /* The automatic index is partial */
-#define WHERE_IN_EARLYOUT  0x00040000  /* Perhaps quit IN loops early */
-#define WHERE_BIGNULL_SORT 0x00080000  /* Column nEq of index is BIGNULL */
-#define WHERE_IN_SEEKSCAN  0x00100000  /* Seek-scan optimization for IN */
-#define WHERE_TRANSCONS    0x00200000  /* Uses a transitive constraint */
-#define WHERE_BLOOMFILTER  0x00400000  /* Consider using a Bloom-filter */
-#define WHERE_SELFCULL     0x00800000  /* nOut reduced by extra WHERE terms */
-#define WHERE_OMIT_OFFSET  0x01000000  /* Set offset counter to zero */
-#define WHERE_COROUTINE    0x02000000  /* Implemented by co-routine.
-                                       ** NB: False-negatives are possible */
-#define WHERE_EXPRIDX      0x04000000  /* Uses an index-on-expressions */
-
-#endif /* !defined(SQLITE_WHEREINT_H) */
-
-/************** End of whereInt.h ********************************************/
-/************** Continuing where we left off in wherecode.c ******************/
-
-#ifndef SQLITE_OMIT_EXPLAIN
-
-/*
-** Return the name of the i-th column of the pIdx index.
-*/
-static const char *explainIndexColumnName(Index *pIdx, int i){
-  i = pIdx->aiColumn[i];
-  if( i==XN_EXPR ) return "<expr>";
-  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; i<nTerm; i++){
-    if( i ) sqlite3_str_append(pStr, ",", 1);
-    sqlite3_str_appendall(pStr, explainIndexColumnName(pIdx, iTerm+i));
-  }
-  if( nTerm>1 ) sqlite3_str_append(pStr, ")", 1);
-
-  sqlite3_str_append(pStr, zOp, 1);
-
-  if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1);
-  for(i=0; i<nTerm; i++){
-    if( i ) sqlite3_str_append(pStr, ",", 1);
-    sqlite3_str_append(pStr, "?", 1);
-  }
-  if( nTerm>1 ) 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<nEq; i++){
-    const char *z = explainIndexColumnName(pIndex, i);
-    if( i ) sqlite3_str_append(pStr, " AND ", 5);
-    sqlite3_str_appendf(pStr, 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 sets the P4 value of an existing OP_Explain opcode to
-** text describing the loop in pLevel. If the OP_Explain opcode already has
-** a P4 value, it is freed before it is overwritten.
-*/
-SQLITE_PRIVATE void sqlite3WhereAddExplainText(
-  Parse *pParse,                  /* Parse context */
-  int addr,                       /* Address of OP_Explain opcode */
-  SrcList *pTabList,              /* Table list this loop refers to */
-  WhereLevel *pLevel,             /* Scan to write OP_Explain opcode for */
-  u16 wctrlFlags                  /* Flags passed to sqlite3WhereBegin() */
-){
-#if !defined(SQLITE_DEBUG)
-  if( sqlite3ParseToplevel(pParse)->explain==2 || IS_STMT_SCANSTATUS(pParse->db) )
-#endif
-  {
-    VdbeOp *pOp = sqlite3VdbeGetOp(pParse->pVdbe, addr);
-    SrcItem *pItem = &pTabList->a[pLevel->iFrom];
-    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 */
-#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_EXPLAIN)
-    char *zMsg;                   /* Text to add to EQP output */
-#endif
-    StrAccum str;                 /* EQP output string */
-    char zBuf[100];               /* Initial space for EQP output string */
-
-    if( db->mallocFailed ) return;
-
-    pLoop = pLevel->pWLoop;
-    flags = pLoop->wsFlags;
-
-    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%s",
-       isSearch ? "SEARCH" : "SCAN",
-       pItem,
-       pItem->fg.fromExists ? " EXISTS" : "");
-    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->pSTab) && 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|WHERE_EXPRIDX) ){
-        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_appendall(&str, " VIRTUAL TABLE INDEX ");
-      sqlite3_str_appendf(&str,
-                  pLoop->u.vtab.bIdxNumHex ? "0x%x:%s" : "%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
-#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_EXPLAIN)
-    zMsg = sqlite3StrAccumFinish(&str);
-    sqlite3ExplainBreakpoint("",zMsg);
-#endif
-
-    assert( pOp->opcode==OP_Explain );
-    assert( pOp->p4type==P4_DYNAMIC || pOp->p4.z==0 );
-    sqlite3DbFree(db, pOp->p4.z);
-    pOp->p4type = P4_DYNAMIC;
-    pOp->p4.z = sqlite3StrAccumFinish(&str);
-  }
-}
-
-
-/*
-** 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
-  {
-    if( (pLevel->pWLoop->wsFlags & WHERE_MULTI_OR)==0
-     && (wctrlFlags & WHERE_OR_SUBCLAUSE)==0
-    ){
-      Vdbe *v = pParse->pVdbe;
-      int addr = sqlite3VdbeCurrentAddr(v);
-      ret = sqlite3VdbeAddOp3(
-          v, OP_Explain, addr, pParse->addrExplain, pLevel->pWLoop->rRun
-      );
-      sqlite3WhereAddExplainText(pParse, addr, pTabList, pLevel, wctrlFlags);
-    }
-  }
-  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->pSTab;
-    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; i<pLoop->u.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);
-      }
-    }else{
-      int addr;
-      VdbeOp *pOp;
-      assert( pSrclist->a[pLvl->iFrom].fg.isSubquery );
-      addr = pSrclist->a[pLvl->iFrom].u4.pSubq->addrFillSub;
-      pOp = sqlite3VdbeGetOp(v, addr-1);
-      assert( sqlite3VdbeDb(v)->mallocFailed || pOp->opcode==OP_InitCoroutine );
-      assert( sqlite3VdbeDb(v)->mallocFailed || pOp->p2>addr );
-      sqlite3VdbeScanStatusRange(v, addrExplain, addr, pOp->p2-1);
-    }
-  }
-}
-#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_NONE<SQLITE_AFF_BLOB );
-  while( n>0 && 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; i<n; i++){
-    Expr *p = sqlite3VectorFieldSubexpr(pRight, i);
-    if( sqlite3CompareAffinity(p, zAff[i])==SQLITE_AFF_BLOB
-     || sqlite3ExprNeedsNoAffinityChange(p, zAff[i])
-    ){
-      zAff[i] = SQLITE_AFF_BLOB;
-    }
-  }
-}
-
-/*
-** The pOrderBy->a[].u.x.iOrderByCol values might be incorrect because
-** columns might have been rearranged in the result set.  This routine
-** fixes them up.
-**
-** pEList is the new result set.  The pEList->a[].u.x.iOrderByCol values
-** contain the *old* locations of each expression.  This is a temporary
-** use of u.x.iOrderByCol, not its intended use.  The caller must reset
-** u.x.iOrderByCol back to zero for all entries in pEList before the
-** caller returns.
-**
-** This routine changes pOrderBy->a[].u.x.iOrderByCol values from
-** pEList->a[N].u.x.iOrderByCol into N+1.  (The "+1" is because of the 1-based
-** indexing used by iOrderByCol.)  Or if no match, iOrderByCol is set to zero.
-*/
-static void adjustOrderByCol(ExprList *pOrderBy, ExprList *pEList){
-  int i, j;
-  if( pOrderBy==0 ) return;
-  for(i=0; i<pOrderBy->nExpr; i++){
-    int t = pOrderBy->a[i].u.x.iOrderByCol;
-    if( t==0 ) continue;
-    for(j=0; j<pEList->nExpr; j++){
-      if( pEList->a[j].u.x.iOrderByCol==t ){
-        pOrderBy->a[i].u.x.iOrderByCol = j+1;
-        break;
-      }
-    }
-    if( j>=pEList->nExpr ){
-      pOrderBy->a[i].u.x.iOrderByCol = 0;
-    }
-  }
-}
-
-
-/*
-** pX is an expression of the form:  (vector) IN (SELECT ...)
-** In other words, it is a vector IN operator with a SELECT clause on the
-** RHS.  But not all terms in the vector are indexable and the terms might
-** not be in the correct order for indexing.
-**
-** This routine makes a copy of the input pX expression and then adjusts
-** the vector on the LHS with corresponding changes to the SELECT so that
-** the vector contains only index terms and those terms are in the correct
-** order.  The modified IN expression is returned.  The caller is responsible
-** for deleting the returned expression.
-**
-** Example:
-**
-**    CREATE TABLE t1(a,b,c,d,e,f);
-**    CREATE INDEX t1x1 ON t1(e,c);
-**    SELECT * FROM t1 WHERE (a,b,c,d,e) IN (SELECT v,w,x,y,z FROM t2)
-**                           \_______________________________________/
-**                                     The pX expression
-**
-** Since only columns e and c can be used with the index, in that order,
-** the modified IN expression that is returned will be:
-**
-**        (e,c) IN (SELECT z,x FROM t2)
-**
-** The reduced pX is different from the original (obviously) and thus is
-** only used for indexing, to improve performance.  The original unaltered
-** IN expression must also be run on each output row for correctness.
-*/
-static Expr *removeUnindexableInClauseTerms(
-  Parse *pParse,        /* The parsing context */
-  int iEq,              /* Look at loop terms starting here */
-  WhereLoop *pLoop,     /* The current loop */
-  Expr *pX              /* The IN expression to be reduced */
-){
-  sqlite3 *db = pParse->db;
-  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; i<pLoop->nLTerm; 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( NEVER(pOrigRhs->a[iField].pExpr==0) ){
-            continue; /* Duplicate PK column */
-          }
-          pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
-          pOrigRhs->a[iField].pExpr = 0;
-          if( pRhs ) pRhs->a[pRhs->nExpr-1].u.x.iOrderByCol = iField+1;
-          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;
-      pSelect->selId = ++pParse->nSelect; /* Req'd for SubrtnSig validity */
-      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 either the ORDER BY clause or the GROUP BY clause contains
-      ** references to result-set columns, those references might now be
-      ** obsolete.  So fix them up.
-      */
-      assert( pRhs!=0 || db->mallocFailed );
-      if( pRhs ){
-        adjustOrderByCol(pSelect->pOrderBy, pRhs);
-        adjustOrderByCol(pSelect->pGroupBy, pRhs);
-        for(i=0; i<pRhs->nExpr; i++) pRhs->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;
-}
-
-
-#ifndef SQLITE_OMIT_SUBQUERY
-/*
-** Generate code for a single X IN (....) term of the WHERE clause.
-**
-** This is a special-case of codeEqualityTerm() that works for IN operators
-** only.  It is broken out into a subroutine because this case is
-** uncommon and by splitting it off into a subroutine, the common case
-** runs faster.
-**
-** The current value for the constraint is left in  register iTarget.
-** This routine sets up a loop that will iterate over all values of X.
-*/
-static SQLITE_NOINLINE void codeINTerm(
-  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;
-  int eType = IN_INDEX_NOOP;
-  int iTab;
-  struct InLoop *pIn;
-  WhereLoop *pLoop = pLevel->pWLoop;
-  Vdbe *v = pParse->pVdbe;
-  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 );
-
-  for(i=0; i<iEq; i++){
-    if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
-      disableTerm(pLevel, pTerm);
-      return;
-    }
-  }
-  for(i=iEq; i<pLoop->nLTerm; 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{
-    sqlite3 *db = pParse->db;
-    Expr *pXMod = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX);
-    if( !db->mallocFailed ){
-      aiMap = (int*)sqlite3DbMallocZero(db, sizeof(int)*nEq);
-      eType = sqlite3FindInIndex(pParse, pXMod, IN_INDEX_LOOP, 0, aiMap, &iTab);
-    }
-    sqlite3ExprDelete(db, pXMod);
-  }
-
-  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; i<pLoop->nLTerm; i++){
-      if( pLoop->aLTerm[i]->pExpr==pX ){
-        int iOut = iTarget + 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 = iTarget - 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
-
-
-/*
-** 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;
-  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(pParse->pVdbe, OP_Null, 0, iReg);
-#ifndef SQLITE_OMIT_SUBQUERY
-  }else{
-    assert( pX->op==TK_IN );
-    iReg = iTarget;
-    codeINTerm(pParse, pTerm, pLevel, iEq, bRev, iTarget);
-#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 = 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; j<nSkip; j++){
-      sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, j, regBase+j);
-      testcase( pIdx->aiColumn[j]==XN_EXPR );
-      VdbeComment((v, "%s", explainIndexColumnName(pIdx, j)));
-    }
-  }
-
-  /* Evaluate the equality constraints
-  */
-  assert( zAff==0 || (int)strlen(zAff)>=nEq );
-  for(j=nSkip; j<nEq; j++){
-    int r1;
-    pTerm = pLoop->aLTerm[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);
-      }
-    }
-    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 identified
-** 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; i<pWC->nBase; 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; j<pLoop->nLTerm && pLoop->aLTerm[j]!=pTerm; j++){}
-      if( j<pLoop->nLTerm ) 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; i<pIdx->nColumn-1; i++){
-        int x1, x2;
-        assert( pIdx->aiColumn[i]<pTab->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; i<nReg; i++){
-        sqlite3ExprCode(pParse, pList->a[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; i<pWC->nTerm; 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 */
-){
-  int saved_addrBrk;
-  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;
-    saved_addrBrk = pLevel->addrBrk;
-    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 = saved_addrBrk;
-  }
-}
-
-/*
-** Loop pLoop is a WHERE_INDEXED level that uses at least one IN(...)
-** operator. Return true if level pLoop is guaranteed to visit only one
-** row for each key generated for the index.
-*/
-static int whereLoopIsOneRow(WhereLoop *pLoop){
-  if( pLoop->u.btree.pIndex->onError
-   && pLoop->nSkip==0
-   && pLoop->u.btree.nEq==pLoop->u.btree.pIndex->nKeyCol
-  ){
-    int ii;
-    for(ii=0; ii<pLoop->u.btree.nEq; ii++){
-      if( pLoop->aLTerm[ii]->eOperator & (WO_IS|WO_ISNULL) ){
-        return 0;
-      }
-    }
-    return 1;
-  }
-  return 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 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->pSTab->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->addrNxt = pLevel->addrBrk;
-  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 match flag"));
-  }
-
-  /* Special case of a FROM clause subquery implemented as a co-routine */
-  if( pTabItem->fg.viaCoroutine ){
-    int regYield;
-    Subquery *pSubq;
-    assert( pTabItem->fg.isSubquery && pTabItem->u4.pSubq!=0 );
-    pSubq = pTabItem->u4.pSubq;
-    regYield = pSubq->regReturn;
-    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSubq->addrFillSub);
-    pLevel->p2 =  sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk);
-    VdbeCoverage(v);
-    VdbeComment((v, "next row of %s", pTabItem->pSTab->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; j<nConstraint; j++){
-      int iTarget = iReg+j+2;
-      pTerm = pLoop->aLTerm[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, 0);
-          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);
-    /* The instruction immediately prior to OP_VFilter must be an OP_Integer
-    ** that sets the "argc" value for xVFilter.  This is necessary for
-    ** resolveP2() to work correctly.  See tag-20250207a. */
-    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; j<nConstraint; j++){
-      pTerm = pLoop->aLTerm[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(iIn<pLevel->u.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 correct. */
-
-      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, pLevel->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: Search using an index.
-    **
-    ** The WHERE clause may contain zero or more equality
-    ** terms ("==" or "IN" or "IS" 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 "==", "IN", or "IS" 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( (nEq<pIdx->nColumn && 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; j<pPk->nKeyCol; 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.  This optimization does not work on an outer join,
-      ** as shown by:
-      **
-      ** 2019-11-02 ticket 623eff57e76d45f6      (LEFT JOIN)
-      ** 2025-05-29 forum post 7dee41d32506c4ae  (RIGHT JOIN)
-      */
-      if( pIdx->pPartIdxWhere && pLevel->pRJ==0 ){
-        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->u.in.nIn && regBignull==0 && whereLoopIsOneRow(pLoop))
-    ){
-      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(<term>)
-    **          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: <loop body>                 # Return data, whatever.
-    **
-    **          Return     2                # Jump back to the Gosub
-    **
-    **       B: <after the loop>
-    **
-    ** 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->pSTab;
-
-    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 || pTabItem->fg.fromExists ){
-      int nNotReady;                 /* The number of notReady tables */
-      SrcItem *origSrc;              /* Original list of tables */
-      nNotReady = pWInfo->nLevel - iLevel - 1;
-      pOrTab = sqlite3DbMallocRawNN(db, SZ_SRCLIST(nNotReady+1));
-      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]));
-      }
-
-      /* Clear the fromExists flag on the OR-optimized table entry so that
-      ** the calls to sqlite3WhereEnd() do not code early-exits after the
-      ** first row is visited. The early exit applies to this table's
-      ** overall loop - including the multiple OR branches and any WHERE
-      ** conditions not passed to the sub-loops - not to the sub-loops.  */
-      pOrTab->a[0].fg.fromExists = 0;
-    }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://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; iTerm<pWC->nTerm; 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; ii<pOrWc->nTerm; 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; iPk<nPk; iPk++){
-                int iCol = pPk->aiColumn[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->pTabList!=pOrTab ){ 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,pLevel->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.
-  **
-  ** This optimization of causing simple query restrictions to occur before
-  ** more complex one is call the "push-down" optimization in MySQL.  Here
-  ** in SQLite, the name is "MySQL push-down", since there is also another
-  ** totally unrelated optimization called "WHERE-clause push-down".
-  ** Sometimes the qualifier is omitted, resulting in an ambiguity, so beware.
-  */
-  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].pSTab;
-    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; iPk<nPk; iPk++){
-        int iCol = pPk->aiColumn[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; j<pWC->nBase; 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 *pFrom;
-  union {
-    SrcList sSrc;
-    u8 fromSpace[SZ_SRCLIST_1];
-  } uSrc;
-  Bitmask mAll = 0;
-  int k;
-
-  ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pSTab->zName));
-  sqlite3VdbeNoJumpsOutsideSubrtn(v, pRJ->addrSubrtn, pRJ->endSubrtn,
-                                  pRJ->regReturn);
-  for(k=0; k<iLevel; k++){
-    int iIdxCur;
-    SrcItem *pRight;
-    assert( pWInfo->a[k].pWLoop->iTab == pWInfo->a[k].iFrom );
-    pRight = &pWInfo->pTabList->a[pWInfo->a[k].iFrom];
-    mAll |= pWInfo->a[k].pWLoop->maskSelf;
-    if( pRight->fg.viaCoroutine ){
-      Subquery *pSubq;
-      assert( pRight->fg.isSubquery && pRight->u4.pSubq!=0 );
-      pSubq = pRight->u4.pSubq;
-      assert( pSubq->pSelect!=0 && pSubq->pSelect->pEList!=0 );
-      sqlite3VdbeAddOp3(
-          v, OP_Null, 0, pSubq->regResult,
-          pSubq->regResult + pSubq->pSelect->pEList->nExpr-1
-      );
-    }
-    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; k<pWC->nTerm; 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));
-    }
-  }
-  if( pLevel->iIdxCur ){
-    /* pSubWhere may contain expressions that read from an index on the
-    ** table on the RHS of the right join. All such expressions first test
-    ** if the index is pointing at a NULL row, and if so, read from the
-    ** table cursor instead. So ensure that the index cursor really is
-    ** pointing at a NULL row here, so that no values are read from it during
-    ** the scan of the RHS of the RIGHT join below.  */
-    sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur);
-  }
-  pFrom = &uSrc.sSrc;
-  pFrom->nSrc = 1;
-  pFrom->nAlloc = 1;
-  memcpy(&pFrom->a[0], pTabItem, sizeof(SrcItem));
-  pFrom->a[0].fg.jointype = 0;
-  assert( pParse->withinRJSubrtn < 100 );
-  pParse->withinRJSubrtn++;
-  pSubWInfo = sqlite3WhereBegin(pParse, pFrom, 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->pSTab;
-    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; iPk<nPk; iPk++){
-        int iCol = pPk->aiColumn[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 editability.  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_GT<TK_GE );
-  assert( TK_LT>TK_EQ && TK_LT<TK_GE );
-  assert( TK_LE>TK_EQ && TK_LE<TK_GE );
-  assert( TK_GE==TK_EQ+4 );
-  assert( TK_IN<TK_EQ );
-  assert( TK_IS<TK_EQ );
-  assert( TK_ISNULL<TK_EQ );
-  if( op>TK_GE ) return 0;
-  if( op>=TK_EQ ) return 1;
-  return op==TK_IN || 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_GT<TK_LE );
-    assert( pExpr->op>=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_EQ ){
-    assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
-    c = (u16)(WO_EQ<<(op-TK_EQ));
-  }else if( op==TK_IN ){
-    c = WO_IN;
-  }else if( op==TK_ISNULL ){
-    c = WO_ISNULL;
-  }else{
-    assert( op==TK_IS );
-    c = WO_IS;
-  }
-  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 bytes prior to the first wildcard,
-    ** U+fffd character, or malformed utf-8. If the underlying database
-    ** has a UTF16LE encoding, then only consider ASCII characters.  Note that
-    ** the encoding of z[] is UTF8 - we are dealing with only UTF8 here in this
-    ** code, but the database engine itself might be processing content using a
-    ** different encoding. */
-    cnt = 0;
-    while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
-      cnt++;
-      if( c==wc[3] && z[cnt]>0 && z[cnt]<0x80 ){
-        cnt++;
-      }else if( c>=0x80 ){
-        const u8 *z2 = z+cnt-1;
-        if( c==0xff || sqlite3Utf8Read(&z2)==0xfffd  /* bad utf-8 */
-         || ENC(db)==SQLITE_UTF16LE
-        ){
-          cnt--;
-          break;
-        }else{
-          cnt = (int)(z2-z);
-        }
-      }
-    }
-
-    /* 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>1 || (cnt>0 && z[0]!=wc[3])) && ALWAYS(255!=(u8)z[cnt-1]) ){
-      Expr *pPrefix;
-
-      /* A "complete" match if the pattern ends with "*" or "%" */
-      *pisComplete = c==wc[0] && z[cnt+1]==0 && ENC(db)!=SQLITE_UTF16LE;
-
-      /* 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; iFrom<cnt; iFrom++){
-          if( zNew[iFrom]==wc[3] ) iFrom++;
-          zNew[iTo++] = zNew[iFrom];
-        }
-        zNew[iTo] = 0;
-        assert( iTo>0 );
-
-        /* 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;
-          assert( zNew[iTo]==0 );
-          isNum = sqlite3AtoF(zNew, &rDummy);
-          if( isNum<=0 ){
-            if( iTo==1 && zNew[0]=='-' ){
-              isNum = +1;
-            }else{
-              zNew[iTo-1]++;
-              isNum = sqlite3AtoF(zNew, &rDummy);
-              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 */
-
-/*
-** If pExpr is one of "like", "glob", "match", or "regexp", then
-** return the corresponding SQLITE_INDEX_CONSTRAINT_xxxx value.
-** If not, return 0.
-**
-** pExpr is guaranteed to be a TK_FUNCTION.
-*/
-SQLITE_PRIVATE int sqlite3ExprIsLikeOperator(const Expr *pExpr){
-  static const struct {
-    const char *zOp;
-    unsigned char eOp;
-  } aOp[] = {
-    { "match",  SQLITE_INDEX_CONSTRAINT_MATCH },
-    { "glob",   SQLITE_INDEX_CONSTRAINT_GLOB },
-    { "like",   SQLITE_INDEX_CONSTRAINT_LIKE },
-    { "regexp", SQLITE_INDEX_CONSTRAINT_REGEXP }
-  };
-  int i;
-  assert( pExpr->op==TK_FUNCTION );
-  assert( !ExprHasProperty(pExpr, EP_IntValue) );
-  for(i=0; i<ArraySize(aOp); i++){
-    if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
-      return aOp[i].eOp;
-    }
-  }
-  return 0;
-}
-
-
-#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 ){
-    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) && (i = sqlite3ExprIsLikeOperator(pExpr))!=0 ){
-      *peOp2 = i;
-      *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_EQ ){
-    /* Comparison operators are a common case.  Save a few comparisons for
-    ** that common case by terminating early. */
-    assert( TK_NE < TK_EQ );
-    assert( TK_ISNOT < TK_EQ );
-    assert( TK_NOTNULL < TK_EQ );
-    return 0;
-  }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( N<pTerm->u.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<y OR x=y    -->     x<=y
-**    x=y OR x=y    -->     x=y
-**    x<=y OR x<y   -->     x<=y
-**
-** The following is NOT generated:
-**
-**    x<y OR x>y    -->     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 */
-  Expr *pA, *pB;         /* Expressions associated with pOne and pTwo */
-
-  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;
-  pA = pOne->pExpr;
-  pB = pTwo->pExpr;
-  assert( pA->pLeft!=0 && pA->pRight!=0 );
-  assert( pB->pLeft!=0 && pB->pRight!=0 );
-  if( sqlite3ExprCompare(0,pA->pLeft, pB->pLeft, -1) )  return;
-  if( sqlite3ExprCompare(0,pA->pRight, pB->pRight,-1) ) return;
-  if( ExprHasProperty(pA,EP_Commuted)!=ExprHasProperty(pB,EP_Commuted) ){
-    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, pA, 0);
-  if( pNew==0 ) return;
-  for(op=TK_EQ; eOp!=(WO_EQ<<(op-TK_EQ)); op++){ assert( op<TK_GE ); }
-  pNew->op = 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 <op> <expr>" where C is any column of table T and
-** <op> 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; j<pAndWC->nTerm; 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 followed 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 operator is not IS or else the query does not contain RIGHT JOIN
-**   5.  The affinities of A and B must be compatible
-**   6a. Both operands use the same collating sequence OR
-**   6b. 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, SrcList *pSrc){
-  char aff1, aff2;
-  CollSeq *pColl;
-  if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0;  /* (1) */
-  if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;                 /* (2) */
-  if( ExprHasProperty(pExpr, EP_OuterON) ) return 0;                   /* (3) */
-  assert( pSrc!=0 );
-  if( pExpr->op==TK_IS
-   && pSrc->nSrc>=2
-   && (pSrc->a[0].fg.jointype & JT_LTORJ)!=0
-  ){
-    return 0;                                                          /* (4) */
-  }
-  aff1 = sqlite3ExprAffinity(pExpr->pLeft);
-  aff2 = sqlite3ExprAffinity(pExpr->pRight);
-  if( aff1!=aff2
-   && (!sqlite3IsNumericAffinity(aff1) || !sqlite3IsNumericAffinity(aff2))
-  ){
-    return 0;                                                          /* (5) */
-  }
-  pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);
-  if( !sqlite3IsBinary(pColl)
-   && !sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight)
-  ){
-    return 0;                                                          /* (6) */
-  }
-  return 1;
-}
-
-/*
-** 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; i<pSrc->nSrc; i++){
-        if( pSrc->a[i].fg.isSubquery ){
-          mask |= exprSelectUsage(pMaskSet, pSrc->a[i].u4.pSubq->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].pSTab->pIndex; pIdx; pIdx=pIdx->pNext){
-      if( pIdx->aColExpr==0 ) continue;
-      for(i=0; i<pIdx->nKeyCol; i++){
-        if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
-        assert( pIdx->bHasExpr );
-        if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
-         && !sqlite3ExprIsConstant(0,pIdx->aColExpr->a[i].pExpr)
-        ){
-          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_IS<TK_GE && TK_ISNULL<TK_GE && TK_IN<TK_GE );
-  assert( op<=TK_GE );
-  if( pExpr->op==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; i<pFrom->nSrc; i++){
-    Index *pIdx;
-    for(pIdx=pFrom->a[i].pSTab->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 "<expr> <op> X" it gets commuted
-** to the standard form of "X <op> <expr>".
-**
-** If the expression is of the form "X <op> Y" where both X and Y are
-** columns, then the original expression is unchanged and a new virtual
-** term of the form "Y <op> 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;              /* Prerequisites of the pExpr->pLeft */
-  Bitmask prereqAll;               /* Prerequisites 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];
-#ifdef SQLITE_DEBUG
-  pTerm->iTerm = idxTerm;
-#endif
-  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 */
-    }else if( (prereqAll>>1)>=x ){
-      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;
-        assert( pWInfo->pTabList!=0 );
-        if( termIsEquivalence(pParse, pDup, pWInfo->pTabList) ){
-          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 *pC;       /* Last character before the first wildcard */
-      pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
-      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( *pC=='A'-1 ) isComplete = 0;
-        *pC = sqlite3UpperToLower[*pC];
-      }
-
-      /* Increment the value of the last utf8 character in the prefix. */
-      while( *pC==0xBF && pC>(u8*)pStr2->u.zToken ){
-        *pC = 0x80;
-        pC--;
-      }
-      assert( *pC!=0xFF );        /* isLikeOrGlob() guarantees this */
-      (*pC)++;
-    }
-    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; i<nLeft; i++){
-      int idxNew;
-      Expr *pNew;
-      Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, 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; i<sqlite3ExprVectorSize(pExpr->pLeft); 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 | extraRight;
-        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, pParse) && iVal>=0 ){
-    Expr *pVal = sqlite3ExprInt32(db, iVal);
-    if( pVal==0 ) return;
-    pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
-  }else{
-    Expr *pVal = sqlite3ExprAlloc(db, TK_REGISTER, 0, 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].pSTab))      /* 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; ii<pWC->nTerm; 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 && pWC->a[ii].prereqRight==0 ) continue;
-
-      /* If this term has a parent with exactly one child, and the parent will
-      ** be passed through to xBestIndex, then this term can be ignored.  */
-      if( pWC->a[ii].iParent>=0 ){
-        WhereTerm *pParent = &pWC->a[ pWC->a[ii].iParent ];
-        if( pParent->leftCursor==iCsr
-         && pParent->prereqRight==0
-         && pParent->nChild==1
-        ){
-          continue;
-        }
-      }
-
-      /* This term will not be passed through. Do not add a LIMIT clause. */
-      return;
-    }
-
-    /* Check condition (5). Return early if it is not met. */
-    if( pOrderBy ){
-      for(ii=0; ii<pOrderBy->nExpr; 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 );
-    if( p->iOffset!=0 && (p->selFlags & SF_Compound)==0 ){
-      whereAddLimitExpr(pWC, p->iOffset, p->pLimit->pRight,
-                        iCsr, SQLITE_INDEX_CONSTRAINT_OFFSET);
-    }
-    if( p->iOffset==0 || (p->selFlags & SF_Compound)==0 ){
-      whereAddLimitExpr(pWC, p->iLimit, p->pLimit->pLeft,
-                        iCsr, SQLITE_INDEX_CONSTRAINT_LIMIT);
-    }
-  }
-}
-
-/*
-** 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; i<pWC->nTerm; 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; i<pList->nExpr; 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->pSTab;
-  assert( pTab!=0 );
-  pArgs = pItem->u1.pFuncArg;
-  if( pArgs==0 ) return;
-  for(j=k=0; j<pArgs->nExpr; j++){
-    Expr *pRhs;
-    u32 joinType;
-    while( k<pTab->nCol && (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 <col> IN (...) */
-  u32 mHandleIn;           /* Terms that vtab will handle as <col> IN (...) */
-  sqlite3_value *aRhs[FLEXARRAY];  /* RHS values for constraints. MUST BE LAST
-                                   ** Extra space is allocated to hold up
-                                   ** to nTerm such values */
-};
-
-/* Size (in bytes) of a HiddenIndeInfo object sufficient to hold as
-** many as N constraints */
-#define SZ_HIDDENINDEXINFO(N) \
-                  (offsetof(HiddenIndexInfo,aRhs) + (N)*sizeof(sqlite3_value*))
-
-/* 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->n<N_OR_COST ){
-    p = &pSet->a[pSet->n++];
-    p->nOut = nOut;
-  }else{
-    p = pSet->a;
-    for(i=1; i<pSet->n; 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; i<pMaskSet->n; 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->sz<nByte );
-    memcpy(pNew, pOld, pOldBlk->sz);
-  }
-  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;
-}
-
-/*
-** Term pTerm is guaranteed to be a WO_IN term. It may be a component term
-** of a vector IN expression of the form "(x, y, ...) IN (SELECT ...)".
-** This function checks to see if the term is compatible with an index
-** column with affinity idxaff (one of the SQLITE_AFF_XYZ values). If so,
-** it returns a pointer to the name of the collation sequence (e.g. "BINARY"
-** or "NOCASE") used by the comparison in pTerm. If it is not compatible
-** with affinity idxaff, NULL is returned.
-*/
-static SQLITE_NOINLINE const char *indexInAffinityOk(
-  Parse *pParse,
-  WhereTerm *pTerm,
-  u8 idxaff
-){
-  Expr *pX = pTerm->pExpr;
-  Expr inexpr;
-
-  assert( pTerm->eOperator & WO_IN );
-
-  if( sqlite3ExprIsVector(pX->pLeft) ){
-    int iField = pTerm->u.x.iField - 1;
-    inexpr.flags = 0;
-    inexpr.op = TK_EQ;
-    inexpr.pLeft = pX->pLeft->x.pList->a[iField].pExpr;
-    assert( ExprUseXSelect(pX) );
-    inexpr.pRight = pX->x.pSelect->pEList->a[iField].pExpr;
-    pX = &inexpr;
-  }
-
-  if( sqlite3IndexAffinityOk(pX, idxaff) ){
-    CollSeq *pRet = sqlite3ExprCompareCollSeq(pParse, pX);
-    return pRet ? pRet->zName : sqlite3StrBINARY;
-  }
-  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; k<pWC->nTerm; 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->nEquiv<ArraySize(pScan->aiCur)
-           && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0
-          ){
-            int j;
-            for(j=0; j<pScan->nEquiv; 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 ){
-              const char *zCollName;
-              Parse *pParse = pWC->pWInfo->pParse;
-              pX = pTerm->pExpr;
-
-              if( (pTerm->eOperator & WO_IN) ){
-                zCollName = indexInAffinityOk(pParse, pTerm, pScan->idxaff);
-                if( !zCollName ) continue;
-              }else{
-                CollSeq *pColl;
-                if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){
-                  continue;
-                }
-                assert(pX->pLeft);
-                pColl = sqlite3ExprCompareCollSeq(pParse, pX);
-                zCollName = pColl ? pColl->zName : sqlite3StrBINARY;
-              }
-
-              if( sqlite3StrICmp(zCollName, 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)!=0 && pScan->nEquiv>1 ){
-              int ii;
-              sqlite3DebugPrintf("EQUIVALENT TO {%d:%d} (due to TERM-%d):",
-                 pScan->aiCur[0], pScan->aiColumn[0], pTerm->iTerm);
-              for(ii=1; ii<pScan->nEquiv; 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 <op> <expr>" 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 <op> 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 <op> <expr>".  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 <op> <expr>"
-** where X is a reference to the iColumn of table iCur or of index pIdx
-** if pIdx!=0 and <op> 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=<expr> 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 <expr> if X=A1
-** and A1=A2 and A2=A3 and ... and A9=A10 and A10=<expr>.
-**
-** If there are multiple terms in the WHERE clause of the form "X <op> <expr>"
-** then try for the one with no dependencies on <expr> - in other words where
-** <expr> is a constant expression of some kind.  Only return entries of
-** the form "X <op> Y" where Y is a column in another table if no terms of
-** the form "X <op> <const-expr>" 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; i<pList->nExpr; 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 && iCol<pIdx->nColumn );
-  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].pSTab;
-
-  /* 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; i<pDistinct->nExpr; 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; i<pIdx->nKeyCol; 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;
-#ifdef SQLITE_DEBUG
-  if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
-    printf("CHECKING for column-to-copy on cursor %d for %d..%d\n",
-            iTabCur, iStart, iEnd);
-  }
-#endif
-  for(; iStart<iEnd; iStart++, pOp++){
-    if( pOp->p1!=iTabCur ) continue;
-    if( pOp->opcode==OP_Column ){
-#ifdef SQLITE_DEBUG
-      if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
-        printf("TRANSLATE OP_Column to OP_Copy at %d\n", iStart);
-      }
-#endif
-      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 ){
-#ifdef SQLITE_DEBUG
-      if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
-        printf("TRANSLATE OP_Rowid to OP_Sequence at %d\n", iStart);
-      }
-#endif
-      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,   /* The IndexInfo object */
-  Table *pTab              /* The TABLE that is the virtual table */
-){
-  int i;
-  if( (sqlite3WhereTrace & 0x10)==0 ) return;
-  sqlite3DebugPrintf("sqlite3_index_info inputs for %s:\n", pTab->zName);
-  for(i=0; i<p->nConstraint; 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; i<p->nOrderBy; 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,   /* The IndexInfo object */
-  Table *pTab              /* The TABLE that is the virtual table */
-){
-  int i;
-  if( (sqlite3WhereTrace & 0x10)==0 ) return;
-  sqlite3DebugPrintf("sqlite3_index_info outputs for %s:\n", pTab->zName);
-  for(i=0; i<p->nConstraint; 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,B)
-#define whereTraceIndexInfoOutputs(A,B)
-#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
-   && NEVER(ExprHasProperty(pTerm->pExpr, EP_InnerON))
-  ){
-    return 0;
-  }
-  return 1;
-}
-
-#ifndef SQLITE_OMIT_AUTOMATIC_INDEX
-/*
-** Return true if column iCol of table pTab seem like it might be a
-** good column to use as part of a query-time index.
-**
-** Current algorithm (subject to improvement!):
-**
-**   1.   If iCol is already the left-most column of some other index,
-**        then return false.
-**
-**   2.   If iCol is part of an existing index that has an aiRowLogEst of
-**        more than 20, then return false.
-**
-**   3.   If no disqualifying conditions above are found, return true.
-**
-** 2025-01-03: I experimented with a new rule that returns false if the
-** the datatype of the column is "BOOLEAN". This did not improve
-** performance on any queries at hand, but it did burn CPU cycles, so the
-** idea was not committed.
-*/
-static SQLITE_NOINLINE int columnIsGoodIndexCandidate(
-  const Table *pTab,
-  int iCol
-){
-  const Index *pIdx;
-  for(pIdx = pTab->pIndex; pIdx!=0; pIdx=pIdx->pNext){
-    int j;
-    for(j=0; j<pIdx->nKeyCol; j++){
-       if( pIdx->aiColumn[j]==iCol ){
-         if( j==0 ) return 0;
-         if( pIdx->hasStat1 && pIdx->aiRowLogEst[j+1]>20 ) return 0;
-         break;
-       }
-    }
-  }
-  return 1;
-}
-#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */
-
-
-
-#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;
-  int leftCol;
-
-  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 );
-  leftCol = pTerm->u.x.leftColumn;
-  if( leftCol<0 ) return 0;
-  aff = pSrc->pSTab->aCol[leftCol].affinity;
-  if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
-  testcase( pTerm->pExpr->op==TK_IS );
-  return columnIsGoodIndexCandidate(pSrc->pSTab, leftCol);
-}
-#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 <table>(<cols>) [WHERE <expr>]
-**
-** 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 || !HasRowid(pTab) );
-    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 <expr>" : "")
-      );
-      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->pSTab;
-  pWCEnd = &pWC->a[pWC->nTerm];
-  pLoop = pLevel->pWLoop;
-  idxCols = 0;
-  for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
-    Expr *pExpr = pTerm->pExpr;
-    /* 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, 0)
-    ){
-      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 & ~idxCols;
-  }else{
-    extraCols = pSrc->colUsed & (~idxCols | MASKBIT(BMS-1));
-  }
-  if( !HasRowid(pTable) ){
-    /* For WITHOUT ROWID tables, ensure that all PRIMARY KEY columns are
-    ** either in the idxCols mask or in the extraCols mask */
-    for(i=0; i<pTable->nCol; i++){
-      if( (pTable->aCol[i].colFlags & COLFLAG_PRIMKEY)==0 ) continue;
-      if( i>=BMS-1 ){
-        extraCols |= MASKBIT(BMS-1);
-        break;
-      }
-      if( idxCols & MASKBIT(i) ) continue;
-      extraCols |= MASKBIT(i);
-    }
-  }
-  mxBitCol = MIN(BMS-1,pTable->nCol);
-  testcase( pTable->nCol==BMS-1 );
-  testcase( pTable->nCol==BMS-2 );
-  for(i=0; i<mxBitCol; i++){
-    if( extraCols & MASKBIT(i) ) nKeyCol++;
-  }
-  if( pSrc->colUsed & MASKBIT(BMS-1) ){
-    nKeyCol += pTable->nCol - BMS + 1;
-  }
-
-  /* Construct the Index object to describe this index */
-  assert( nKeyCol <= pTable->nCol + MAX(0, pTable->nCol - BMS + 1) );
-  /* ^-- This guarantees that the number of index columns will fit in the u16 */
-  pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+HasRowid(pTable),
-                                    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; pTerm<pWCEnd; pTerm++){
-    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-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; i<mxBitCol; i++){
-    if( extraCols & MASKBIT(i) ){
-      pIdx->aiColumn[n] = i;
-      pIdx->azColl[n] = sqlite3StrBINARY;
-      n++;
-    }
-  }
-  if( pSrc->colUsed & MASKBIT(BMS-1) ){
-    for(i=BMS-1; i<pTable->nCol; i++){
-      pIdx->aiColumn[n] = i;
-      pIdx->azColl[n] = sqlite3StrBINARY;
-      n++;
-    }
-  }
-  assert( n==nKeyCol );
-  if( HasRowid(pTable) ){
-    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;
-    Subquery *pSubq;
-    assert( pSrc->fg.isSubquery );
-    pSubq = pSrc->u4.pSubq;
-    assert( pSubq!=0 );
-    regYield = pSubq->regReturn;
-    addrCounter = sqlite3VdbeAddOp2(v, OP_Integer, 0, 0);
-    sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSubq->addrFillSub);
-    addrTop =  sqlite3VdbeAddOp1(v, OP_Yield, regYield);
-    VdbeCoverage(v);
-    VdbeComment((v, "next row of %s", pSrc->pSTab->zName));
-  }else{
-    assert( pLevel->addrHalt );
-    addrTop = sqlite3VdbeAddOp2(v, OP_Rewind,pLevel->iTabCur,pLevel->addrHalt);
-    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 ){
-    assert( pSrc->fg.isSubquery && pSrc->u4.pSubq!=0 );
-    sqlite3VdbeChangeP2(v, addrCounter, regBase+n);
-    testcase( pParse->db->mallocFailed );
-    assert( pLevel->iIdxCur>0 );
-    translateColumnToCopy(pParse, addrTop, pLevel->iTabCur,
-                          pSrc->u4.pSubq->regResult, pLevel->iIdxCur);
-    sqlite3VdbeGoto(v, addrTop);
-    pSrc->fg.viaCoroutine = 0;
-    sqlite3VdbeJumpHere(v, addrTop);
-  }else{
-    sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v);
-    sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX);
-    if( (pSrc->fg.jointype & JT_LEFT)!=0 ){
-      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 */
-  IndexedExpr *saved_pIdxPartExpr;     /* saved copy of Parse.pIdxPartExpr */
-
-  saved_pIdxEpr = pParse->pIdxEpr;
-  saved_pIdxPartExpr = pParse->pIdxPartExpr;
-  pParse->pIdxEpr = 0;
-  pParse->pIdxPartExpr = 0;
-
-  assert( pLoop!=0 );
-  assert( v!=0 );
-  assert( pLoop->wsFlags & WHERE_BLOOMFILTER );
-  assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 );
-
-  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->pSTab;
-    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; pTerm<pWCEnd; pTerm++){
-      Expr *pExpr = pTerm->pExpr;
-      if( (pTerm->wtFlags & TERM_VIRTUAL)==0
-       && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, iSrc, 0)
-      ){
-        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; jj<n; jj++){
-        assert( pIdx->pTable==pItem->pSTab );
-        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;
-  pParse->pIdxPartExpr = saved_pIdxPartExpr;
-}
-
-
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-/*
-** Return term iTerm of the WhereClause passed as the first argument. Terms
-** are numbered from 0 upwards, starting with the terms in pWC->a[], then
-** those in pWC->pOuter->a[] (if any), and so on.
-*/
-static WhereTerm *termFromWhereClause(WhereClause *pWC, int iTerm){
-  WhereClause *p;
-  for(p=pWC; p; p=p->pOuter){
-    if( iTerm<p->nTerm ) return &p->a[iTerm];
-    iTerm -= p->nTerm;
-  }
-  return 0;
-}
-
-/*
-** 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;
-  WhereClause *p;
-
-  assert( pSrc!=0 );
-  pTab = pSrc->pSTab;
-  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(p=pWC, nTerm=0; p; p=p->pOuter){
-    for(i=0, pTerm=p->a; i<p->nTerm; 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.leftColumn<pTab->nCol );
-      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; i<n; i++){
-      Expr *pExpr = pOrderBy->a[i].pExpr;
-      Expr *pE2;
-
-      /* Skip over constant terms in the ORDER BY clause */
-      if( sqlite3ExprIsConstant(0, 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->iColumn<pTab->nCol );
-        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->iColumn<pTab->nCol );
-        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 ){
-      int bSortByGroup = (pWInfo->wctrlFlags & WHERE_SORTBYGROUP)!=0;
-      nOrderBy = n;
-      if( (pWInfo->wctrlFlags & WHERE_DISTINCTBY) && !pSrc->fg.rowidUsed ){
-        eDistinct = 2 + bSortByGroup;
-      }else if( pWInfo->wctrlFlags & WHERE_GROUPBY ){
-        eDistinct = 1 - bSortByGroup;
-      }else if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){
-        eDistinct = 3;
-      }
-    }
-  }
-
-  /* Allocate the sqlite3_index_info structure
-  */
-  pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
-                           + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm
-                           + sizeof(*pIdxOrderBy)*nOrderBy
-                           + SZ_HIDDENINDEXINFO(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;
-  pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed;
-  if( HasRowid(pTab)==0 ){
-    /* Ensure that all bits associated with PK columns are set. This is to
-    ** ensure they are available for cases like RIGHT joins or OR loops. */
-    Index *pPk = sqlite3PrimaryKeyIndex((Table*)pTab);
-    assert( pPk!=0 );
-    for(i=0; i<pPk->nKeyCol; i++){
-      int iCol = pPk->aiColumn[i];
-      assert( iCol>=0 );
-      if( iCol>=BMS-1 ) iCol = BMS-1;
-      pIdxInfo->colUsed |= MASKBIT(iCol);
-    }
-  }
-  pHidden->pWC = pWC;
-  pHidden->pParse = pParse;
-  pHidden->eDistinct = eDistinct;
-  pHidden->mIn = 0;
-  for(p=pWC, i=j=0; p; p=p->pOuter){
-    int nLast = i+p->nTerm;;
-    for(pTerm=p->a; i<nLast; 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; i<nOrderBy; i++){
-    Expr *pExpr = pOrderBy->a[i].pExpr;
-    if( sqlite3ExprIsConstant(0, 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 and zero the sqlite3_index_info.idxStr value if needed.
-*/
-static void freeIdxStr(sqlite3_index_info *pIdxInfo){
-  if( pIdxInfo->needToFreeIdxStr ){
-    sqlite3_free(pIdxInfo->idxStr);
-    pIdxInfo->idxStr = 0;
-    pIdxInfo->needToFreeIdxStr = 0;
-  }
-}
-
-/*
-** 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; i<pIdxInfo->nConstraint; i++){
-    sqlite3ValueFree(pHidden->aRhs[i]); /* IMP: R-14553-25174 */
-    pHidden->aRhs[i] = 0;
-  }
-  freeIdxStr(pIdxInfo);
-  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){
-  int rc;
-  sqlite3_vtab *pVtab;
-
-  assert( IsVirtual(pTab) );
-  pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
-  whereTraceIndexInfoInputs(p, pTab);
-  pParse->db->nSchemaLock++;
-  rc = pVtab->pModule->xBestIndex(pVtab, p);
-  pParse->db->nSchemaLock--;
-  whereTraceIndexInfoOutputs(p, pTab);
-
-  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; n<nField; n++){
-        if( aSample[iSamp-1].anLt[n-1]!=aSample[iSamp].anLt[n-1] ) break;
-      }
-    }else{
-      n = iTest + 1;
-    }
-
-    pRec->nField = 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 && n<nField ){
-      iLower = aSample[iSamp].anLt[n-1];
-      iMin = iTest+1;
-      res = -1;
-    }else{
-      iSample = iTest;
-      iCol = n-1;
-    }
-  }while( res && iMin<iSample );
-  i = iSample / nField;
-
-#ifdef SQLITE_DEBUG
-  /* The following assert statements check that the binary search code
-  ** above found the right answer. This block serves no purpose other
-  ** than to invoke the asserts.  */
-  if( pParse->db->mallocFailed==0 ){
-    if( res==0 ){
-      /* If (res==0) is true, then pRec must be equal to sample i. */
-      assert( i<pIdx->nSample );
-      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 && iCol<pIdx->nColumn );
-  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 performed 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 && i<p->nSample; 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 x<?) reduces the expected number of
-** rows visited by a factor of 64.
-*/
-static int whereRangeScanEst(
-  Parse *pParse,       /* Parsing & code generating context */
-  WhereLoopBuilder *pBuilder,
-  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     /* 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(nEq<p->nSampleCol)
-   && 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( iNew<iUpper ) iUpper = iNew;
-          nOut--;
-          pUpper = 0;
-        }
-      }
-
-      pBuilder->pRec = 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( nNew<nOut ){
-          nOut = nNew;
-        }
-        WHERETRACE(0x20, ("STAT4 range scan: %u..%u  est=%d\n",
-                           (u32)iLower, (u32)iUpper, nOut));
-      }
-    }else{
-      int bDone = 0;
-      rc = whereRangeSkipScanEst(pParse, pLower, pUpper, pLoop, &bDone);
-      if( bDone ) return rc;
-    }
-  }
-#else
-  UNUSED_PARAMETER(pParse);
-  UNUSED_PARAMETER(pBuilder);
-  assert( pLower || pUpper );
-#endif
-  assert( pUpper==0 || (pUpper->wtFlags & 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( nNew<nOut ) nOut = nNew;
-#if defined(WHERETRACE_ENABLED)
-  if( pLoop->nOut>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->nRecValid<nEq );
-
-  /* If values are not available for all fields of the index to the left
-  ** of this one, no estimate can be made. Return SQLITE_NOTFOUND. */
-  if( pBuilder->nRecValid<(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 && i<pList->nExpr; 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 */
-
-
-#if defined(WHERETRACE_ENABLED) || defined(SQLITE_DEBUG)
-/*
-** 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);
-    }
-    iTerm = pTerm->iTerm = MAX(iTerm,pTerm->iTerm);
-    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);
-  }
-}
-SQLITE_PRIVATE void sqlite3ShowWhereTerm(WhereTerm *pTerm){
-  sqlite3WhereTermPrint(pTerm, 0);
-}
-#endif
-
-#ifdef WHERETRACE_ENABLED
-/*
-** Show the complete content of a WhereClause
-*/
-SQLITE_PRIVATE void sqlite3WhereClausePrint(WhereClause *pWC){
-  int i;
-  for(i=0; i<pWC->nTerm; i++){
-    sqlite3WhereTermPrint(&pWC->a[i], i);
-  }
-}
-#endif
-
-#ifdef WHERETRACE_ENABLED
-/*
-** Print a WhereLoop object for debugging purposes
-**
-** Format example:
-**
-**     .--- Position in WHERE clause           rSetup, rRun, nOut ---.
-**     |                                                             |
-**     |  .--- selfMask                       nTerm ------.          |
-**     |  |                                               |          |
-**     |  |   .-- prereq    Idx          wsFlags----.     |          |
-**     |  |   |             Name                    |     |          |
-**     |  |   |           __|__        nEq ---.  ___|__   |        __|__
-**     | / \ / \         /     \              | /      \ / \      /     \
-**     1.002.001         t2.t2xy              2 f 010241 N 2 cost 0,56,31
-*/
-SQLITE_PRIVATE void sqlite3WhereLoopPrint(const WhereLoop *p, const WhereClause *pWC){
-  WhereInfo *pWInfo;
-  if( pWC ){
-    int nb;
-    SrcItem *pItem;
-    Table *pTab;
-    Bitmask mAll;
-
-    pWInfo = pWC->pWInfo;
-    nb = 1+(pWInfo->pTabList->nSrc+3)/4;
-    pItem = pWInfo->pTabList->a + p->iTab;
-    pTab = pItem->pSTab;
-    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);
-  }else{
-    pWInfo = 0;
-    sqlite3DebugPrintf("%c%2d.%03llx.%03llx %c%d",
-         p->cId, p->iTab, p->maskSelf, p->prereq & 0xfff, p->cId, p->iTab);
-  }
-  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);
-  }
-  if( pWInfo && pWInfo->bStarUsed && p->rStarDelta!=0 ){
-    sqlite3DebugPrintf(" cost %d,%d,%d delta=%d\n",
-                       p->rSetup, p->rRun, p->nOut, p->rStarDelta);
-  }else{
-    sqlite3DebugPrintf(" cost %d,%d,%d\n", p->rSetup, p->rRun, p->nOut);
-  }
-  if( p->nLTerm && (sqlite3WhereTrace & 0x4000)!=0 ){
-    int i;
-    for(i=0; i<p->nLTerm; i++){
-      sqlite3WhereTermPrint(p->aLTerm[i], i);
-    }
-  }
-}
-SQLITE_PRIVATE void sqlite3ShowWhereLoop(const WhereLoop *p){
-  if( p ) sqlite3WhereLoopPrint(p, 0);
-}
-SQLITE_PRIVATE void sqlite3ShowWhereLoopList(const WhereLoop *p){
-  while( p ){
-    sqlite3ShowWhereLoop(p);
-    p = p->pNextLoop;
-  }
-}
-#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 X is a proper subset of Y but is of equal or less cost.
-** In other words, return true if all constraints of X are also part of Y
-** and Y has additional constraints that might speed the search that X lacks
-** but the cost of running X is not more than the cost of running Y.
-**
-** In other words, return true if the cost relationship between X and Y
-** is inverted and needs to be adjusted.
-**
-** Case 1:
-**
-**   (1a)  X and Y use the same index.
-**   (1b)  X has fewer == terms than Y
-**   (1c)  Neither X nor Y use skip-scan
-**   (1d)  X does not have a a greater cost than Y
-**
-** Case 2:
-**
-**   (2a)  X has the same or lower cost, or returns the same or fewer rows,
-**         than Y.
-**   (2b)  X uses fewer WHERE clause terms than Y
-**   (2c)  Every WHERE clause term used by X is also used by Y
-**   (2d)  X skips at least as many columns as Y
-**   (2e)  If X is a covering index, than Y is too
-*/
-static int whereLoopCheaperProperSubset(
-  const WhereLoop *pX,       /* First WhereLoop to compare */
-  const WhereLoop *pY        /* Compare against this WhereLoop */
-){
-  int i, j;
-  if( pX->rRun>pY->rRun && pX->nOut>pY->nOut ) return 0; /* (1d) and (2a) */
-  assert( (pX->wsFlags & WHERE_VIRTUALTABLE)==0 );
-  assert( (pY->wsFlags & WHERE_VIRTUALTABLE)==0 );
-  if( pX->u.btree.nEq < pY->u.btree.nEq                  /* (1b) */
-   && pX->u.btree.pIndex==pY->u.btree.pIndex             /* (1a) */
-   && pX->nSkip==0 && pY->nSkip==0                       /* (1c) */
-  ){
-    return 1;  /* Case 1 is true */
-  }
-  if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){
-    return 0;                                            /* (2b) */
-  }
-  if( pY->nSkip > pX->nSkip ) return 0;                  /* (2d) */
-  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;                                  /* (2c) */
-  }
-  if( (pX->wsFlags&WHERE_IDX_ONLY)!=0
-   && (pY->wsFlags&WHERE_IDX_ONLY)==0 ){
-    return 0;                                            /* (2e) */
-  }
-  return 1;  /* Case 2 is true */
-}
-
-/*
-** 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 application-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 dependencies 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 supplanted 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;
-}
-
-/*
-** Callback for estLikePatternLength().
-**
-** If this node is a string literal that is longer pWalker->sz, then set
-** pWalker->sz to the byte length of that string literal.
-**
-** pWalker->eCode indicates how to count characters:
-**
-**    eCode==0     Count as a GLOB pattern
-**    eCode==1     Count as a LIKE pattern
-*/
-static int exprNodePatternLengthEst(Walker *pWalker, Expr *pExpr){
-  if( pExpr->op==TK_STRING ){
-    int sz = 0;                    /* Pattern size in bytes */
-    u8 *z = (u8*)pExpr->u.zToken;  /* The pattern */
-    u8 c;                          /* Next character of the pattern */
-    u8 c1, c2, c3;                 /* Wildcards */
-    if( pWalker->eCode ){
-      c1 = '%';
-      c2 = '_';
-      c3 = 0;
-    }else{
-      c1 = '*';
-      c2 = '?';
-      c3 = '[';
-    }
-    while( (c = *(z++))!=0 ){
-      if( c==c3 ){
-        if( *z ) z++;
-        while( *z && *z!=']' ) z++;
-      }else if( c!=c1 && c!=c2 ){
-        sz++;
-      }
-    }
-    if( sz>pWalker->u.sz ) pWalker->u.sz = sz;
-  }
-  return WRC_Continue;
-}
-
-/*
-** Return the length of the longest string literal in the given
-** expression.
-**
-** eCode indicates how to count characters:
-**
-**    eCode==0     Count as a GLOB pattern
-**    eCode==1     Count as a LIKE pattern
-*/
-static int estLikePatternLength(Expr *p, u16 eCode){
-  Walker w;
-  w.u.sz = 0;
-  w.eCode = eCode;
-  w.xExprCallback = exprNodePatternLengthEst;
-  w.xSelectCallback = sqlite3SelectWalkFail;
-#ifdef SQLITE_DEBUG
-  w.xSelectCallback2 = sqlite3SelectWalkAssert2;
-#endif
-  sqlite3WalkExpr(&w, p);
-  return w.u.sz;
-}
-
-/*
-** 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.
-**
-** Heuristic 3:  If there is a LIKE or GLOB (or REGEXP or MATCH) operator
-** with a large constant pattern, then reduce the size of the search
-** space according to the length of the pattern, under the theory that
-** longer patterns are less likely to match.  This heuristic was added
-** to give better output-row count estimates when preparing queries for
-** the Join-Order Benchmarks.  See forum thread 2026-01-30T09:57:54z
-*/
-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. */
-        Expr *pOpExpr = pTerm->pExpr;
-        pLoop->nOut--;
-        if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0
-         && (pTerm->wtFlags & TERM_HIGHTRUTH)==0  /* tag-20200224-1 */
-        ){
-          Expr *pRight = pOpExpr->pRight;
-          int k = 0;
-          testcase( pOpExpr->op==TK_IS );
-          if( sqlite3ExprIsInteger(pRight, &k, 0) && k>=(-1) && k<=1 ){
-            k = 10;
-          }else{
-            k = 20;
-          }
-          if( iReduce<k ){
-            pTerm->wtFlags |= TERM_HEURTRUTH;
-            iReduce = k;
-          }
-        }else
-        if( ExprHasProperty(pOpExpr, EP_InfixFunc)
-         && pOpExpr->op==TK_FUNCTION
-        ){
-          int eOp;
-          assert( ExprUseXList(pOpExpr) );
-          assert( pOpExpr->x.pList->nExpr>=2 );
-          eOp = sqlite3ExprIsLikeOperator(pOpExpr);
-          if( ALWAYS(eOp>0) ){
-            int szPattern;
-            Expr *pRHS = pOpExpr->x.pList->a[0].pExpr;
-            eOp = eOp==SQLITE_INDEX_CONSTRAINT_LIKE;
-            szPattern = estLikePatternLength(pRHS, eOp);
-            if( szPattern>0 ){
-              pLoop->nOut -= szPattern*2;
-            }
-          }
-        }
-      }
-    }
-  }
-  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; i<nCmp; i++){
-    /* Test if comparison i of pTerm is compatible with column (i+nEq)
-    ** of the index. If not, exit the loop.  */
-    char aff;                     /* Comparison affinity */
-    char idxaff = 0;              /* Indexed columns affinity */
-    CollSeq *pColl;               /* Comparison collation sequence */
-    Expr *pLhs, *pRhs;
-
-    assert( ExprUseXList(pTerm->pExpr->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 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
-    if( pColl==0 ) break;
-    if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break;
-  }
-  return i;
-}
-
-/*
-** Adjust the cost C by the costMult factor 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 analyze 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.nEq<pProbe->nColumn );
-  assert( pNew->u.btree.nEq<pProbe->nKeyCol
-       || 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;
-        int bRedundant = 0;
-        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; i<pNew->nLTerm-1; i++){
-          if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ){
-            nIn = 0;
-            if( pNew->aLTerm[i]->u.x.iField == pTerm->u.x.iField ){
-              /* Detect when two or more columns of an index match the same
-              ** column of a vector IN operater, and avoid adding the column
-              ** to the WhereLoop more than once.  See tag-20250707-01
-              ** in test/rowvalue.test */
-              bRedundant = 1;
-            }
-          }
-        }
-        if( bRedundant ){
-          pNew->nLTerm--;
-          continue;
-        }
-      }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))<pTerm->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 estimated cost of visiting selected rows in the
-    ** index.  The estimate is the sum of two values:
-    **   1.  The cost of doing one search-by-key to find the first matching
-    **       entry
-    **   2.  Stepping forward in the index pNew->nOut times to find all
-    **       additional matching entries.
-    */
-    assert( pSrc->pSTab->szTabRow>0 );
-    if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){
-      /* The pProbe->szIdxRow is low for an IPK table since the interior
-      ** pages are small.  Thus 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->pSTab->szTabRow;
-    }
-    rCostIdx = sqlite3LogEstAdd(rLogSize, rCostIdx);
-
-    /* Estimate the cost of running the loop.  If all data is coming
-    ** from the index, then this is just the cost of doing the index
-    ** lookup and scan.  But if some data is coming out of the main table,
-    ** we also have to add in the cost of doing pNew->nOut searches to
-    ** locate the row in the main table that corresponds to the index entry.
-    */
-    pNew->rRun = 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);
-    if( pSrc->fg.fromExists ) pNew->nOut = 0;
-    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.nEq<pProbe->nColumn
-     && (pNew->u.btree.nEq<pProbe->nKeyCol ||
-          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+1<pProbe->nKeyCol
-   && 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 */
-   && pSrc->fg.fromExists==0
-   && (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; ii<pOB->nExpr; ii++){
-    Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr);
-    if( NEVER(pExpr==0) ) continue;
-    if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN)
-     && pExpr->iTable==iCursor
-    ){
-      if( pExpr->iColumn<0 ) return 1;
-      for(jj=0; jj<pIndex->nKeyCol; jj++){
-        if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
-      }
-    }else if( (aColExpr = pIndex->aColExpr)!=0 ){
-      for(jj=0; jj<pIndex->nKeyCol; 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;
-  }
-  for(i=0, pTerm=pWC->a; i<pWC->nTerm; 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)
-     && !sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, -1)
-     && (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; i<pIdx->nColumn; 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; i<nColumn; i++){
-      if( aiColumn[i]==pExpr->iColumn ) 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; i<pIdx->nColumn; 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;
-}
-
-/*
-** 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){
-  IndexedExpr **pp = (IndexedExpr**)pObject;
-  while( *pp!=0 ){
-    IndexedExpr *p = *pp;
-    *pp = p->pIENext;
-    sqlite3ExprDelete(db, p->pExpr);
-    sqlite3DbFreeNN(db, p);
-  }
-}
-
-/*
-** This function is called for a partial index - one with a WHERE clause - in
-** two scenarios. In both cases, it determines whether or not the WHERE
-** clause on the index implies that a column of the table may be safely
-** replaced by a constant expression. For example, in the following
-** SELECT:
-**
-**   CREATE INDEX i1 ON t1(b, c) WHERE a=<expr>;
-**   SELECT a, b, c FROM t1 WHERE a=<expr> AND b=?;
-**
-** The "a" in the select-list may be replaced by <expr>, iff:
-**
-**    (a) <expr> is a constant expression, and
-**    (b) The (a=<expr>) comparison uses the BINARY collation sequence, and
-**    (c) Column "a" has an affinity other than NONE or BLOB.
-**
-** If argument pItem is NULL, then pMask must not be NULL. In this case this
-** function is being called as part of determining whether or not pIdx
-** is a covering index. This function clears any bits in (*pMask)
-** corresponding to columns that may be replaced by constants as described
-** above.
-**
-** Otherwise, if pItem is not NULL, then this function is being called
-** as part of coding a loop that uses index pIdx. In this case, add entries
-** to the Parse.pIdxPartExpr list for each column that can be replaced
-** by a constant.
-*/
-static void wherePartIdxExpr(
-  Parse *pParse,                  /* Parse context */
-  Index *pIdx,                    /* Partial index being processed */
-  Expr *pPart,                    /* WHERE clause being processed */
-  Bitmask *pMask,                 /* Mask to clear bits in */
-  int iIdxCur,                    /* Cursor number for index */
-  SrcItem *pItem                  /* The FROM clause entry for the table */
-){
-  assert( pItem==0 || (pItem->fg.jointype & JT_RIGHT)==0 );
-  assert( (pItem==0 || pMask==0) && (pMask!=0 || pItem!=0) );
-
-  if( pPart->op==TK_AND ){
-    wherePartIdxExpr(pParse, pIdx, pPart->pRight, pMask, iIdxCur, pItem);
-    pPart = pPart->pLeft;
-  }
-
-  if( (pPart->op==TK_EQ || pPart->op==TK_IS) ){
-    Expr *pLeft = pPart->pLeft;
-    Expr *pRight = pPart->pRight;
-    u8 aff;
-
-    if( pLeft->op!=TK_COLUMN ) return;
-    if( !sqlite3ExprIsConstant(0, pRight) ) return;
-    if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pParse, pPart)) ) return;
-    if( pLeft->iColumn<0 ) return;
-    aff = pIdx->pTable->aCol[pLeft->iColumn].affinity;
-    if( aff>=SQLITE_AFF_TEXT ){
-      if( pItem ){
-        sqlite3 *db = pParse->db;
-        IndexedExpr *p = (IndexedExpr*)sqlite3DbMallocRaw(db, sizeof(*p));
-        if( p ){
-          int bNullRow = (pItem->fg.jointype&(JT_LEFT|JT_LTORJ))!=0;
-          p->pExpr = sqlite3ExprDup(db, pRight, 0);
-          p->iDataCur = pItem->iCursor;
-          p->iIdxCur = iIdxCur;
-          p->iIdxCol = pLeft->iColumn;
-          p->bMaybeNullRow = bNullRow;
-          p->pIENext = pParse->pIdxPartExpr;
-          p->aff = aff;
-          pParse->pIdxPartExpr = p;
-          if( p->pIENext==0 ){
-            void *pArg = (void*)&pParse->pIdxPartExpr;
-            sqlite3ParserAddCleanup(pParse, whereIndexedExprCleanup, pArg);
-          }
-        }
-      }else if( pLeft->iColumn<(BMS-1) ){
-        *pMask &= ~((Bitmask)1 << pLeft->iColumn);
-      }
-    }
-  }
-}
-
-
-/*
-** 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 prerequisites 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->pSTab;
-  pWC = pBuilder->pWC;
-  assert( !IsVirtual(pSrc->pSTab) );
-
-  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->pSTab->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 */
-   && !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 && pTerm<pWCEnd; pTerm++){
-      if( pTerm->prereqRight & 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->u.btree.nDistinctCol = 0;
-    pNew->nSkip = 0;
-    pNew->nLTerm = 0;
-    pNew->iSortIdx = 0;
-    pNew->rSetup = 0;
-    pNew->prereq = mPrereq;
-    pNew->nOut = rSize;
-    pNew->u.btree.pIndex = pProbe;
-    pNew->u.btree.pOrderBy = 0;
-    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
-      ApplyCostMultiplier(pNew->rRun, pTab->costMult);
-      whereLoopOutputAdjust(pWC, pNew, rSize);
-      if( pSrc->fg.isSubquery ){
-        if( pSrc->fg.viaCoroutine ) pNew->wsFlags |= WHERE_COROUTINE;
-        /* Do not set btree.pOrderBy for a recursive CTE. In this case
-        ** the ORDER BY clause does not determine the overall order that
-        ** rows are emitted from the CTE in.  */
-        if( (pSrc->u4.pSubq->pSelect->selFlags & SF_Recursive)==0 ){
-          pNew->u.btree.pOrderBy = pSrc->u4.pSubq->pSelect->pOrderBy;
-        }
-      }else if( pSrc->fg.fromExists ){
-        pNew->nOut = 0;
-      }
-      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;
-        if( pProbe->pPartIdxWhere ){
-          wherePartIdxExpr(
-              pWInfo->pParse, pProbe, pProbe->pPartIdxWhere, &m, 0, 0
-          );
-        }
-        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
-           && (HasRowid(pTab) || pWInfo->pSelect!=0 || sqlite3FaultSim(700))
-        ){
-          WHERETRACE(0x200,
-             ("-> %s is 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->szIdxRow<pTab->szTabRow)
-         && (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; ii<pWC2->nTerm; 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{
-          if( pSrc->fg.fromExists ) pNew->nOut = 0;
-          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_MaybeReanalyze;
-    }
-#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;
-}
-
-/*
-** Return true if the first nCons constraints in the pUsage array are
-** marked as in-use (have argvIndex>0). False otherwise.
-*/
-static int allConstraintsUsed(
-  struct sqlite3_index_constraint_usage *aUsage,
-  int nCons
-){
-  int ii;
-  for(ii=0; ii<nCons; ii++){
-    if( aUsage[ii].argvIndex<=0 ) return 0;
-  }
-  return 1;
-}
-
-/*
-** 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; i<nConstraint; i++, pIdxCons++){
-    WhereTerm *pTerm = termFromWhereClause(pWC, 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;
-  pHidden->mHandleIn = 0;
-
-  /* Invoke the virtual table xBestIndex() method */
-  rc = vtabBestIndex(pParse, pSrc->pSTab, 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"));
-      freeIdxStr(pIdxInfo);
-      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<nConstraint; i++, pIdxCons++){
-    int iTerm;
-    if( (iTerm = pUsage[i].argvIndex - 1)>=0 ){
-      WhereTerm *pTerm;
-      int j = pIdxCons->iTermOffset;
-      if( iTerm>=nConstraint
-       || j<0
-       || (pTerm = termFromWhereClause(pWC, j))==0
-       || pNew->aLTerm[iTerm]!=0
-       || pIdxCons->usable==0
-      ){
-        sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pSTab->zName);
-        freeIdxStr(pIdxInfo);
-        return SQLITE_ERROR;
-      }
-      testcase( iTerm==nConstraint-1 );
-      testcase( j==0 );
-      testcase( j==pWC->nTerm-1 );
-      pNew->prereq |= pTerm->prereqRight;
-      assert( iTerm<pNew->nLSlot );
-      pNew->aLTerm[iTerm] = pTerm;
-      if( iTerm>mxTerm ) mxTerm = iTerm;
-      testcase( iTerm==15 );
-      testcase( iTerm==16 );
-      if( pUsage[i].omit ){
-        if( i<16 && ((1<<i)&mNoOmit)==0 ){
-          testcase( i!=iTerm );
-          pNew->u.vtab.omitMask |= 1<<iTerm;
-        }else{
-          testcase( i!=iTerm );
-        }
-        if( pTerm->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 );
-      }
-
-      /* Unless pbRetryLimit is non-NULL, there should be no LIMIT/OFFSET
-      ** terms. And if there are any, they should follow all other terms. */
-      assert( pbRetryLimit || !isLimitTerm(pTerm) );
-      assert( !isLimitTerm(pTerm) || i>=nConstraint-2 );
-      assert( !isLimitTerm(pTerm) || i==nConstraint-1 || isLimitTerm(pTerm+1) );
-
-      if( isLimitTerm(pTerm) && (*pbIn || !allConstraintsUsed(pUsage, i)) ){
-        /* 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. Similarly,
-        ** if there is a LIMIT/OFFSET and there are other unused terms,
-        ** the plan cannot be used. In these cases set variable *pbRetryLimit
-        ** to true to tell the caller to retry with LIMIT and OFFSET
-        ** disabled. */
-        freeIdxStr(pIdxInfo);
-        *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->pSTab->zName);
-      freeIdxStr(pIdxInfo);
-      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->u.vtab.bIdxNumHex = (pIdxInfo->idxFlags&SQLITE_INDEX_SCAN_HEX)!=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 constraint, 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 && iCons<pIdxInfo->nConstraint ){
-    CollSeq *pC = 0;
-    int iTerm = pIdxInfo->aConstraint[iCons].iTermOffset;
-    Expr *pX = termFromWhereClause(pHidden->pWC, 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_BKPT; /* EV: R-30545-25046 */
-  }else{
-    if( pH->aRhs[iCons]==0 ){
-      WhereTerm *pTerm = termFromWhereClause(
-          pH->pWC, 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; i<nDb; i++){
-    sqlite3CodeVerifySchema(pParse, i);
-  }
-  if( DbMaskNonZero(pParse->writeMask) ){
-    for(i=0; i<nDb; i++){
-      sqlite3BeginWriteOperation(pParse, 0, i);
-    }
-  }
-}
-
-/*
-** Add all WhereLoop objects for a table of the join identified by
-** pBuilder->pNew->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->pSTab) );
-  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->pSTab->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; i<nConstraint; i++){
-        int iTerm = p->aConstraint[i].iTermOffset;
-        Bitmask mThis = termFromWhereClause(pWC, iTerm)->prereqRight & ~mPrereq;
-        if( mThis>mPrev && mThis<mNext ) mNext = mThis;
-      }
-      mPrev = mNext;
-      if( mNext==ALLBITS ) break;
-      if( mNext==mBest || mNext==mBestNoIn ) continue;
-      WHERETRACE(0x800, ("  VirtualOne: mPrev=%04llx mNext=%04llx\n",
-                       (sqlite3_uint64)mPrev, (sqlite3_uint64)mNext));
-      rc = whereLoopAddVirtualOne(
-          pBuilder, mPrereq, mNext|mPrereq, 0, p, mNoOmit, &bIn, 0);
-      if( pNew->prereq==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);
-    }
-  }
-
-  freeIndexInfo(pParse->db, p);
-  WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pSTab->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; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){
-    if( (pTerm->eOperator & 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; pOrTerm<pOrWCEnd; pOrTerm++){
-        if( (pOrTerm->eOperator & 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->pSTab) ){
-          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; i<sPrev.n; i++){
-            for(j=0; j<sCur.n; j++){
-              whereOrInsert(&sSum, sPrev.a[i].prereq | sCur.a[j].prereq,
-                            sqlite3LogEstAdd(sPrev.a[i].rRun, sCur.a[j].rRun),
-                            sqlite3LogEstAdd(sPrev.a[i].nOut, sCur.a[j].nOut));
-            }
-          }
-        }
-      }
-      pNew->nLTerm = 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 && i<sSum.n; i++){
-        /* TUNING: Currently sSum.a[i].rRun is set to the sum of the costs
-        ** of all sub-scans required by the OR-scan. However, due to rounding
-        ** errors, it may be that the cost of the OR-scan is equal to its
-        ** most expensive sub-scan. Add the smallest possible penalty
-        ** (equivalent to multiplying the cost by 1.07) to ensure that
-        ** this does not happen. Otherwise, for WHERE clauses such as the
-        ** following where there is an index on "y":
-        **
-        **     WHERE likelihood(x=?, 0.99) OR y=?
-        **
-        ** the planner may elect to "OR" together a full-table scan and an
-        ** index lookup. And other similarly odd results.  */
-        pNew->rRun = 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 hasRightCrossJoin = 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; pItem<pEnd; iTab++, pItem++){
-    Bitmask mUnusable = 0;
-    pNew->iTab = 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 hasRightCrossJoin flag prevent FROM-clause terms from moving
-      ** from the right side of a LEFT JOIN or CROSS JOIN over to the
-      ** left side of that same join.  This is a required restriction in
-      ** the case of LEFT JOIN - an incorrect answer may results if it is
-      ** not enforced.  This restriction is not required for CROSS JOIN.
-      ** It is provided merely as a means of controlling join order, under
-      ** the theory that no real-world queries that care about performance
-      ** actually use the CROSS JOIN syntax.
-      */
-      if( pItem->fg.jointype & (JT_LTORJ|JT_CROSS) ){
-        testcase( pItem->fg.jointype & JT_LTORJ );
-        testcase( pItem->fg.jointype & JT_CROSS );
-        hasRightCrossJoin = 1;
-      }
-      mPrereq |= mPrior;
-      bFirstPastRJ = (pItem->fg.jointype & JT_RIGHT)!=0;
-    }else if( pItem->fg.fromExists ){
-      /* joins that result from the EXISTS-to-JOIN optimization should not
-      ** be moved to the left of any of their dependencies */
-      WhereClause *pWC = &pWInfo->sWC;
-      WhereTerm *pTerm;
-      int i;
-      for(i=pWC->nBase, pTerm=pWC->a; i>0; i--, pTerm++){
-        if( (pNew->maskSelf & pTerm->prereqAll)!=0 ){
-          mPrereq |= (pTerm->prereqAll & (pNew->maskSelf-1));
-        }
-      }
-    }else if( !hasRightCrossJoin ){
-      mPrereq = 0;
-    }
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-    if( IsVirtual(pItem->pSTab) ){
-      SrcItem *p;
-      for(p=&pItem[1]; p<pEnd; p++){
-        if( mUnusable || (p->fg.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;
-}
-
-/* Implementation of the order-by-subquery optimization:
-**
-** WhereLoop pLoop, which the iLoop-th term of the nested loop, is really
-** a subquery or CTE that has an ORDER BY clause.  See if any of the terms
-** in the subquery ORDER BY clause will satisfy pOrderBy from the outer
-** query.  Mark off all satisfied terms (by setting bits in *pOBSat) and
-** return TRUE if they do.  If not, return false.
-**
-** Example:
-**
-**    CREATE TABLE t1(a,b,c, PRIMARY KEY(a,b));
-**    CREATE TABLE t2(x,y);
-**    WITH t3(p,q) AS MATERIALIZED (SELECT x+y, x-y FROM t2 ORDER BY x+y)
-**       SELECT * FROM t3 JOIN t1 ON a=q ORDER BY p, b;
-**
-** The CTE named "t3" comes out in the natural order of "p", so the first
-** first them of "ORDER BY p,b" is satisfied by a sequential scan of "t3"
-** and sorting only needs to occur on the second term "b".
-**
-** Limitations:
-**
-** (1)  The optimization is not applied if the outer ORDER BY contains
-**      a COLLATE clause.  The optimization might be applied if the
-**      outer ORDER BY uses NULLS FIRST, NULLS LAST, ASC, and/or DESC as
-**      long as the subquery ORDER BY does the same.  But if the
-**      outer ORDER BY uses COLLATE, even a redundant COLLATE, the
-**      optimization is bypassed.
-**
-** (2)  The subquery ORDER BY terms must exactly match subquery result
-**      columns, including any COLLATE annotations.  This routine relies
-**      on iOrderByCol to do matching between order by terms and result
-**      columns, and iOrderByCol will not be set if the result column
-**      and ORDER BY collations differ.
-**
-** (3)  The subquery and outer ORDER BY can be in opposite directions as
-**      long as  the subquery is materialized.  If the subquery is
-**      implemented as a co-routine, the sort orders must be in the same
-**      direction because there is no way to run a co-routine backwards.
-*/
-static SQLITE_NOINLINE int wherePathMatchSubqueryOB(
-  WhereInfo *pWInfo,      /* The WHERE clause */
-  WhereLoop *pLoop,       /* The nested loop term that is a subquery */
-  int iLoop,              /* Which level of the nested loop.  0==outermost */
-  int iCur,               /* Cursor used by the this loop */
-  ExprList *pOrderBy,     /* The ORDER BY clause on the whole query */
-  Bitmask *pRevMask,      /* When loops need to go in reverse order */
-  Bitmask *pOBSat         /* Which terms of pOrderBy are satisfied so far */
-){
-  int iOB;                /* Index into pOrderBy->a[] */
-  int jSub;               /* Index into pSubOB->a[] */
-  u8 rev = 0;             /* True if iOB and jSub sort in opposite directions */
-  u8 revIdx = 0;          /* Sort direction for jSub */
-  Expr *pOBExpr;          /* Current term of outer ORDER BY */
-  ExprList *pSubOB;       /* Complete ORDER BY on the subquery */
-
-  pSubOB = pLoop->u.btree.pOrderBy;
-  assert( pSubOB!=0 );
-  for(iOB=0; (MASKBIT(iOB) & *pOBSat)!=0; iOB++){}
-  for(jSub=0; jSub<pSubOB->nExpr && iOB<pOrderBy->nExpr; jSub++, iOB++){
-    if( pSubOB->a[jSub].u.x.iOrderByCol==0 ) break;
-    pOBExpr = pOrderBy->a[iOB].pExpr;
-    if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) break;
-    if( pOBExpr->iTable!=iCur ) break;
-    if( pOBExpr->iColumn!=pSubOB->a[jSub].u.x.iOrderByCol-1 ) break;
-    if( (pWInfo->wctrlFlags & WHERE_GROUPBY)==0 ){
-      u8 sfOB = pOrderBy->a[iOB].fg.sortFlags;   /* sortFlags for iOB */
-      u8 sfSub = pSubOB->a[jSub].fg.sortFlags;   /* sortFlags for jSub */
-      if( (sfSub & KEYINFO_ORDER_BIGNULL) != (sfOB & KEYINFO_ORDER_BIGNULL) ){
-        break;
-      }
-      revIdx = sfSub & KEYINFO_ORDER_DESC;
-      if( jSub>0 ){
-        if( (rev^revIdx)!=(sfOB & KEYINFO_ORDER_DESC) ){
-          break;
-        }
-      }else{
-        rev = revIdx ^ (sfOB & KEYINFO_ORDER_DESC);
-        if( rev ){
-          if( (pLoop->wsFlags & WHERE_COROUTINE)!=0 ){
-            /* Cannot run a co-routine in reverse order */
-            break;
-          }
-          *pRevMask |= MASKBIT(iLoop);
-        }
-      }
-    }
-    *pOBSat |= MASKBIT(iOB);
-  }
-  return jSub>0;
-}
-
-/*
-** 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 && obSat<obDone && iLoop<=nLoop; iLoop++){
-    if( iLoop>0 ) ready |= pLoop->maskSelf;
-    if( iLoop<nLoop ){
-      pLoop = pPath->aLoop[iLoop];
-      if( wctrlFlags & WHERE_ORDERBY_LIMIT ) continue;
-    }else{
-      pLoop = pLast;
-    }
-    if( pLoop->wsFlags & WHERE_VIRTUALTABLE ){
-      if( pLoop->u.vtab.isOrdered && pWInfo->pOrderBy==pOrderBy ){
-        obSat = obDone;
-      }else{
-        /* No further ORDER BY terms may be matched. So this call should
-        ** return >=0, not -1. Clear isOrderDistinct to ensure it does so. */
-        isOrderDistinct = 0;
-      }
-      break;
-    }
-    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; i<nOrderBy; i++){
-      if( MASKBIT(i) & obSat ) continue;
-      pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[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; j<pLoop->nLTerm && 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 ){
-        if( pLoop->u.btree.pOrderBy
-         && OptimizationEnabled(db, SQLITE_OrderBySubq)
-         &&  wherePathMatchSubqueryOB(pWInfo,pLoop,iLoop,iCur,
-                                     pOrderBy,pRevMask, &obSat)
-        ){
-          nColumn = 0;
-          isOrderDistinct = 0;
-        }else{
-          nColumn = 1;
-        }
-        pIndex = 0;
-        nKeyCol = 0;
-      }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 isOrderDistinct 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<nColumn; j++){
-        u8 bOnce = 1; /* True to run the ORDER BY search loop */
-
-        assert( j>=pLoop->u.btree.nEq
-            || (pLoop->aLTerm[j]==0)==(j<pLoop->nSkip)
-        );
-        if( j<pLoop->u.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
-            ** j<pLoop->u.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; i<pLoop->u.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 having been satisfied.
-        */
-        isMatch = 0;
-        for(i=0; bOnce && i<nOrderBy; i++){
-          if( MASKBIT(i) & obSat ) continue;
-          pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[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 || j<nKeyCol ){
-            testcase( isOrderDistinct!=0 );
-            isOrderDistinct = 0;
-          }
-          break;
-        }
-      } /* end Loop over all index columns */
-      if( distinctColumns ){
-        testcase( isOrderDistinct==0 );
-        isOrderDistinct = 1;
-      }
-    } /* end-if not one-row */
-
-    /* Mark off any other ORDER BY terms that reference pLoop */
-    if( isOrderDistinct ){
-      orderDistinctMask |= pLoop->maskSelf;
-      for(i=0; i<nOrderBy; i++){
-        Expr *p;
-        Bitmask mTerm;
-        if( MASKBIT(i) & obSat ) continue;
-        p = pOrderBy->a[i].pExpr;
-        mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p);
-        if( mTerm==0 && !sqlite3ExprIsConstant(0,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(i<BMS) ? MASKBIT(i) - 1 : 0;
-      if( (obSat&m)==m ) return i;
-    }
-    return 0;
-  }
-  return -1;
-}
-
-
-/*
-** If the WHERE_GROUPBY flag is set in the mask passed to sqlite3WhereBegin(),
-** the planner assumes that the specified pOrderBy list is actually a GROUP
-** BY clause - and so any order that groups rows as required satisfies the
-** request.
-**
-** Normally, in this case it is not possible for the caller to determine
-** whether or not the rows are really being delivered in sorted order, or
-** just in some other order that provides the required grouping. However,
-** if the WHERE_SORTBYGROUP flag is also passed to sqlite3WhereBegin(), then
-** this function may be called on the returned WhereInfo object. It returns
-** true if the rows really will be sorted in the specified order, or false
-** otherwise.
-**
-** For example, assuming:
-**
-**   CREATE INDEX i1 ON t1(x, Y);
-**
-** then
-**
-**   SELECT * FROM t1 GROUP BY x,y ORDER BY x,y;   -- IsSorted()==1
-**   SELECT * FROM t1 GROUP BY y,x ORDER BY y,x;   -- IsSorted()==0
-*/
-SQLITE_PRIVATE int sqlite3WhereIsSorted(WhereInfo *pWInfo){
-  assert( pWInfo->wctrlFlags & (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; i<nLoop; i++){ zName[i] = pPath->aLoop[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->iLimit<nRow ){
-      nRow = pWInfo->iLimit;
-    }
-  }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;
-}
-
-/*
-** Compute the maximum number of paths in the solver algorithm, for
-** queries that have three or more terms in the FROM clause.  Queries with
-** two or fewer FROM clause terms are handled by the caller.
-**
-** Query planning is NP-hard.  We must limit the number of paths at
-** each step of the solver search algorithm to avoid exponential behavior.
-**
-** The value returned is a tuning parameter.  Currently the value is:
-**
-**     18    for star queries
-**     12    otherwise
-**
-** For the purposes of this heuristic, a star-query is defined as a query
-** with a central "fact" table that is joined against multiple
-** "dimension" tables, subject to the following constraints:
-**
-**   (aa)  Only a five-way or larger join is considered for this
-**         optimization.  If there are fewer than four terms in the FROM
-**         clause, this heuristic does not apply.
-**
-**   (bb)  The join between the fact table and the dimension tables must
-**         be an INNER join.  CROSS and OUTER JOINs do not qualify.
-**
-**   (cc)  A table must have 3 or more dimension tables in order to be
-**         considered a fact table. (Was 4 prior to 2026-02-10.)
-**
-**   (dd)  A table that is a self-join cannot be a dimension table.
-**         Dimension tables are joined against fact tables.
-**
-** SIDE EFFECT:  (and really the whole point of this subroutine)
-**
-** If pWInfo describes a star-query, then the cost for SCANs of dimension
-** WhereLoops is increased to be slightly larger than the cost of a SCAN
-** in the fact table.  Only SCAN costs are increased.  SEARCH costs are
-** unchanged. This heuristic helps keep fact tables in outer loops. Without
-** this heuristic, paths with fact tables in outer loops tend to get pruned
-** by the mxChoice limit on the number of paths, resulting in poor query
-** plans.  See the starschema1.test test module for examples of queries
-** that need this heuristic to find good query plans.
-**
-** This heuristic can be completely disabled, so that no query is
-** considered a star-query, using SQLITE_TESTCTRL_OPTIMIZATION to
-** disable the SQLITE_StarQuery optimization.  In the CLI, the command
-** to do that is:  ".testctrl opt -starquery".
-**
-** HISTORICAL NOTES:
-**
-** This optimization was first added on 2024-05-09 by check-in 38db9b5c83d.
-** The original optimization reduced the cost and output size estimate for
-** fact tables to help them move to outer loops.  But months later (as people
-** started upgrading) performance regression reports started caming in,
-** including:
-**
-**    forum post b18ef983e68d06d1 (2024-12-21)
-**    forum post 0025389d0860af82 (2025-01-14)
-**    forum post d87570a145599033 (2025-01-17)
-**
-** To address these, the criteria for a star-query was tightened to exclude
-** cases where the fact and dimensions are separated by an outer join, and
-** the affect of star-schema detection was changed to increase the rRun cost
-** on just full table scans of dimension tables, rather than reducing costs
-** in the all access methods of the fact table.
-*/
-static int computeMxChoice(WhereInfo *pWInfo){
-  int nLoop = pWInfo->nLevel;    /* Number of terms in the join */
-  WhereLoop *pWLoop;             /* For looping over WhereLoops */
-
-#ifdef SQLITE_DEBUG
-  /* The star-query detection code below makes use of the following
-  ** properties of the WhereLoop list, so verify them before
-  ** continuing:
-  **    (1)  .maskSelf is the bitmask corresponding to .iTab
-  **    (2)  The WhereLoop list is in ascending .iTab order
-  */
-  for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){
-    assert( pWLoop->maskSelf==MASKBIT(pWLoop->iTab) );
-    assert( pWLoop->pNextLoop==0 || pWLoop->iTab<=pWLoop->pNextLoop->iTab );
-  }
-#endif /* SQLITE_DEBUG */
-
-  if( nLoop>=4  /* Constraint (aa) */
-   && !pWInfo->bStarDone
-   && OptimizationEnabled(pWInfo->pParse->db, SQLITE_StarQuery)
-  ){
-    SrcItem *aFromTabs;    /* All terms of the FROM clause */
-    int iFromIdx;          /* Term of FROM clause is the candidate fact-table */
-    Bitmask m;             /* Bitmask for candidate fact-table */
-    Bitmask mSelfJoin = 0; /* Tables that cannot be dimension tables */
-    WhereLoop *pStart;     /* Where to start searching for dimension-tables */
-
-    pWInfo->bStarDone = 1; /* Only do this computation once */
-
-    /* Look for fact tables with three or more dimensions where the
-    ** dimension tables are not separately from the fact tables by an outer
-    ** or cross join.  Adjust cost weights if found.
-    */
-    assert( !pWInfo->bStarUsed );
-    aFromTabs = pWInfo->pTabList->a;
-    pStart = pWInfo->pLoops;
-    for(iFromIdx=0, m=1; iFromIdx<nLoop; iFromIdx++, m<<=1){
-      int nDep = 0;             /* Number of dimension tables */
-      LogEst mxRun;             /* Maximum SCAN cost of a fact table */
-      Bitmask mSeen = 0;        /* Mask of dimension tables */
-      SrcItem *pFactTab;        /* The candidate fact table */
-
-      pFactTab = aFromTabs + iFromIdx;
-      if( (pFactTab->fg.jointype & (JT_OUTER|JT_CROSS))!=0 ){
-        /* If the candidate fact-table is the right table of an outer join
-        ** restrict the search for dimension-tables to be tables to the right
-        ** of the fact-table.  Constraint (bb) */
-        if( iFromIdx+3 > nLoop ){
-          break;  /* ^-- Impossible to reach nDep>=2 - Constraint (cc) */
-        }
-        while( pStart && pStart->iTab<=iFromIdx ){
-          pStart = pStart->pNextLoop;
-        }
-      }
-      for(pWLoop=pStart; pWLoop; pWLoop=pWLoop->pNextLoop){
-        if( (aFromTabs[pWLoop->iTab].fg.jointype & (JT_OUTER|JT_CROSS))!=0 ){
-          break; /* Constraint (bb) */
-        }
-        if( (pWLoop->prereq & m)!=0        /* pWInfo depends on iFromIdx */
-         && (pWLoop->maskSelf & mSeen)==0  /* pWInfo not already a dependency */
-         && (pWLoop->maskSelf & mSelfJoin)==0 /* Not a self-join */
-        ){
-          if( aFromTabs[pWLoop->iTab].pSTab==pFactTab->pSTab ){
-            mSelfJoin |= m;
-          }else{
-            nDep++;
-            mSeen |= pWLoop->maskSelf;
-          }
-        }
-      }
-      if( nDep<=2 ){
-        continue; /* Constraint (cc) */
-      }
-
-      /* If we reach this point, it means that pFactTab is a fact table
-      ** with four or more dimensions connected by inner joins.  Proceed
-      ** to make cost adjustments. */
-
-#ifdef WHERETRACE_ENABLED
-      /* Make sure rStarDelta values are initialized */
-      if( !pWInfo->bStarUsed ){
-        for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){
-          pWLoop->rStarDelta = 0;
-        }
-      }
-#endif
-#ifdef WHERETRACE_ENABLED /* 0x80000 */
-      if( sqlite3WhereTrace & 0x80000 ){
-        Bitmask mShow = mSeen;
-        sqlite3DebugPrintf("Fact table %s(%d), dimensions:",
-            pFactTab->zAlias ? pFactTab->zAlias : pFactTab->pSTab->zName,
-            iFromIdx);
-        for(pWLoop=pStart; pWLoop; pWLoop=pWLoop->pNextLoop){
-          if( mShow & pWLoop->maskSelf ){
-            SrcItem *pDim = aFromTabs + pWLoop->iTab;
-            mShow &= ~pWLoop->maskSelf;
-            sqlite3DebugPrintf(" %s(%d)",
-              pDim->zAlias ? pDim->zAlias: pDim->pSTab->zName, pWLoop->iTab);
-          }
-        }
-        sqlite3DebugPrintf("\n");
-      }
-#endif
-      pWInfo->bStarUsed = 1;
-
-      /* Compute the maximum cost of any WhereLoop for the
-      ** fact table plus one epsilon */
-      mxRun = LOGEST_MIN;
-      for(pWLoop=pStart; pWLoop; pWLoop=pWLoop->pNextLoop){
-        if( pWLoop->iTab<iFromIdx ) continue;
-        if( pWLoop->iTab>iFromIdx ) break;
-        if( pWLoop->rRun>mxRun ) mxRun = pWLoop->rRun;
-      }
-      if( ALWAYS(mxRun<LOGEST_MAX) ) mxRun++;
-
-      /* Increase the cost of table scans for dimension tables to be
-      ** slightly more than the maximum cost of the fact table */
-      for(pWLoop=pStart; pWLoop; pWLoop=pWLoop->pNextLoop){
-        if( (pWLoop->maskSelf & mSeen)==0 ) continue;
-        if( pWLoop->nLTerm ) continue;
-        if( pWLoop->rRun<mxRun ){
-#ifdef WHERETRACE_ENABLED /* 0x80000 */
-          if( sqlite3WhereTrace & 0x80000 ){
-            SrcItem *pDim = aFromTabs + pWLoop->iTab;
-            sqlite3DebugPrintf(
-              "Increase SCAN cost of %s to %d\n",
-              pDim->zAlias ? pDim->zAlias: pDim->pSTab->zName, mxRun
-            );
-          }
-          pWLoop->rStarDelta = mxRun - pWLoop->rRun;
-#endif /* WHERETRACE_ENABLED */
-          pWLoop->rRun = mxRun;
-        }
-      }
-    }
-#ifdef WHERETRACE_ENABLED /* 0x80000 */
-    if( (sqlite3WhereTrace & 0x80000)!=0 && pWInfo->bStarUsed ){
-      sqlite3DebugPrintf("WhereLoops changed by star-query heuristic:\n");
-      for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){
-        if( pWLoop->rStarDelta ){
-          sqlite3WhereLoopPrint(pWLoop, &pWInfo->sWC);
-        }
-      }
-    }
-#endif
-  }
-  return pWInfo->bStarUsed ? 18 : 12;
-}
-
-/*
-** Two WhereLoop objects, pCandidate and pBaseline, are known to have the
-** same cost.  Look deep into each to see if pCandidate is even slightly
-** better than pBaseline.  Return false if it is, if pCandidate is is preferred.
-** Return true if pBaseline is preferred or if we cannot tell the difference.
-**
-**    Result       Meaning
-**    --------     ----------------------------------------------------------
-**    true         We cannot tell the difference in pCandidate and pBaseline
-**    false        pCandidate seems like a better choice than pBaseline
-*/
-static SQLITE_NOINLINE int whereLoopIsNoBetter(
-  const WhereLoop *pCandidate,
-  const WhereLoop *pBaseline
-){
-  if( (pCandidate->wsFlags & WHERE_INDEXED)==0 ) return 1;
-  if( (pBaseline->wsFlags & WHERE_INDEXED)==0 ) return 1;
-  if( pCandidate->u.btree.pIndex->szIdxRow <
-        pBaseline->u.btree.pIndex->szIdxRow ) return 0;
-  return 1;
-}
-
-/*
-** 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 mxUnsort = 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;
-  WHERETRACE(0x002, ("---- begin solver.  (nRowEst=%d, nQueryLoop=%d)\n",
-                     nRowEst, pParse->nQueryLoop));
-  /* TUNING: mxChoice is the maximum number of possible paths to preserve
-  ** at each step.  Based on the number of loops in the FROM clause:
-  **
-  **     nLoop      mxChoice
-  **     -----      --------
-  **       1            1            // the most common case
-  **       2            5
-  **       3+        12 or 18        // see computeMxChoice()
-  */
-  if( nLoop<=1 ){
-    mxChoice = 1;
-  }else if( nLoop==2 ){
-    mxChoice = 5;
-  }else if( pParse->nErr ){
-    mxChoice = 1;
-  }else{
-    mxChoice = computeMxChoice(pWInfo);
-  }
-  assert( nLoop<=pWInfo->pTabList->nSrc );
-
-  /* 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; iLoop<nLoop; iLoop++){
-    nTo = 0;
-    for(ii=0, pFrom=aFrom; ii<nFrom; ii++, pFrom++){
-      for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){
-        LogEst nOut;                      /* Rows visited by (pFrom+pWLoop) */
-        LogEst rCost;                     /* Cost of path (pFrom+pWLoop) */
-        LogEst rUnsort;                   /* 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 */
-        rUnsort = pWLoop->rRun + pFrom->nRow;
-        if( pWLoop->rSetup ){
-          rUnsort = sqlite3LogEstAdd(pWLoop->rSetup, rUnsort);
-        }
-        rUnsort = sqlite3LogEstAdd(rUnsort, pFrom->rUnsort);
-        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 && isOrdered<nOrderBy ){
-          if( aSortCost[isOrdered]==0 ){
-            aSortCost[isOrdered] = whereSortingCost(
-                pWInfo, nRowEst, nOrderBy, isOrdered
-            );
-          }
-          /* TUNING:  Add a small extra penalty (3) to sorting as an
-          ** extra encouragement to the query planner to select a plan
-          ** where the rows emerge in the correct order without any sorting
-          ** required. */
-          rCost = sqlite3LogEstAdd(rUnsort, aSortCost[isOrdered]) + 3;
-
-          WHERETRACE(0x002,
-              ("---- sort cost=%-3d (%d/%d) increases cost %3d to %-3d\n",
-               aSortCost[isOrdered], (nOrderBy-isOrdered), nOrderBy,
-               rUnsort, rCost));
-        }else{
-          rCost = rUnsort;
-          rUnsort -= 2;  /* TUNING:  Slight bias in favor of no-sort plans */
-        }
-
-        /* 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:
-        **     (1) covers the same set of loops, and
-        **     (2) has a compatible isOrdered value.
-        **
-        ** "Compatible isOrdered value" means either
-        **     (A) both have isOrdered==-1, or
-        **     (B) both have isOrder>=0, or
-        **     (C) ordering does not matter because this is the last round
-        **         of the solver.
-        **
-        ** 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.
-        */
-        testcase( nTo==0 );
-        for(jj=0, pTo=aTo; jj<nTo; jj++, pTo++){
-          if( pTo->maskLoop==maskNew
-           && ( ((pTo->isOrdered^isOrdered)&0x80)==0 || iLoop==nLoop-1 )
-          ){
-            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 && rUnsort>=mxUnsort))
-          ){
-            /* 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, rUnsort,
-                  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<mxChoice ){
-            /* Increase the size of the aTo set by one */
-            jj = nTo++;
-          }else{
-            /* New path replaces the prior worst to keep count below mxChoice */
-            jj = mxI;
-          }
-          pTo = &aTo[jj];
-#ifdef WHERETRACE_ENABLED /* 0x4 */
-          if( sqlite3WhereTrace&0x4 ){
-            sqlite3DebugPrintf("New    %s cost=%-3d,%3d,%3d order=%c\n",
-                wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsort,
-                isOrdered>=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->rUnsort) <= (rCost,nOut,rUnsort)
-          */
-          if( (pTo->rCost<rCost)
-           || (pTo->rCost==rCost && pTo->nRow<nOut)
-           || (pTo->rCost==rCost && pTo->nRow==nOut && pTo->rUnsort<rUnsort)
-           || (pTo->rCost==rCost && pTo->nRow==nOut && pTo->rUnsort==rUnsort
-                  && whereLoopIsNoBetter(pWLoop, pTo->aLoop[iLoop]) )
-          ){
-#ifdef WHERETRACE_ENABLED /* 0x4 */
-            if( sqlite3WhereTrace&0x4 ){
-              sqlite3DebugPrintf(
-                  "Skip   %s cost=%-3d,%3d,%3d order=%c",
-                  wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsort,
-                  isOrdered>=0 ? isOrdered+'0' : '?');
-              sqlite3DebugPrintf("   vs %s cost=%-3d,%3d,%3d order=%c\n",
-                  wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
-                  pTo->rUnsort, 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, rUnsort,
-                isOrdered>=0 ? isOrdered+'0' : '?');
-            sqlite3DebugPrintf("  was %s cost=%-3d,%3d,%3d order=%c\n",
-                wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
-                pTo->rUnsort, 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->rUnsort = rUnsort;
-        pTo->isOrdered = isOrdered;
-        memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop);
-        pTo->aLoop[iLoop] = pWLoop;
-        if( nTo>=mxChoice ){
-          mxI = 0;
-          mxCost = aTo[0].rCost;
-          mxUnsort = aTo[0].nRow;
-          for(jj=1, pTo=&aTo[1]; jj<mxChoice; jj++, pTo++){
-            if( pTo->rCost>mxCost
-             || (pTo->rCost==mxCost && pTo->rUnsort>mxUnsort)
-            ){
-              mxCost = pTo->rCost;
-              mxUnsort = pTo->rUnsort;
-              mxI = jj;
-            }
-          }
-        }
-      }
-    }
-
-#ifdef WHERETRACE_ENABLED  /* >=2 */
-    if( sqlite3WhereTrace & 0x02 ){
-      LogEst rMin, rFloor = 0;
-      int nDone = 0;
-      int nProgress;
-      sqlite3DebugPrintf("---- after round %d ----\n", iLoop);
-      do{
-        nProgress = 0;
-        rMin = 0x7fff;
-        for(ii=0, pTo=aTo; ii<nTo; ii++, pTo++){
-          if( pTo->rCost>rFloor && pTo->rCost<rMin ) rMin = pTo->rCost;
-        }
-        for(ii=0, pTo=aTo; ii<nTo; ii++, pTo++){
-          if( pTo->rCost==rMin ){
-            sqlite3DebugPrintf(" %s cost=%-3d nrow=%-3d order=%c",
-               wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
-               pTo->isOrdered>=0 ? (pTo->isOrdered+'0') : '?');
-            if( pTo->isOrdered>0 ){
-              sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop);
-            }else{
-              sqlite3DebugPrintf("\n");
-            }
-            nDone++;
-            nProgress++;
-          }
-        }
-        rFloor = rMin;
-      }while( nDone<nTo && nProgress>0 );
-    }
-#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;
-  }
-
-  /* Only one path is available, which is the best path */
-  assert( nFrom==1 );
-  pFrom = aFrom;
-
-  assert( pWInfo->nLevel==nLoop );
-  /* Load the lowest cost path into pWInfo */
-  for(iLoop=0; iLoop<nLoop; iLoop++){
-    WhereLevel *pLevel = pWInfo->a + 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], &notUsed);
-    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;
-      }
-      /* vvv--- See check-in [12ad822d9b827777] on 2023-03-16 ---vvv */
-      assert( pWInfo->pSelect->pOrderBy==0
-           || 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;
-#ifdef WHERETRACE_ENABLED
-  pWInfo->rTotalCost = pFrom->rCost;
-#endif
-
-  /* Free temporary memory and return success */
-  sqlite3StackFreeNN(pParse->db, pSpace);
-  return SQLITE_OK;
-}
-
-/*
-** This routine implements a heuristic designed to improve query planning.
-** This routine is called in between the first and second call to
-** wherePathSolver().  Hence the name "Interstage" "Heuristic".
-**
-** The first call to wherePathSolver() (hereafter just "solver()") computes
-** the best path without regard to the order of the outputs.  The second call
-** to the solver() builds upon the first call to try to find an alternative
-** path that satisfies the ORDER BY clause.
-**
-** This routine looks at the results of the first solver() run, and for
-** every FROM clause term in the resulting query plan that uses an equality
-** constraint against an index, disable other WhereLoops for that same
-** FROM clause term that would try to do a full-table scan.  This prevents
-** an index search from being converted into a full-table scan in order to
-** satisfy an ORDER BY clause, since even though we might get slightly better
-** performance using the full-scan without sorting if the output size
-** estimates are very precise, we might also get severe performance
-** degradation using the full-scan if the output size estimate is too large.
-** It is better to err on the side of caution.
-**
-** Except, if the first solver() call generated a full-table scan in an outer
-** loop then stop this analysis at the first full-scan, since the second
-** solver() run might try to swap that full-scan for another in order to
-** get the output into the correct order.  In other words, we allow a
-** rewrite like this:
-**
-**     First Solver()                      Second Solver()
-**       |-- SCAN t1                         |-- SCAN t2
-**       |-- SEARCH t2                       `-- SEARCH t1
-**       `-- SORT USING B-TREE
-**
-** The purpose of this routine is to disallow rewrites such as:
-**
-**     First Solver()                      Second Solver()
-**       |-- SEARCH t1                       |-- SCAN t2     <--- bad!
-**       |-- SEARCH t2                       `-- SEARCH t1
-**       `-- SORT USING B-TREE
-**
-** See test cases in test/whereN.test for the real-world query that
-** originally provoked this heuristic.
-*/
-static SQLITE_NOINLINE void whereInterstageHeuristic(WhereInfo *pWInfo){
-  int i;
-#ifdef WHERETRACE_ENABLED
-  int once = 0;
-#endif
-  for(i=0; i<pWInfo->nLevel; i++){
-    WhereLoop *p = pWInfo->a[i].pWLoop;
-    if( p==0 ) break;
-    if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 ){
-      /* Treat a vtab scan as similar to a full-table scan */
-      break;
-    }
-    if( (p->wsFlags & (WHERE_COLUMN_EQ|WHERE_COLUMN_NULL|WHERE_COLUMN_IN))!=0 ){
-      u8 iTab = p->iTab;
-      WhereLoop *pLoop;
-      for(pLoop=pWInfo->pLoops; pLoop; pLoop=pLoop->pNextLoop){
-        if( pLoop->iTab!=iTab ) continue;
-        if( (pLoop->wsFlags & (WHERE_CONSTRAINT|WHERE_AUTO_INDEX))!=0 ){
-          /* Auto-index and index-constrained loops allowed to remain */
-          continue;
-        }
-#ifdef WHERETRACE_ENABLED
-        if( sqlite3WhereTrace & 0x80 ){
-          if( once==0 ){
-            sqlite3DebugPrintf("Loops disabled by interstage heuristic:\n");
-            once = 1;
-          }
-          sqlite3WhereLoopPrint(pLoop, &pWInfo->sWC);
-        }
-#endif /* WHERETRACE_ENABLED */
-        pLoop->prereq = ALLBITS;  /* Prevent 2nd solver() from using this one */
-      }
-    }else{
-      break;
-    }
-  }
-}
-
-/*
-** 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->pSTab;
-  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; j<pIdx->nKeyCol; 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.
-**   6) The ORDER BY clause has 63 or fewer terms
-**   7) The omit-noop-join optimization is enabled.
-**
-** Items (1), (6), and (7) are checked by the caller.
-**
-** 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;
-    Bitmask m1;
-    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; pTerm<pEnd; pTerm++){
-      if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
-        if( !ExprHasProperty(pTerm->pExpr, EP_OuterON)
-         || pTerm->pExpr->w.iJoin!=pItem->iCursor
-        ){
-          break;
-        }
-      }
-      if( hasRightJoin
-       && ExprHasProperty(pTerm->pExpr, EP_InnerON)
-       && NEVER(pTerm->pExpr->w.iJoin==pItem->iCursor)
-      ){
-        break;  /* restriction (5) */
-      }
-    }
-    if( pTerm<pEnd ) continue;
-    WHERETRACE(0xffffffff,("-> omit unused FROM-clause term %c\n",pLoop->cId));
-    m1 = MASKBIT(i)-1;
-    testcase( ((pWInfo->revMask>>1) & ~m1)!=0 );
-    pWInfo->revMask = (m1 & pWInfo->revMask) | ((pWInfo->revMask>>1) & ~m1);
-    notReady &= ~pLoop->maskSelf;
-    for(pTerm=pWInfo->sWC.a; pTerm<pEnd; pTerm++){
-      if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
-        pTerm->wtFlags |= TERM_CODED;
-        pTerm->prereqAll = 0;
-      }
-    }
-    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; i<pWInfo->nLevel; 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->pSTab;
-    if( (pTab->tabFlags & TF_HasStat1)==0 ) break;
-    pTab->tabFlags |= TF_MaybeReanalyze;
-    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;
-  }
-}
-
-/*
-** 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; i<pIdx->nColumn; i++){
-    Expr *pExpr;
-    int j = pIdx->aiColumn[i];
-    if( j==XN_EXPR ){
-      pExpr = pIdx->aColExpr->a[i].pExpr;
-    }else if( j>=0 && (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)!=0 ){
-      pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
-    }else{
-      continue;
-    }
-    if( sqlite3ExprIsConstant(0,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 = (pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0;
-    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 ){
-      void *pArg = (void*)&pParse->pIdxEpr;
-      sqlite3ParserAddCleanup(pParse, whereIndexedExprCleanup, pArg);
-    }
-  }
-}
-
-/*
-** Set the reverse-scan order mask to one for all tables in the query
-** with the exception of MATERIALIZED common table expressions that have
-** their own internal ORDER BY clauses.
-**
-** This implements the PRAGMA reverse_unordered_selects=ON setting.
-** (Also SQLITE_DBCONFIG_REVERSE_SCANORDER).
-*/
-static SQLITE_NOINLINE void whereReverseScanOrder(WhereInfo *pWInfo){
-  int ii;
-  for(ii=0; ii<pWInfo->pTabList->nSrc; ii++){
-    SrcItem *pItem = &pWInfo->pTabList->a[ii];
-    if( !pItem->fg.isCte
-     || pItem->u2.pCteUse->eM10d!=M10d_Yes
-     || NEVER(pItem->fg.isSubquery==0)
-     || pItem->u4.pSubq->pSelect->pOrderBy==0
-    ){
-      pWInfo->revMask |= MASKBIT(ii);
-    }
-  }
-}
-
-/*
-** 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 conceptually 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;
-    wctrlFlags &= ~WHERE_WANT_DISTINCT;
-    wctrlFlags |= WHERE_KEEP_ALL_JOINS; /* Disable omit-noop-join opt */
-  }
-
-  /* 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 = SZ_WHEREINFO(nTabList);
-  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;
-    }
-    if( ALWAYS(pWInfo->pSelect)
-     && (pWInfo->pSelect->selFlags & SF_MultiValue)==0
-    ){
-      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<<N.
-    **
-    ** The rule of the previous sentence ensures that if X is the bitmask for
-    ** a table T, then X-1 is the bitmask for all other tables to the left of T.
-    ** Knowing the bitmask for all tables to the left of a left join is
-    ** important.  Ticket #3015.
-    **
-    ** Note that bitmasks are created for all pTabList->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)<pTabList->nSrc );
-  #ifdef SQLITE_DEBUG
-    {
-      Bitmask mx = 0;
-      for(ii=0; ii<pTabList->nSrc; 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; ii<sWLB.pWC->nBase; 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 ){
-       whereInterstageHeuristic(pWInfo);
-       wherePathSolver(pWInfo, pWInfo->nRowOut<0 ? 1 : pWInfo->nRowOut+1);
-       if( db->mallocFailed ) goto whereBeginError;
-    }
-
-    /* TUNING:  Assume that a DISTINCT clause on a subquery reduces
-    ** the output size by a factor of 8 (LogEst -30).  Search for
-    ** tag-20250414a to see other cases.
-    */
-    if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT)!=0 ){
-      WHERETRACE(0x0080,("nRowOut reduced from %d to %d due to DISTINCT\n",
-                         pWInfo->nRowOut, pWInfo->nRowOut-30));
-      pWInfo->nRowOut -= 30;
-    }
-
-  }
-  assert( pWInfo->pTabList!=0 );
-  if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){
-    whereReverseScanOrder(pWInfo);
-  }
-  if( pParse->nErr ){
-    goto whereBeginError;
-  }
-  assert( db->mallocFailed==0 );
-#ifdef WHERETRACE_ENABLED
-  if( sqlite3WhereTrace ){
-    sqlite3DebugPrintf("---- Solution cost=%d, nRow=%d",
-                       pWInfo->rTotalCost, 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; ii<pWInfo->nLevel; 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       /* Must be a join, or this opt8n is pointless */
-   && pResultSet!=0           /* Condition (1) */
-   && 0==(wctrlFlags & (WHERE_AGG_DISTINCT|WHERE_KEEP_ALL_JOINS)) /* (1),(6) */
-   && OptimizationEnabled(db, SQLITE_OmitNoopJoin)                /* (7) */
-  ){
-    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].pSTab) );
-    if( bOnerow || (
-        0!=(wctrlFlags & WHERE_ONEPASS_MULTIROW)
-     && !IsVirtual(pTabList->a[0].pSTab)
-     && (0==(wsFlags & WHERE_MULTI_OR) || (wctrlFlags & WHERE_DUPLICATES_OK))
-     && OptimizationEnabled(db, SQLITE_OnePass)
-    )){
-      pWInfo->eOnePass = bOnerow ? ONEPASS_SINGLE : ONEPASS_MULTI;
-      if( HasRowid(pTabList->a[0].pSTab) && (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; ii<nTabList; ii++, pLevel++){
-    Table *pTab;     /* Table to open */
-    int iDb;         /* Index of database containing table/index */
-    SrcItem *pTabItem;
-
-    pTabItem = &pTabList->a[pLevel->iFrom];
-    pTab = pTabItem->pSTab;
-    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-    pLoop = pLevel->pWLoop;
-    pLevel->addrBrk = sqlite3VdbeMakeLabel(pParse);
-    if( ii==0 || (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){
-      pLevel->addrHalt = pLevel->addrBrk;
-    }else if( pWInfo->a[ii-1].pRJ ){
-      pLevel->addrHalt = pWInfo->a[ii-1].addrBrk;
-    }else{
-      pLevel->addrHalt = pWInfo->a[ii-1].addrHalt;
-    }
-    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->nCol<BMS
-       && (pTab->tabFlags & (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
-      if( ii>=2
-       && (pTabItem[0].fg.jointype & (JT_LTORJ|JT_LEFT))==0
-       && pLevel->addrHalt==pWInfo->a[0].addrHalt
-      ){
-        sqlite3VdbeAddOp2(v, OP_IfEmpty, pTabItem->iCursor, pWInfo->iBreak);
-        VdbeCoverage(v);
-      }
-    }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->pSTab->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);
-        }
-        if( pIx->pPartIdxWhere && (pTabItem->fg.jointype & JT_RIGHT)==0 ){
-          wherePartIdxExpr(
-              pParse, pIx, pIx->pPartIdxWhere, 0, 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; ii<pIx->nColumn; 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->pSTab );
-      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; ii<nTabList; ii++){
-    int addrExplain;
-    int wsFlags;
-    SrcItem *pSrc;
-    if( pParse->nErr ) goto whereBeginError;
-    pLevel = &pWInfo->a[ii];
-    wsFlags = pLevel->pWLoop->wsFlags;
-    pSrc = &pTabList->a[pLevel->iFrom];
-    if( pSrc->fg.isMaterialized ){
-      Subquery *pSubq;
-      int iOnce = 0;
-      assert( pSrc->fg.isSubquery );
-      pSubq = pSrc->u4.pSubq;
-      if( pSrc->fg.isCorrelated==0 ){
-        iOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
-      }else{
-        iOnce = 0;
-      }
-      sqlite3VdbeAddOp2(v, OP_Gosub, pSubq->regReturn, pSubq->addrFillSub);
-      VdbeComment((v, "materialize %!S", pSrc));
-      if( iOnce )  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);
-  }
-#ifdef WHERETRACE_ENABLED
-  /* Prevent harmless compiler warnings about debugging routines
-  ** being declared but never used */
-  sqlite3ShowWhereLoopList(0);
-#endif /* WHERETRACE_ENABLED */
-  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);
-    sqlite3ShowWhereTerm(0); /* So compiler won't complain about unused func */
-  }
-#endif
-
-/*
-** 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;
-#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT
-  int addrSeek = 0;
-#endif
-
-  /* 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);
-      /* Replace addrCont with a new label that will never be used, just so
-      ** the subsequent call to resolve pLevel->addrCont will have something
-      ** to resolve. */
-      pLevel->addrCont = sqlite3VdbeMakeLabel(pParse);
-      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
-      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;
-        int addrIfNull = 0; /* Init to avoid false-positive compiler warning */
-        if( pLevel->iLeftJoin ){
-          addrIfNull = sqlite3VdbeAddOp2(v, OP_IfNullRow, pLevel->iIdxCur, r1);
-        }
-        for(j=0; j<n; j++){
-          sqlite3VdbeAddOp3(v, OP_Column, pLevel->iIdxCur, 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);
-        if( pLevel->iLeftJoin ){
-          sqlite3VdbeJumpHere(v, addrIfNull);
-        }
-      }
-#endif /* SQLITE_DISABLE_SKIPAHEAD_DISTINCT */
-    }
-    if( pTabList->a[pLevel->iFrom].fg.fromExists ){
-      /* This is an EXISTS-to-JOIN optimization loop. If this loop sees a
-      ** successful row, it should break out of itself. */
-      sqlite3VdbeAddOp2(v, OP_Goto, 0, pLevel->addrBrk);
-      VdbeComment((v, "EXISTS break %d", i));
-    }
-    sqlite3VdbeResolveLabel(v, pLevel->addrCont);
-    if( pLevel->op!=OP_Noop ){
-      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);
-        addrSeek = 0;
-      }
-#endif
-    }
-    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 ){
-        SrcItem *pSrc = &pTabList->a[pLevel->iFrom];
-        assert( pLevel->iTabCur==pSrc->iCursor );
-        if( pSrc->fg.viaCoroutine ){
-          int m, n;
-          assert( pSrc->fg.isSubquery );
-          n = pSrc->u4.pSubq->regResult;
-          assert( pSrc->pSTab!=0 );
-          m = pSrc->pSTab->nCol;
-          sqlite3VdbeAddOp3(v, OP_Null, 0, n, n+m-1);
-        }
-        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].pSTab->zName));
-  }
-
-  assert( pWInfo->nLevel<=pTabList->nSrc );
-  for(i=0, pLevel=pWInfo->a; i<pWInfo->nLevel; i++, pLevel++){
-    int k, last;
-    VdbeOp *pOp, *pLastOp;
-    Index *pIdx = 0;
-    SrcItem *pTabItem = &pTabList->a[pLevel->iFrom];
-    Table *pTab = pTabItem->pSTab;
-    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 );
-      assert( pTabItem->fg.isSubquery );
-      assert( pTabItem->u4.pSubq->regResult>=0 );
-      translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur,
-                            pTabItem->u4.pSubq->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 if( pLoop->wsFlags & (WHERE_IDX_ONLY|WHERE_EXPRIDX) ){
-            if( pLoop->wsFlags & WHERE_IDX_ONLY ){
-              /* An error. pLoop is supposed to be a covering index loop,
-              ** and yet the VM code refers to a column of the table that
-              ** is not part of the index.  */
-              sqlite3ErrorMsg(pParse, "internal query planner error");
-              pParse->rc = SQLITE_INTERNAL;
-            }else{
-              /* The WHERE_EXPRIDX flag is set by the planner when it is likely
-              ** that pLoop is a covering index loop, but it is not possible
-              ** to be 100% sure. In this case, any OP_Explain opcode
-              ** corresponding to this loop describes the index as a "COVERING
-              ** INDEX". But, pOp proves that pLoop is not actually a covering
-              ** index loop. So clear the WHERE_EXPRIDX flag and rewrite the
-              ** text that accompanies the OP_Explain opcode, if any.  */
-              pLoop->wsFlags &= ~WHERE_EXPRIDX;
-              sqlite3WhereAddExplainText(pParse,
-                  pLevel->addrBody-1,
-                  pTabList,
-                  pLevel,
-                  pWInfo->wctrlFlags
-              );
-            }
-          }
-        }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)<pLastOp );
-#ifdef SQLITE_DEBUG
-      if( db->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 functions) 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( iRow<iSmall ){
-        sqlite3_result_int64(pCtx, 1 + iRow/(nSize+1));
-      }else{
-        sqlite3_result_int64(pCtx, 1 + nLarge + (iRow-iSmall)/nSize);
-      }
-    }
-  }
-}
-#define ntileFinalizeFunc ntileValueFunc
-
-/*
-** Context object for last_value() window function.
-*/
-struct LastValueCtx {
-  sqlite3_value *pVal;
-  int nVal;
-};
-
-/*
-** Implementation of last_value().
-*/
-static void last_valueStepFunc(
-  sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct LastValueCtx *p;
-  UNUSED_PARAMETER(nArg);
-  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    sqlite3_value_free(p->pVal);
-    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 referred 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; i<ArraySize(aUp); i++){
-        if( pFunc->zName==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 = sqlite3ExprInt32(db, 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; i<nSrc; i++){
-        if( pExpr->iTable==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; i<p->pSub->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; i<pAppend->nExpr; 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, 0) ){
-          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 &= ~(u32)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_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, sqlite3ExprInt32(db, 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==0 ){
-      sqlite3SelectDelete(db, pSub);
-    }else if( sqlite3SrcItemAttachSubquery(pParse, &p->pSrc->a[0], pSub, 0) ){
-      Table *pTab2;
-      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].pSTab = pTab;
-        pTab = pTab2;
-        memset(&w, 0, sizeof(w));
-        w.xExprCallback = sqlite3WindowExtraAggFuncDepth;
-        w.xSelectCallback = sqlite3WalkerDepthIncrease;
-        w.xSelectCallback2 = sqlite3WalkerDepthDecrease;
-        sqlite3WalkSelect(&w, 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(0,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
-  **   <expr> PRECEDING
-  **   CURRENT ROW
-  **   <expr> 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. Token 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 );
-    assert( ExprIsFullSize(p) );
-    p->y.pWin = pWin;
-    ExprSetProperty(p, EP_WinFunc|EP_FullSize);
-    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){
-  Window *pWin;
-  int nEphExpr;
-  Window *pMWin;
-  Vdbe *v;
-
-  assert( pSelect->pSrc->a[0].fg.isSubquery );
-  nEphExpr = pSelect->pSrc->a[0].u4.pSubq->pSelect->pEList->nExpr;
-  pMWin = pSelect->pWin;
-  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 <expr>" (eCond==0) or "FOLLOWING <expr>" (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<ArraySize(azErr) );
-  sqlite3VdbeAddOp2(v, OP_Integer, 0, regZero);
-  if( 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 implementation 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; i<pOrderBy->nExpr; 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;
-    int addrIf = 0;
-
-    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; i<nArg; i++){
-      if( i!=1 || pFunc->zName!=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( 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( 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( pWin->pFilter==0 );
-      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 ){
-      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); iOp<iEnd; iOp++){
-          VdbeOp *pOp = sqlite3VdbeGetOp(v, iOp);
-          if( pOp->opcode==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, (u16)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 <expr1> PRECEDING AND <expr2> 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 = <expr2>          // FOLLOWING expression
-**         regStart = <expr1>        // 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 <expr> PRECEDING AND <expr> PRECEDING"
-** and "BETWEEN <expr> FOLLOWING AND <expr> 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 <expr1> PRECEDING AND <expr2> 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 = <expr2>
-**         regStart = <expr1>
-**       }else{
-**         if( (regEnd--)<=0 ){
-**           AGGSTEP
-**         }
-**         RETURN_ROW
-**         if( (regStart--)<=0 ){
-**           AGGINVERSE
-**         }
-**       }
-**     }
-**     flush:
-**       if( (regEnd--)<=0 ){
-**         AGGSTEP
-**       }
-**       RETURN_ROW
-**
-**
-**   ROWS BETWEEN <expr1> FOLLOWING AND <expr2> 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 = <expr2>
-**       regStart = regEnd - <expr1>
-**     }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 equivalent 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 <expr1> 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 = <expr1>
-**     }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 <expr1> PRECEDING AND <expr2> PRECEDING
-**   ROWS BETWEEN <expr1> FOLLOWING AND <expr2> 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 = <expr2>
-**       regStart = <expr1>
-**       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 = <expr2>
-**           regStart = <expr1>
-**         }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 <expr1> PRECEDING AND <expr2> 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 = <expr2>
-**         regStart = <expr1>
-**       }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 <expr> FOLLOWING
-** or <expr PRECEDING) read from cursor csr.
-**
-**   RANGE BETWEEN <expr1> PRECEDING AND <expr2> 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 = <expr2>
-**         regStart = <expr1>
-**       }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 <expr1> FOLLOWING AND <expr2> 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 = <expr2>
-**         regStart = <expr1>
-**       }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].pSTab->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 <expr> PRECEDING */
-  int regEnd = 0;                 /* Value of <expr> 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
-  ** same 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 "<expr> PRECEDING" or "<expr> FOLLOWING"
-  ** clause, allocate registers to store the results of evaluating each
-  ** <expr>.  */
-  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; iInput<nInput; iInput++){
-    sqlite3VdbeAddOp3(v, OP_Column, csrInput, iInput, regNew+iInput);
-  }
-  sqlite3VdbeAddOp3(v, OP_MakeRecord, regNew, nInput, regRecord);
-
-  /* An input row has just been read into an array of registers starting
-  ** at regNew. If the window has a PARTITION clause, this block generates
-  ** VM code to check if the input row is the start of a new partition.
-  ** If so, it does an OP_Gosub to an address to be filled in later. The
-  ** address of the OP_Gosub is stored in local variable addrGosubFlush. */
-  if( pMWin->pPartition ){
-    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 <expr> */
-    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 );
-      /* assert( regStart>=0 );
-      ** regEnd = regEnd - regStart;
-      ** regStart = 0;   */
-      sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regEnd);
-      sqlite3VdbeAddOp2(v, OP_Integer, 0, regStart);
-
-      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 grammar.  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" */
-
-/*
-** Verify that the pParse->isCreate field is set
-*/
-#define ASSERT_IS_CREATE   assert(pParse->isCreate)
-
-/*
-** 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; };
-
-/*
-** Generate a syntax error
-*/
-static void parserSyntaxError(Parse *pParse, Token *p){
-  sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", p);
-}
-
-/*
-** Disable lookaside memory allocation for objects that might be
-** shared across database connections.
-*/
-static void disableLookaside(Parse *pParse){
-  sqlite3 *db = pParse->db;
-  pParse->disableLookaside++;
-#ifdef SQLITE_DEBUG
-  pParse->isCreate = 1;
-#endif
-  memset(&pParse->u1.cr, 0, sizeof(pParse->u1.cr));
-  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|SF_Values))==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;
-  }
-
-  /* Memory allocator for parser stack resizing.  This is a thin wrapper around
-  ** sqlite3_realloc() that includes a call to sqlite3FaultSim() to facilitate
-  ** testing.
-  */
-  static void *parserStackRealloc(
-    void *pOld,               /* Prior allocation */
-    sqlite3_uint64 newSize,   /* Requested new alloation size */
-    Parse *pParse             /* Parsing context */
-  ){
-    void *p = sqlite3FaultSim(700) ? 0 : sqlite3_realloc(pOld, newSize);
-    if( p==0 ) sqlite3OomFault(pParse->db);
-    return p;
-  }
-  static void parserStackFree(void *pOld, Parse *pParse){
-    (void)pParse;
-    sqlite3_free(pOld);
-  }
-
-  /* Return an integer that is the maximum allowed stack size */
-  static int parserStackSizeLimit(Parse *pParse){
-    return pParse->db->aLimit[SQLITE_LIMIT_PARSER_DEPTH];
-  }
-
-
-  /* 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;
-  }
-
-
-  /* Create a TK_ISNULL or TK_NOTNULL expression, perhaps optimized to
-  ** to TK_TRUEFALSE, if possible */
-  static Expr *sqlite3PExprIsNull(
-    Parse *pParse,  /* Parsing context */
-    int op,         /* TK_ISNULL or TK_NOTNULL */
-    Expr *pLeft     /* Operand */
-  ){
-    Expr *p = pLeft;
-    assert( op==TK_ISNULL || op==TK_NOTNULL );
-    assert( pLeft!=0 );
-    while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
-      p = p->pLeft;
-      assert( p!=0 );
-    }
-    switch( p->op ){
-      case TK_INTEGER:
-      case TK_STRING:
-      case TK_FLOAT:
-      case TK_BLOB:
-        sqlite3ExprDeferredDelete(pParse, pLeft);
-        return sqlite3ExprInt32(pParse->db, op==TK_NOTNULL);
-      default:
-        break;
-    }
-    return sqlite3PExpr(pParse, op, pLeft, 0);
-  }
-
-  /* Create a TK_IS or TK_ISNOT operator, perhaps optimized to
-  ** TK_ISNULL or TK_NOTNULL or TK_TRUEFALSE. */
-  static Expr *sqlite3PExprIs(
-    Parse *pParse,  /* Parsing context */
-    int op,         /* TK_IS or TK_ISNOT */
-    Expr *pLeft,    /* Left operand */
-    Expr *pRight    /* Right operand */
-  ){
-    if( pRight && pRight->op==TK_NULL ){
-      sqlite3ExprDeferredDelete(pParse, pRight);
-      return sqlite3PExprIsNull(pParse, op==TK_IS ? TK_ISNULL : TK_NOTNULL, pLeft);
-    }
-    return sqlite3PExpr(pParse, op, pLeft, pRight);
-  }
-
-  /* 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_ISNOT                          46
-#define TK_MATCH                          47
-#define TK_LIKE_KW                        48
-#define TK_BETWEEN                        49
-#define TK_IN                             50
-#define TK_ISNULL                         51
-#define TK_NOTNULL                        52
-#define TK_NE                             53
-#define TK_EQ                             54
-#define TK_GT                             55
-#define TK_LE                             56
-#define TK_LT                             57
-#define TK_GE                             58
-#define TK_ESCAPE                         59
-#define TK_ID                             60
-#define TK_COLUMNKW                       61
-#define TK_DO                             62
-#define TK_FOR                            63
-#define TK_IGNORE                         64
-#define TK_INITIALLY                      65
-#define TK_INSTEAD                        66
-#define TK_NO                             67
-#define TK_KEY                            68
-#define TK_OF                             69
-#define TK_OFFSET                         70
-#define TK_PRAGMA                         71
-#define TK_RAISE                          72
-#define TK_RECURSIVE                      73
-#define TK_REPLACE                        74
-#define TK_RESTRICT                       75
-#define TK_ROW                            76
-#define TK_ROWS                           77
-#define TK_TRIGGER                        78
-#define TK_VACUUM                         79
-#define TK_VIEW                           80
-#define TK_VIRTUAL                        81
-#define TK_WITH                           82
-#define TK_NULLS                          83
-#define TK_FIRST                          84
-#define TK_LAST                           85
-#define TK_CURRENT                        86
-#define TK_FOLLOWING                      87
-#define TK_PARTITION                      88
-#define TK_PRECEDING                      89
-#define TK_RANGE                          90
-#define TK_UNBOUNDED                      91
-#define TK_EXCLUDE                        92
-#define TK_GROUPS                         93
-#define TK_OTHERS                         94
-#define TK_TIES                           95
-#define TK_GENERATED                      96
-#define TK_ALWAYS                         97
-#define TK_MATERIALIZED                   98
-#define TK_REINDEX                        99
-#define TK_RENAME                         100
-#define TK_CTIME_KW                       101
-#define TK_ANY                            102
-#define TK_BITAND                         103
-#define TK_BITOR                          104
-#define TK_LSHIFT                         105
-#define TK_RSHIFT                         106
-#define TK_PLUS                           107
-#define TK_MINUS                          108
-#define TK_STAR                           109
-#define TK_SLASH                          110
-#define TK_REM                            111
-#define TK_CONCAT                         112
-#define TK_PTR                            113
-#define TK_COLLATE                        114
-#define TK_BITNOT                         115
-#define TK_ON                             116
-#define TK_INDEXED                        117
-#define TK_STRING                         118
-#define TK_JOIN_KW                        119
-#define TK_CONSTRAINT                     120
-#define TK_DEFAULT                        121
-#define TK_NULL                           122
-#define TK_PRIMARY                        123
-#define TK_UNIQUE                         124
-#define TK_CHECK                          125
-#define TK_REFERENCES                     126
-#define TK_AUTOINCR                       127
-#define TK_INSERT                         128
-#define TK_DELETE                         129
-#define TK_UPDATE                         130
-#define TK_SET                            131
-#define TK_DEFERRABLE                     132
-#define TK_FOREIGN                        133
-#define TK_DROP                           134
-#define TK_UNION                          135
-#define TK_ALL                            136
-#define TK_EXCEPT                         137
-#define TK_INTERSECT                      138
-#define TK_SELECT                         139
-#define TK_VALUES                         140
-#define TK_DISTINCT                       141
-#define TK_DOT                            142
-#define TK_FROM                           143
-#define TK_JOIN                           144
-#define TK_USING                          145
-#define TK_ORDER                          146
-#define TK_GROUP                          147
-#define TK_HAVING                         148
-#define TK_LIMIT                          149
-#define TK_WHERE                          150
-#define TK_RETURNING                      151
-#define TK_INTO                           152
-#define TK_NOTHING                        153
-#define TK_FLOAT                          154
-#define TK_BLOB                           155
-#define TK_INTEGER                        156
-#define TK_VARIABLE                       157
-#define TK_CASE                           158
-#define TK_WHEN                           159
-#define TK_THEN                           160
-#define TK_ELSE                           161
-#define TK_INDEX                          162
-#define TK_ALTER                          163
-#define TK_ADD                            164
-#define TK_WINDOW                         165
-#define TK_OVER                           166
-#define TK_FILTER                         167
-#define TK_COLUMN                         168
-#define TK_AGG_FUNCTION                   169
-#define TK_AGG_COLUMN                     170
-#define TK_TRUEFALSE                      171
-#define TK_FUNCTION                       172
-#define TK_UPLUS                          173
-#define TK_UMINUS                         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_QNUMBER                        183
-#define TK_SPACE                          184
-#define TK_COMMENT                        185
-#define TK_ILLEGAL                        186
-#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
-**    YYREALLOC          Name of the realloc() function to use
-**    YYFREE             Name of the free() function to use
-**    YYDYNSTACK         True if stack space should be extended on heap
-**    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
-**    YY_MIN_DSTRCTR     Minimum symbol value that has a destructor
-**    YY_MAX_DSTRCTR     Maximum symbol value that has a destructor
-*/
-#ifndef INTERFACE
-# define INTERFACE 1
-#endif
-/************* Begin control #defines *****************************************/
-#define YYCODETYPE unsigned short int
-#define YYNOCODE 322
-#define YYACTIONTYPE unsigned short int
-#define YYWILDCARD 102
-#define sqlite3ParserTOKENTYPE Token
-typedef union {
-  int yyinit;
-  sqlite3ParserTOKENTYPE yy0;
-  ExprList* yy14;
-  With* yy59;
-  Cte* yy67;
-  Upsert* yy122;
-  IdList* yy132;
-  int yy144;
-  const char* yy168;
-  SrcList* yy203;
-  Window* yy211;
-  OnOrUsing yy269;
-  struct TrigEvent yy286;
-  struct {int value; int mask;} yy383;
-  u32 yy391;
-  TriggerStep* yy427;
-  Expr* yy454;
-  u8 yy462;
-  struct FrameBound yy509;
-  Select* yy555;
-} YYMINORTYPE;
-#ifndef YYSTACKDEPTH
-#define YYSTACKDEPTH 50
-#endif
-#define sqlite3ParserARG_SDECL
-#define sqlite3ParserARG_PDECL
-#define sqlite3ParserARG_PARAM
-#define sqlite3ParserARG_FETCH
-#define sqlite3ParserARG_STORE
-#undef YYREALLOC
-#define YYREALLOC parserStackRealloc
-#undef YYFREE
-#define YYFREE parserStackFree
-#undef YYDYNSTACK
-#define YYDYNSTACK 1
-#undef YYSIZELIMIT
-#define YYSIZELIMIT parserStackSizeLimit
-#define sqlite3ParserCTX(P) ((P)->pParse)
-#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;
-#undef YYERRORSYMBOL
-#undef YYERRSYMDT
-#undef YYFALLBACK
-#define YYFALLBACK 1
-#define YYNSTATE             600
-#define YYNRULE              412
-#define YYNRULE_WITH_ACTION  348
-#define YYNTOKEN             187
-#define YY_MAX_SHIFT         599
-#define YY_MIN_SHIFTREDUCE   867
-#define YY_MAX_SHIFTREDUCE   1278
-#define YY_ERROR_ACTION      1279
-#define YY_ACCEPT_ACTION     1280
-#define YY_NO_ACTION         1281
-#define YY_MIN_REDUCE        1282
-#define YY_MAX_REDUCE        1693
-#define YY_MIN_DSTRCTR       206
-#define YY_MAX_DSTRCTR       319
-/************* 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
-
-/* Macro to determine if stack space has the ability to grow using
-** heap memory.
-*/
-#if YYSTACKDEPTH<=0 || YYDYNSTACK
-# define YYGROWABLESTACK 1
-#else
-# define YYGROWABLESTACK 0
-#endif
-
-/* Guarantee a minimum number of initial stack slots.
-*/
-#if YYSTACKDEPTH<=0
-# undef YYSTACKDEPTH
-# define YYSTACKDEPTH 2  /* Need a minimum stack size */
-#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 (2379)
-static const YYACTIONTYPE yy_action[] = {
- /*     0 */   134,  131,  238,  290,  290, 1353,  593, 1332,  478, 1606,
- /*    10 */   593, 1315,  593,    7,  593, 1353,  590,  593,  579,  424,
- /*    20 */  1566,  134,  131,  238, 1318,  541,  478,  477,  575,   84,
- /*    30 */    84, 1005,  303,   84,   84,   51,   51,   63,   63, 1006,
- /*    40 */    84,   84,  498,  141,  142,   93,  442, 1254, 1254, 1085,
- /*    50 */  1088, 1075, 1075,  139,  139,  140,  140,  140,  140,  424,
- /*    60 */   296,  296,  498,  296,  296,  567,  553,  296,  296, 1306,
- /*    70 */   574, 1358, 1358,  590,  542,  579,  590,  574,  579,  548,
- /*    80 */   590, 1304,  579,  141,  142,   93,  576, 1254, 1254, 1085,
- /*    90 */  1088, 1075, 1075,  139,  139,  140,  140,  140,  140,  399,
- /*   100 */   478,  395,    6,  138,  138,  138,  138,  137,  137,  136,
- /*   110 */   136,  136,  135,  132,  463,   44,  342,  593,  305, 1127,
- /*   120 */  1280,    1,    1,  599,    2, 1284,  598, 1200, 1284, 1200,
- /*   130 */   330,  424,  158,  330, 1613,  158,  390,  116,  308, 1366,
- /*   140 */    51,   51, 1366,  138,  138,  138,  138,  137,  137,  136,
- /*   150 */   136,  136,  135,  132,  463,  141,  142,   93,  515, 1254,
- /*   160 */  1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,
- /*   170 */   140, 1230,  329,  584,  296,  296,  212,  296,  296,  568,
- /*   180 */   568,  488,  143, 1072, 1072, 1086, 1089,  590, 1195,  579,
- /*   190 */   590,  340,  579,  140,  140,  140,  140,  133,  392,  564,
- /*   200 */   536, 1195,  250,  425, 1195,  250,  137,  137,  136,  136,
- /*   210 */   136,  135,  132,  463,  291,  138,  138,  138,  138,  137,
- /*   220 */   137,  136,  136,  136,  135,  132,  463,  966, 1230, 1231,
- /*   230 */  1230,  412,  965,  467,  412,  424,  467,  489,  357, 1611,
- /*   240 */   391,  138,  138,  138,  138,  137,  137,  136,  136,  136,
- /*   250 */   135,  132,  463,  463,  134,  131,  238,  555, 1076,  141,
- /*   260 */   142,   93,  593, 1254, 1254, 1085, 1088, 1075, 1075,  139,
- /*   270 */   139,  140,  140,  140,  140, 1317,  134,  131,  238,  424,
- /*   280 */   549, 1597, 1531,  333,   97,   83,   83,  140,  140,  140,
- /*   290 */   140,  138,  138,  138,  138,  137,  137,  136,  136,  136,
- /*   300 */   135,  132,  463,  141,  142,   93, 1657, 1254, 1254, 1085,
- /*   310 */  1088, 1075, 1075,  139,  139,  140,  140,  140,  140,  138,
- /*   320 */   138,  138,  138,  137,  137,  136,  136,  136,  135,  132,
- /*   330 */   463,  591, 1230,  958,  958,  138,  138,  138,  138,  137,
- /*   340 */   137,  136,  136,  136,  135,  132,  463,   44,  398,  547,
- /*   350 */  1306,  136,  136,  136,  135,  132,  463,  386,  593,  442,
- /*   360 */   595,  145,  595,  138,  138,  138,  138,  137,  137,  136,
- /*   370 */   136,  136,  135,  132,  463,  500, 1230,  112,  550,  460,
- /*   380 */   459,   51,   51,  424,  296,  296,  479,  334, 1259, 1230,
- /*   390 */  1231, 1230, 1599, 1261,  388,  312,  444,  590,  246,  579,
- /*   400 */   546, 1260,  271,  235,  329,  584,  551,  141,  142,   93,
- /*   410 */   429, 1254, 1254, 1085, 1088, 1075, 1075,  139,  139,  140,
- /*   420 */   140,  140,  140,   22,   22, 1230, 1262,  424, 1262,  216,
- /*   430 */   296,  296,   98, 1230, 1231, 1230,  264,  884,   45,  528,
- /*   440 */   525,  524, 1041,  590, 1269,  579,  421,  420,  393,  523,
- /*   450 */    44,  141,  142,   93,  498, 1254, 1254, 1085, 1088, 1075,
- /*   460 */  1075,  139,  139,  140,  140,  140,  140,  138,  138,  138,
- /*   470 */   138,  137,  137,  136,  136,  136,  135,  132,  463,  593,
- /*   480 */  1611,  561, 1230, 1231, 1230,   23,  264,  515,  200,  528,
- /*   490 */   525,  524,  127,  585,  509,    4,  355,  487,  506,  523,
- /*   500 */   593,  498,   84,   84,  134,  131,  238,  329,  584,  588,
- /*   510 */  1627,  138,  138,  138,  138,  137,  137,  136,  136,  136,
- /*   520 */   135,  132,  463,   19,   19,  435, 1230, 1460,  297,  297,
- /*   530 */   311,  424, 1565,  464, 1631,  599,    2, 1284,  437,  574,
- /*   540 */  1107,  590,  330,  579,  158,  582,  489,  357,  573,  593,
- /*   550 */   592, 1366,  409, 1274, 1230,  141,  142,   93, 1364, 1254,
- /*   560 */  1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,
- /*   570 */   140,  389,   84,   84, 1062,  567, 1230,  313, 1523,  593,
- /*   580 */   125,  125,  970, 1230, 1231, 1230,  296,  296,  126,   46,
- /*   590 */   464,  594,  464,  296,  296, 1050, 1230,  218,  439,  590,
- /*   600 */  1604,  579,   84,   84,    7,  403,  590,  515,  579,  325,
- /*   610 */   417, 1230, 1231, 1230,  250,  138,  138,  138,  138,  137,
- /*   620 */   137,  136,  136,  136,  135,  132,  463, 1050, 1050, 1052,
- /*   630 */  1053,   35, 1275, 1230, 1231, 1230,  424, 1370,  993,  574,
- /*   640 */   371,  414,  274,  412, 1597,  467, 1302,  552,  451,  590,
- /*   650 */   543,  579, 1530, 1230, 1231, 1230, 1214,  201,  409, 1174,
- /*   660 */   141,  142,   93,  223, 1254, 1254, 1085, 1088, 1075, 1075,
- /*   670 */   139,  139,  140,  140,  140,  140,  296,  296, 1250,  593,
- /*   680 */   424,  296,  296,  236,  529,  296,  296,  515,  100,  590,
- /*   690 */  1600,  579,   48, 1605,  590, 1230,  579,    7,  590,  577,
- /*   700 */   579,  904,   84,   84,  141,  142,   93,  496, 1254, 1254,
- /*   710 */  1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,  140,
- /*   720 */   138,  138,  138,  138,  137,  137,  136,  136,  136,  135,
- /*   730 */   132,  463, 1365, 1230,  296,  296, 1250,  115, 1275,  326,
- /*   740 */   233,  539, 1062,   40,  282,  127,  585,  590,    4,  579,
- /*   750 */   329,  584, 1230, 1231, 1230, 1598,  593,  388,  904, 1051,
- /*   760 */  1356, 1356,  588, 1050,  138,  138,  138,  138,  137,  137,
- /*   770 */   136,  136,  136,  135,  132,  463,  185,  593, 1230,   19,
- /*   780 */    19, 1230,  971, 1597,  424, 1651,  464,  129,  908, 1195,
- /*   790 */  1230, 1231, 1230, 1325,  443, 1050, 1050, 1052,  582, 1603,
- /*   800 */   149,  149, 1195,    7,    5, 1195, 1687,  410,  141,  142,
- /*   810 */    93, 1536, 1254, 1254, 1085, 1088, 1075, 1075,  139,  139,
- /*   820 */   140,  140,  140,  140, 1214,  397,  593, 1062,  424, 1536,
- /*   830 */  1538,   50,  901,  125,  125, 1230, 1231, 1230, 1230, 1231,
- /*   840 */  1230,  126, 1230,  464,  594,  464,  515, 1230, 1050,   84,
- /*   850 */    84,    3,  141,  142,   93,  924, 1254, 1254, 1085, 1088,
- /*   860 */  1075, 1075,  139,  139,  140,  140,  140,  140,  138,  138,
- /*   870 */   138,  138,  137,  137,  136,  136,  136,  135,  132,  463,
- /*   880 */  1050, 1050, 1052, 1053,   35,  442,  457,  532,  433, 1230,
- /*   890 */  1062, 1361,  540,  540, 1598,  925,  388,    7, 1129, 1230,
- /*   900 */  1231, 1230, 1129, 1536, 1230, 1231, 1230, 1051,  570, 1214,
- /*   910 */   593, 1050,  138,  138,  138,  138,  137,  137,  136,  136,
- /*   920 */   136,  135,  132,  463,    6,  185, 1195, 1230,  231,  593,
- /*   930 */   382,  992,  424,  151,  151,  510, 1213,  557,  482, 1195,
- /*   940 */   381,  160, 1195, 1050, 1050, 1052, 1230, 1231, 1230,  422,
- /*   950 */   593,  447,   84,   84,  593,  217,  141,  142,   93,  593,
- /*   960 */  1254, 1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,
- /*   970 */   140,  140, 1214,   19,   19,  593,  424,   19,   19,  442,
- /*   980 */  1063,  442,   19,   19, 1230, 1231, 1230,  515,  445,  458,
- /*   990 */  1597,  386,  315, 1175, 1685,  556, 1685,  450,   84,   84,
- /*  1000 */   141,  142,   93,  505, 1254, 1254, 1085, 1088, 1075, 1075,
- /*  1010 */   139,  139,  140,  140,  140,  140,  138,  138,  138,  138,
- /*  1020 */   137,  137,  136,  136,  136,  135,  132,  463,  442, 1147,
- /*  1030 */   454, 1597,  362, 1041,  593,  462, 1460, 1233,   47, 1393,
- /*  1040 */   324,  565,  565,  115, 1148,  449,    7,  460,  459,  307,
- /*  1050 */   375,  354,  593,  113,  593,  329,  584,   19,   19, 1149,
- /*  1060 */   138,  138,  138,  138,  137,  137,  136,  136,  136,  135,
- /*  1070 */   132,  463,  209, 1173,  563,   19,   19,   19,   19,   49,
- /*  1080 */   424,  944, 1175, 1686, 1046, 1686,  218,  355,  484,  343,
- /*  1090 */   210,  945,  569,  562, 1262, 1233, 1262,  490,  314,  423,
- /*  1100 */   424, 1598, 1206,  388,  141,  142,   93,  440, 1254, 1254,
- /*  1110 */  1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,  140,
- /*  1120 */   352,  316,  531,  316,  141,  142,   93,  549, 1254, 1254,
- /*  1130 */  1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,  140,
- /*  1140 */   446,   10, 1598,  274,  388,  915,  281,  299,  383,  534,
- /*  1150 */   378,  533,  269,  593, 1206,  587,  587,  587,  374,  293,
- /*  1160 */  1579,  991, 1173,  302,  138,  138,  138,  138,  137,  137,
- /*  1170 */   136,  136,  136,  135,  132,  463,   53,   53,  520, 1250,
- /*  1180 */   593, 1147, 1576,  431,  138,  138,  138,  138,  137,  137,
- /*  1190 */   136,  136,  136,  135,  132,  463, 1148,  301,  593, 1577,
- /*  1200 */   593, 1307,  431,   54,   54,  593,  268,  593,  461,  461,
- /*  1210 */   461, 1149,  347,  492,  424,  135,  132,  463, 1146, 1195,
- /*  1220 */   474,   68,   68,   69,   69,  550,  332,  287,   21,   21,
- /*  1230 */    55,   55, 1195,  581,  424, 1195,  309, 1250,  141,  142,
- /*  1240 */    93,  119, 1254, 1254, 1085, 1088, 1075, 1075,  139,  139,
- /*  1250 */   140,  140,  140,  140,  593,  237,  480, 1476,  141,  142,
- /*  1260 */    93,  593, 1254, 1254, 1085, 1088, 1075, 1075,  139,  139,
- /*  1270 */   140,  140,  140,  140,  344,  430,  346,   70,   70,  494,
- /*  1280 */   991, 1132, 1132,  512,   56,   56, 1269,  593,  268,  593,
- /*  1290 */   369,  374,  593,  481,  215,  384, 1624,  481,  138,  138,
- /*  1300 */   138,  138,  137,  137,  136,  136,  136,  135,  132,  463,
- /*  1310 */    71,   71,   72,   72,  225,   73,   73,  593,  138,  138,
- /*  1320 */   138,  138,  137,  137,  136,  136,  136,  135,  132,  463,
- /*  1330 */   586,  431,  593,  872,  873,  874,  593,  911,  593, 1602,
- /*  1340 */    74,   74,  593,    7, 1460,  242,  593,  306,  424, 1578,
- /*  1350 */   472,  306,  364,  219,  367,   75,   75,  430,  345,   57,
- /*  1360 */    57,   58,   58,  432,  187,   59,   59,  593,  424,   61,
- /*  1370 */    61, 1475,  141,  142,   93,  123, 1254, 1254, 1085, 1088,
- /*  1380 */  1075, 1075,  139,  139,  140,  140,  140,  140,  424,  570,
- /*  1390 */    62,   62,  141,  142,   93,  911, 1254, 1254, 1085, 1088,
- /*  1400 */  1075, 1075,  139,  139,  140,  140,  140,  140,  161,  384,
- /*  1410 */  1624, 1474,  141,  130,   93,  441, 1254, 1254, 1085, 1088,
- /*  1420 */  1075, 1075,  139,  139,  140,  140,  140,  140,  267,  266,
- /*  1430 */   265, 1460,  138,  138,  138,  138,  137,  137,  136,  136,
- /*  1440 */   136,  135,  132,  463,  593, 1336,  593, 1269, 1460,  384,
- /*  1450 */  1624,  231,  138,  138,  138,  138,  137,  137,  136,  136,
- /*  1460 */   136,  135,  132,  463,  593,  163,  593,   76,   76,   77,
- /*  1470 */    77,  593,  138,  138,  138,  138,  137,  137,  136,  136,
- /*  1480 */   136,  135,  132,  463,  475,  593,  483,   78,   78,   20,
- /*  1490 */    20, 1249,  424,  491,   79,   79,  495,  422,  295,  235,
- /*  1500 */  1574,   38,  511,  896,  422,  335,  240,  422,  147,  147,
- /*  1510 */   112,  593,  424,  593,  101,  222,  991,  142,   93,  455,
- /*  1520 */  1254, 1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,
- /*  1530 */   140,  140,  593,   39,  148,  148,   80,   80,   93,  551,
- /*  1540 */  1254, 1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,
- /*  1550 */   140,  140,  328,  923,  922,   64,   64,  502, 1656, 1005,
- /*  1560 */   933,  896,  124,  422,  121,  254,  593, 1006,  593,  226,
- /*  1570 */   593,  127,  585,  164,    4,   16,  138,  138,  138,  138,
- /*  1580 */   137,  137,  136,  136,  136,  135,  132,  463,  588,   81,
- /*  1590 */    81,   65,   65,   82,   82,  593,  138,  138,  138,  138,
- /*  1600 */   137,  137,  136,  136,  136,  135,  132,  463,  593,  226,
- /*  1610 */   237,  966,  464,  593,  298,  593,  965,  593,   66,   66,
- /*  1620 */   593, 1170,  593,  411,  582,  353,  469,  115,  593,  471,
- /*  1630 */   169,  173,  173,  593,   44,  991,  174,  174,   89,   89,
- /*  1640 */    67,   67,  593,   85,   85,  150,  150, 1114, 1043,  593,
- /*  1650 */   273,   86,   86, 1062,  593,  503,  171,  171,  593,  125,
- /*  1660 */   125,  497,  593,  273,  336,  152,  152,  126, 1335,  464,
- /*  1670 */   594,  464,  146,  146, 1050,  593,  545,  172,  172,  593,
- /*  1680 */  1054,  165,  165,  256,  339,  156,  156,  127,  585, 1586,
- /*  1690 */     4,  329,  584,  499,  358,  273,  115,  348,  155,  155,
- /*  1700 */   930,  931,  153,  153,  588, 1114, 1050, 1050, 1052, 1053,
- /*  1710 */    35, 1554,  521,  593,  270, 1008, 1009,    9,  593,  372,
- /*  1720 */   593,  115,  593,  168,  593,  115,  593, 1110,  464,  270,
- /*  1730 */   996,  964,  273,  129, 1645, 1214,  154,  154, 1054, 1404,
- /*  1740 */   582,   88,   88,   90,   90,   87,   87,   52,   52,   60,
- /*  1750 */    60, 1405,  504,  537,  559, 1179,  961,  507,  129,  558,
- /*  1760 */   127,  585, 1126,    4, 1126, 1125,  894, 1125,  162, 1062,
- /*  1770 */   963,  359,  129, 1401,  363,  125,  125,  588,  366,  368,
- /*  1780 */   370, 1349, 1334,  126, 1333,  464,  594,  464,  377,  387,
- /*  1790 */  1050, 1391, 1414, 1618, 1459, 1387, 1399,  208,  580, 1464,
- /*  1800 */  1314,  464,  243,  516, 1305, 1293, 1384, 1292, 1294, 1638,
- /*  1810 */   288,  170,  228,  582,   12,  408,  321,  322,  241,  323,
- /*  1820 */   245, 1446, 1050, 1050, 1052, 1053,   35,  559,  304,  350,
- /*  1830 */   351,  501,  560,  127,  585, 1441,    4, 1451, 1434,  310,
- /*  1840 */  1450,  526, 1062, 1332,  415,  380,  232, 1527,  125,  125,
- /*  1850 */   588, 1214, 1396,  356, 1526,  583,  126, 1397,  464,  594,
- /*  1860 */   464, 1641,  535, 1050, 1581, 1395, 1269, 1583, 1582,  213,
- /*  1870 */   402,  277,  214,  227,  464, 1573,  239, 1571, 1266, 1394,
- /*  1880 */   434,  198,  100,  224,   96,  183,  582,  191,  485,  193,
- /*  1890 */   486,  194,  195,  196,  519, 1050, 1050, 1052, 1053,   35,
- /*  1900 */   559,  113,  252,  413, 1447,  558,  493,   13, 1455,  416,
- /*  1910 */  1453, 1452,   14,  202, 1521, 1062, 1532,  508,  258,  106,
- /*  1920 */   514,  125,  125,   99, 1214, 1543,  289,  260,  206,  126,
- /*  1930 */   365,  464,  594,  464,  361,  517, 1050,  261,  448, 1295,
- /*  1940 */   262,  418, 1352, 1351,  108, 1350, 1655, 1654, 1343,  915,
- /*  1950 */   419, 1322,  233,  452,  319,  379, 1321,  453, 1623,  320,
- /*  1960 */  1320,  275, 1653,  544,  276, 1609, 1608, 1342, 1050, 1050,
- /*  1970 */  1052, 1053,   35, 1630, 1218,  466,  385,  456,  300, 1419,
- /*  1980 */   144, 1418,  570,  407,  407,  406,  284,  404,   11, 1508,
- /*  1990 */   881,  396,  120,  127,  585,  394,    4, 1214,  327,  114,
- /*  2000 */  1375, 1374,  220,  247,  400,  338,  401,  554,   42, 1224,
- /*  2010 */   588,  596,  283,  337,  285,  286,  188,  597, 1290, 1285,
- /*  2020 */   175, 1558,  176, 1559, 1557, 1556,  159,  317,  229,  177,
- /*  2030 */   868,  230,   91,  465,  464,  221,  331,  468, 1165,  470,
- /*  2040 */   473,   94,  244,   95,  249,  189,  582, 1124, 1122,  341,
- /*  2050 */   427,  190,  178, 1249,  179,   43,  192,  947,  349,  428,
- /*  2060 */  1138,  197,  251,  180,  181,  436,  102,  182,  438,  103,
- /*  2070 */   104,  199,  248, 1140,  253, 1062,  105,  255, 1137,  166,
- /*  2080 */    24,  125,  125,  257, 1264,  273,  360,  513,  259,  126,
- /*  2090 */    15,  464,  594,  464,  204,  883, 1050,  518,  263,  373,
- /*  2100 */   381,   92,  585, 1130,    4,  203,  205,  426,  107,  522,
- /*  2110 */    25,   26,  329,  584,  913,  572,  527,  376,  588,  926,
- /*  2120 */   530,  109,  184,  318,  167,  110,   27,  538, 1050, 1050,
- /*  2130 */  1052, 1053,   35, 1211, 1091,   17,  476,  111, 1181,  234,
- /*  2140 */   292, 1180,  464,  294,  207,  994,  129, 1201,  272, 1000,
- /*  2150 */    28, 1197,   29,   30,  582, 1199, 1205, 1214,   31, 1204,
- /*  2160 */    32, 1186,   41,  566,   33, 1105,  211,    8,  115, 1092,
- /*  2170 */  1090, 1094,   34,  278,  578, 1095,  117,  122,  118, 1145,
- /*  2180 */    36,   18,  128, 1062, 1055,  895,  957,   37,  589,  125,
- /*  2190 */   125,  279,  186,  280, 1646,  157,  405,  126, 1220,  464,
- /*  2200 */   594,  464, 1218,  466, 1050, 1219,  300, 1281, 1281, 1281,
- /*  2210 */  1281,  407,  407,  406,  284,  404, 1281, 1281,  881, 1281,
- /*  2220 */   300, 1281, 1281,  571, 1281,  407,  407,  406,  284,  404,
- /*  2230 */  1281,  247,  881,  338, 1281, 1281, 1050, 1050, 1052, 1053,
- /*  2240 */    35,  337, 1281, 1281, 1281,  247, 1281,  338, 1281, 1281,
- /*  2250 */  1281, 1281, 1281, 1281, 1281,  337, 1281, 1281, 1281, 1281,
- /*  2260 */  1281, 1281, 1281, 1281, 1281, 1214, 1281, 1281, 1281, 1281,
- /*  2270 */  1281, 1281,  249, 1281, 1281, 1281, 1281, 1281, 1281, 1281,
- /*  2280 */   178, 1281, 1281,   43, 1281, 1281,  249, 1281, 1281, 1281,
- /*  2290 */  1281, 1281, 1281, 1281,  178, 1281, 1281,   43, 1281, 1281,
- /*  2300 */   248, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281,
- /*  2310 */  1281, 1281, 1281, 1281,  248, 1281, 1281, 1281, 1281, 1281,
- /*  2320 */  1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281,
- /*  2330 */  1281, 1281, 1281, 1281, 1281,  426, 1281, 1281, 1281, 1281,
- /*  2340 */   329,  584, 1281, 1281, 1281, 1281, 1281, 1281, 1281,  426,
- /*  2350 */  1281, 1281, 1281, 1281,  329,  584, 1281, 1281, 1281, 1281,
- /*  2360 */  1281, 1281, 1281, 1281,  476, 1281, 1281, 1281, 1281, 1281,
- /*  2370 */  1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281,  476,
-};
-static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   277,  278,  279,  241,  242,  225,  195,  227,  195,  312,
- /*    10 */   195,  218,  195,  316,  195,  235,  254,  195,  256,   19,
- /*    20 */   297,  277,  278,  279,  218,  206,  213,  214,  206,  218,
- /*    30 */   219,   31,  206,  218,  219,  218,  219,  218,  219,   39,
- /*    40 */   218,  219,  195,   43,   44,   45,  195,   47,   48,   49,
- /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,   58,   19,
- /*    60 */   241,  242,  195,  241,  242,  195,  255,  241,  242,  195,
- /*    70 */   255,  237,  238,  254,  255,  256,  254,  255,  256,  264,
- /*    80 */   254,  207,  256,   43,   44,   45,  264,   47,   48,   49,
- /*    90 */    50,   51,   52,   53,   54,   55,   56,   57,   58,  251,
- /*   100 */   287,  253,  215,  103,  104,  105,  106,  107,  108,  109,
- /*   110 */   110,  111,  112,  113,  114,   82,  265,  195,  271,   11,
- /*   120 */   187,  188,  189,  190,  191,  192,  190,   87,  192,   89,
- /*   130 */   197,   19,  199,  197,  317,  199,  319,   25,  271,  206,
- /*   140 */   218,  219,  206,  103,  104,  105,  106,  107,  108,  109,
- /*   150 */   110,  111,  112,  113,  114,   43,   44,   45,  195,   47,
- /*   160 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*   170 */    58,   60,  139,  140,  241,  242,  289,  241,  242,  309,
- /*   180 */   310,  294,   70,   47,   48,   49,   50,  254,   77,  256,
- /*   190 */   254,  195,  256,   55,   56,   57,   58,   59,  221,   88,
- /*   200 */   109,   90,  269,  240,   93,  269,  107,  108,  109,  110,
- /*   210 */   111,  112,  113,  114,  215,  103,  104,  105,  106,  107,
- /*   220 */   108,  109,  110,  111,  112,  113,  114,  136,  117,  118,
- /*   230 */   119,  298,  141,  300,  298,   19,  300,  129,  130,  317,
- /*   240 */   318,  103,  104,  105,  106,  107,  108,  109,  110,  111,
- /*   250 */   112,  113,  114,  114,  277,  278,  279,  146,  122,   43,
- /*   260 */    44,   45,  195,   47,   48,   49,   50,   51,   52,   53,
- /*   270 */    54,   55,   56,   57,   58,  218,  277,  278,  279,   19,
- /*   280 */    19,  195,  286,   23,   68,  218,  219,   55,   56,   57,
- /*   290 */    58,  103,  104,  105,  106,  107,  108,  109,  110,  111,
- /*   300 */   112,  113,  114,   43,   44,   45,  232,   47,   48,   49,
- /*   310 */    50,   51,   52,   53,   54,   55,   56,   57,   58,  103,
- /*   320 */   104,  105,  106,  107,  108,  109,  110,  111,  112,  113,
- /*   330 */   114,  135,   60,  137,  138,  103,  104,  105,  106,  107,
- /*   340 */   108,  109,  110,  111,  112,  113,  114,   82,  281,  206,
- /*   350 */   195,  109,  110,  111,  112,  113,  114,  195,  195,  195,
- /*   360 */   205,   22,  207,  103,  104,  105,  106,  107,  108,  109,
- /*   370 */   110,  111,  112,  113,  114,  195,   60,  116,  117,  107,
- /*   380 */   108,  218,  219,   19,  241,  242,  121,   23,  116,  117,
- /*   390 */   118,  119,  306,  121,  308,  206,  234,  254,   15,  256,
- /*   400 */   195,  129,  259,  260,  139,  140,  145,   43,   44,   45,
- /*   410 */   200,   47,   48,   49,   50,   51,   52,   53,   54,   55,
- /*   420 */    56,   57,   58,  218,  219,   60,  154,   19,  156,  265,
- /*   430 */   241,  242,   24,  117,  118,  119,  120,   21,   73,  123,
- /*   440 */   124,  125,   74,  254,   61,  256,  107,  108,  221,  133,
- /*   450 */    82,   43,   44,   45,  195,   47,   48,   49,   50,   51,
- /*   460 */    52,   53,   54,   55,   56,   57,   58,  103,  104,  105,
- /*   470 */   106,  107,  108,  109,  110,  111,  112,  113,  114,  195,
- /*   480 */   317,  318,  117,  118,  119,   22,  120,  195,   22,  123,
- /*   490 */   124,  125,   19,   20,  284,   22,  128,   81,  288,  133,
- /*   500 */   195,  195,  218,  219,  277,  278,  279,  139,  140,   36,
- /*   510 */   195,  103,  104,  105,  106,  107,  108,  109,  110,  111,
- /*   520 */   112,  113,  114,  218,  219,   62,   60,  195,  241,  242,
- /*   530 */   271,   19,  240,   60,  189,  190,  191,  192,  233,  255,
- /*   540 */   124,  254,  197,  256,  199,   72,  129,  130,  264,  195,
- /*   550 */   195,  206,   22,   23,   60,   43,   44,   45,  206,   47,
- /*   560 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*   570 */    58,  195,  218,  219,  101,  195,   60,  271,  162,  195,
- /*   580 */   107,  108,  109,  117,  118,  119,  241,  242,  115,   73,
- /*   590 */   117,  118,  119,  241,  242,  122,   60,  195,  266,  254,
- /*   600 */   312,  256,  218,  219,  316,  203,  254,  195,  256,  255,
- /*   610 */   208,  117,  118,  119,  269,  103,  104,  105,  106,  107,
- /*   620 */   108,  109,  110,  111,  112,  113,  114,  154,  155,  156,
- /*   630 */   157,  158,  102,  117,  118,  119,   19,  242,  144,  255,
- /*   640 */    23,  206,   24,  298,  195,  300,  206,  195,  264,  254,
- /*   650 */   206,  256,  240,  117,  118,  119,  183,   22,   22,   23,
- /*   660 */    43,   44,   45,  151,   47,   48,   49,   50,   51,   52,
- /*   670 */    53,   54,   55,   56,   57,   58,  241,  242,   60,  195,
- /*   680 */    19,  241,  242,  195,   23,  241,  242,  195,  152,  254,
- /*   690 */   310,  256,  243,  312,  254,   60,  256,  316,  254,  206,
- /*   700 */   256,   60,  218,  219,   43,   44,   45,  272,   47,   48,
- /*   710 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
- /*   720 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
- /*   730 */   113,  114,  240,   60,  241,  242,  118,   25,  102,  255,
- /*   740 */   166,  167,  101,   22,   26,   19,   20,  254,   22,  256,
- /*   750 */   139,  140,  117,  118,  119,  306,  195,  308,  117,  118,
- /*   760 */   237,  238,   36,  122,  103,  104,  105,  106,  107,  108,
- /*   770 */   109,  110,  111,  112,  113,  114,  195,  195,   60,  218,
- /*   780 */   219,   60,  109,  195,   19,  217,   60,   25,   23,   77,
- /*   790 */   117,  118,  119,  225,  233,  154,  155,  156,   72,  312,
- /*   800 */   218,  219,   90,  316,   22,   93,  303,  304,   43,   44,
- /*   810 */    45,  195,   47,   48,   49,   50,   51,   52,   53,   54,
- /*   820 */    55,   56,   57,   58,  183,  195,  195,  101,   19,  213,
- /*   830 */   214,  243,   23,  107,  108,  117,  118,  119,  117,  118,
- /*   840 */   119,  115,   60,  117,  118,  119,  195,   60,  122,  218,
- /*   850 */   219,   22,   43,   44,   45,   35,   47,   48,   49,   50,
- /*   860 */    51,   52,   53,   54,   55,   56,   57,   58,  103,  104,
- /*   870 */   105,  106,  107,  108,  109,  110,  111,  112,  113,  114,
- /*   880 */   154,  155,  156,  157,  158,  195,  255,   67,  195,   60,
- /*   890 */   101,  240,  311,  312,  306,   75,  308,  316,   29,  117,
- /*   900 */   118,  119,   33,  287,  117,  118,  119,  118,  146,  183,
- /*   910 */   195,  122,  103,  104,  105,  106,  107,  108,  109,  110,
- /*   920 */   111,  112,  113,  114,  215,  195,   77,   60,   25,  195,
- /*   930 */   122,  144,   19,  218,  219,   66,   23,   88,  246,   90,
- /*   940 */   132,   25,   93,  154,  155,  156,  117,  118,  119,  257,
- /*   950 */   195,  131,  218,  219,  195,  265,   43,   44,   45,  195,
- /*   960 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*   970 */    57,   58,  183,  218,  219,  195,   19,  218,  219,  195,
- /*   980 */    23,  195,  218,  219,  117,  118,  119,  195,  233,  255,
- /*   990 */   195,  195,  233,   22,   23,  146,   25,  233,  218,  219,
- /*  1000 */    43,   44,   45,  294,   47,   48,   49,   50,   51,   52,
- /*  1010 */    53,   54,   55,   56,   57,   58,  103,  104,  105,  106,
- /*  1020 */   107,  108,  109,  110,  111,  112,  113,  114,  195,   12,
- /*  1030 */   234,  195,  240,   74,  195,  255,  195,   60,  243,  262,
- /*  1040 */   263,  311,  312,   25,   27,   19,  316,  107,  108,  265,
- /*  1050 */    24,  265,  195,  150,  195,  139,  140,  218,  219,   42,
- /*  1060 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
- /*  1070 */   113,  114,  233,  102,   67,  218,  219,  218,  219,  243,
- /*  1080 */    19,   64,   22,   23,   23,   25,  195,  128,  129,  130,
- /*  1090 */   233,   74,  233,   86,  154,  118,  156,  130,  265,  208,
- /*  1100 */    19,  306,   95,  308,   43,   44,   45,  266,   47,   48,
- /*  1110 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
- /*  1120 */   153,  230,   96,  232,   43,   44,   45,   19,   47,   48,
- /*  1130 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
- /*  1140 */   114,   22,  306,   24,  308,  127,  120,  121,  122,  123,
- /*  1150 */   124,  125,  126,  195,  147,  212,  213,  214,  132,   23,
- /*  1160 */   195,   25,  102,  100,  103,  104,  105,  106,  107,  108,
- /*  1170 */   109,  110,  111,  112,  113,  114,  218,  219,   19,   60,
- /*  1180 */   195,   12,  210,  211,  103,  104,  105,  106,  107,  108,
- /*  1190 */   109,  110,  111,  112,  113,  114,   27,  134,  195,  195,
- /*  1200 */   195,  210,  211,  218,  219,  195,   47,  195,  212,  213,
- /*  1210 */   214,   42,   16,  130,   19,  112,  113,  114,   23,   77,
- /*  1220 */   195,  218,  219,  218,  219,  117,  163,  164,  218,  219,
- /*  1230 */   218,  219,   90,   64,   19,   93,  153,  118,   43,   44,
- /*  1240 */    45,  160,   47,   48,   49,   50,   51,   52,   53,   54,
- /*  1250 */    55,   56,   57,   58,  195,  119,  272,  276,   43,   44,
- /*  1260 */    45,  195,   47,   48,   49,   50,   51,   52,   53,   54,
- /*  1270 */    55,   56,   57,   58,   78,  116,   80,  218,  219,  116,
- /*  1280 */   144,  128,  129,  130,  218,  219,   61,  195,   47,  195,
- /*  1290 */    16,  132,  195,  263,  195,  314,  315,  267,  103,  104,
- /*  1300 */   105,  106,  107,  108,  109,  110,  111,  112,  113,  114,
- /*  1310 */   218,  219,  218,  219,  151,  218,  219,  195,  103,  104,
- /*  1320 */   105,  106,  107,  108,  109,  110,  111,  112,  113,  114,
- /*  1330 */   210,  211,  195,    7,    8,    9,  195,   60,  195,  312,
- /*  1340 */   218,  219,  195,  316,  195,  120,  195,  263,   19,  195,
- /*  1350 */   125,  267,   78,   24,   80,  218,  219,  116,  162,  218,
- /*  1360 */   219,  218,  219,  301,  302,  218,  219,  195,   19,  218,
- /*  1370 */   219,  276,   43,   44,   45,  160,   47,   48,   49,   50,
- /*  1380 */    51,   52,   53,   54,   55,   56,   57,   58,   19,  146,
- /*  1390 */   218,  219,   43,   44,   45,  118,   47,   48,   49,   50,
- /*  1400 */    51,   52,   53,   54,   55,   56,   57,   58,  165,  314,
- /*  1410 */   315,  276,   43,   44,   45,  266,   47,   48,   49,   50,
- /*  1420 */    51,   52,   53,   54,   55,   56,   57,   58,  128,  129,
- /*  1430 */   130,  195,  103,  104,  105,  106,  107,  108,  109,  110,
- /*  1440 */   111,  112,  113,  114,  195,  228,  195,   61,  195,  314,
- /*  1450 */   315,   25,  103,  104,  105,  106,  107,  108,  109,  110,
- /*  1460 */   111,  112,  113,  114,  195,   22,  195,  218,  219,  218,
- /*  1470 */   219,  195,  103,  104,  105,  106,  107,  108,  109,  110,
- /*  1480 */   111,  112,  113,  114,  195,  195,  246,  218,  219,  218,
- /*  1490 */   219,   25,   19,  246,  218,  219,  246,  257,  259,  260,
- /*  1500 */   195,   22,  266,   60,  257,  195,  120,  257,  218,  219,
- /*  1510 */   116,  195,   19,  195,  150,  151,   25,   44,   45,  266,
- /*  1520 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*  1530 */    57,   58,  195,   54,  218,  219,  218,  219,   45,  145,
- /*  1540 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*  1550 */    57,   58,  246,  121,  122,  218,  219,   19,   23,   31,
- /*  1560 */    25,  118,  159,  257,  161,   24,  195,   39,  195,  143,
- /*  1570 */   195,   19,   20,   22,   22,   24,  103,  104,  105,  106,
- /*  1580 */   107,  108,  109,  110,  111,  112,  113,  114,   36,  218,
- /*  1590 */   219,  218,  219,  218,  219,  195,  103,  104,  105,  106,
- /*  1600 */   107,  108,  109,  110,  111,  112,  113,  114,  195,  143,
- /*  1610 */   119,  136,   60,  195,   22,  195,  141,  195,  218,  219,
- /*  1620 */   195,   23,  195,   25,   72,   23,  131,   25,  195,  134,
- /*  1630 */    23,  218,  219,  195,   82,  144,  218,  219,  218,  219,
- /*  1640 */   218,  219,  195,  218,  219,  218,  219,   60,   23,  195,
- /*  1650 */    25,  218,  219,  101,  195,  117,  218,  219,  195,  107,
- /*  1660 */   108,   23,  195,   25,  195,  218,  219,  115,  228,  117,
- /*  1670 */   118,  119,  218,  219,  122,  195,   19,  218,  219,  195,
- /*  1680 */    60,  218,  219,  142,  195,  218,  219,   19,   20,  195,
- /*  1690 */    22,  139,  140,   23,   23,   25,   25,  195,  218,  219,
- /*  1700 */     7,    8,  218,  219,   36,  118,  154,  155,  156,  157,
- /*  1710 */   158,  195,   23,  195,   25,   84,   85,   49,  195,   23,
- /*  1720 */   195,   25,  195,   23,  195,   25,  195,   23,   60,   25,
- /*  1730 */    23,   23,   25,   25,  142,  183,  218,  219,  118,  195,
- /*  1740 */    72,  218,  219,  218,  219,  218,  219,  218,  219,  218,
- /*  1750 */   219,  195,  195,  146,   86,   98,   23,  195,   25,   91,
- /*  1760 */    19,   20,  154,   22,  156,  154,   23,  156,   25,  101,
- /*  1770 */    23,  195,   25,  195,  195,  107,  108,   36,  195,  195,
- /*  1780 */   195,  195,  228,  115,  195,  117,  118,  119,  195,  195,
- /*  1790 */   122,  261,  195,  321,  195,  195,  195,  258,  238,  195,
- /*  1800 */   195,   60,  299,  291,  195,  195,  258,  195,  195,  195,
- /*  1810 */   290,  244,  216,   72,  245,  193,  258,  258,  299,  258,
- /*  1820 */   299,  274,  154,  155,  156,  157,  158,   86,  247,  295,
- /*  1830 */   248,  295,   91,   19,   20,  270,   22,  274,  270,  248,
- /*  1840 */   274,  222,  101,  227,  274,  221,  231,  221,  107,  108,
- /*  1850 */    36,  183,  262,  247,  221,  283,  115,  262,  117,  118,
- /*  1860 */   119,  198,  116,  122,  220,  262,   61,  220,  220,  251,
- /*  1870 */   247,  142,  251,  245,   60,  202,  299,  202,   38,  262,
- /*  1880 */   202,   22,  152,  151,  296,   43,   72,  236,   18,  239,
- /*  1890 */   202,  239,  239,  239,   18,  154,  155,  156,  157,  158,
- /*  1900 */    86,  150,  201,  248,  275,   91,  248,  273,  236,  248,
- /*  1910 */   275,  275,  273,  236,  248,  101,  286,  202,  201,  159,
- /*  1920 */    63,  107,  108,  296,  183,  293,  202,  201,   22,  115,
- /*  1930 */   202,  117,  118,  119,  292,  223,  122,  201,   65,  202,
- /*  1940 */   201,  223,  220,  220,   22,  220,  226,  226,  229,  127,
- /*  1950 */   223,  220,  166,   24,  285,  220,  222,  114,  315,  285,
- /*  1960 */   220,  202,  220,  307,   92,  320,  320,  229,  154,  155,
- /*  1970 */   156,  157,  158,    0,    1,    2,  223,   83,    5,  268,
- /*  1980 */   149,  268,  146,   10,   11,   12,   13,   14,   22,  280,
- /*  1990 */    17,  202,  159,   19,   20,  251,   22,  183,  282,  148,
- /*  2000 */   252,  252,  250,   30,  249,   32,  248,  147,   25,   13,
- /*  2010 */    36,  204,  196,   40,  196,    6,  302,  194,  194,  194,
- /*  2020 */   209,  215,  209,  215,  215,  215,  224,  224,  216,  209,
- /*  2030 */     4,  216,  215,    3,   60,   22,  122,   19,  122,   19,
- /*  2040 */   125,   22,   15,   22,   71,   16,   72,   23,   23,  140,
- /*  2050 */   305,  152,   79,   25,  131,   82,  143,   20,   16,  305,
- /*  2060 */     1,  143,  145,  131,  131,   62,   54,  131,   37,   54,
- /*  2070 */    54,  152,   99,  117,   34,  101,   54,   24,    1,    5,
- /*  2080 */    22,  107,  108,  116,   76,   25,  162,   41,  142,  115,
- /*  2090 */    24,  117,  118,  119,  116,   20,  122,   19,  126,   23,
- /*  2100 */   132,   19,   20,   69,   22,   69,   22,  134,   22,   68,
- /*  2110 */    22,   22,  139,  140,   60,  141,   68,   24,   36,   28,
- /*  2120 */    97,   22,   37,   68,   23,  150,   34,   22,  154,  155,
- /*  2130 */   156,  157,  158,   23,   23,   22,  163,   25,   23,  142,
- /*  2140 */    23,   98,   60,   23,   22,  144,   25,   76,   34,  117,
- /*  2150 */    34,   89,   34,   34,   72,   87,   76,  183,   34,   94,
- /*  2160 */    34,   23,   22,   24,   34,   23,   25,   44,   25,   23,
- /*  2170 */    23,   23,   22,   22,   25,   11,  143,   25,  143,   23,
- /*  2180 */    22,   22,   22,  101,   23,   23,  136,   22,   25,  107,
- /*  2190 */   108,  142,   25,  142,  142,   23,   15,  115,    1,  117,
- /*  2200 */   118,  119,    1,    2,  122,    1,    5,  322,  322,  322,
- /*  2210 */   322,   10,   11,   12,   13,   14,  322,  322,   17,  322,
- /*  2220 */     5,  322,  322,  141,  322,   10,   11,   12,   13,   14,
- /*  2230 */   322,   30,   17,   32,  322,  322,  154,  155,  156,  157,
- /*  2240 */   158,   40,  322,  322,  322,   30,  322,   32,  322,  322,
- /*  2250 */   322,  322,  322,  322,  322,   40,  322,  322,  322,  322,
- /*  2260 */   322,  322,  322,  322,  322,  183,  322,  322,  322,  322,
- /*  2270 */   322,  322,   71,  322,  322,  322,  322,  322,  322,  322,
- /*  2280 */    79,  322,  322,   82,  322,  322,   71,  322,  322,  322,
- /*  2290 */   322,  322,  322,  322,   79,  322,  322,   82,  322,  322,
- /*  2300 */    99,  322,  322,  322,  322,  322,  322,  322,  322,  322,
- /*  2310 */   322,  322,  322,  322,   99,  322,  322,  322,  322,  322,
- /*  2320 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
- /*  2330 */   322,  322,  322,  322,  322,  134,  322,  322,  322,  322,
- /*  2340 */   139,  140,  322,  322,  322,  322,  322,  322,  322,  134,
- /*  2350 */   322,  322,  322,  322,  139,  140,  322,  322,  322,  322,
- /*  2360 */   322,  322,  322,  322,  163,  322,  322,  322,  322,  322,
- /*  2370 */   322,  322,  322,  322,  322,  322,  322,  322,  163,  322,
- /*  2380 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
- /*  2390 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
- /*  2400 */   322,  322,  322,  322,  322,  322,  322,  322,  187,  187,
- /*  2410 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2420 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2430 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2440 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2450 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2460 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2470 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2480 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2490 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2500 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2510 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2520 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2530 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2540 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2550 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
- /*  2560 */   187,  187,  187,  187,  187,  187,
-};
-#define YY_SHIFT_COUNT    (599)
-#define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (2215)
-static const unsigned short int yy_shift_ofst[] = {
- /*     0 */  2201, 1973, 2215, 1552, 1552,   33,  368, 1668, 1741, 1814,
- /*    10 */   726,  726,  726,  265,   33,   33,   33,   33,   33,    0,
- /*    20 */     0,  216, 1349,  726,  726,  726,  726,  726,  726,  726,
- /*    30 */   726,  726,  726,  726,  726,  726,  726,  726,  272,  272,
- /*    40 */   111,  111,  316,  365,  516,  867,  867,  916,  916,  916,
- /*    50 */   916,   40,  112,  260,  364,  408,  512,  617,  661,  765,
- /*    60 */   809,  913,  957, 1061, 1081, 1195, 1215, 1329, 1349, 1349,
- /*    70 */  1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349,
- /*    80 */  1349, 1349, 1349, 1349, 1349, 1349, 1369, 1349, 1473, 1493,
- /*    90 */  1493,  473, 1974, 2082,  726,  726,  726,  726,  726,  726,
- /*   100 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
- /*   110 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
- /*   120 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
- /*   130 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
- /*   140 */   726,  726,  726,  726,  726,  726,  138,  232,  232,  232,
- /*   150 */   232,  232,  232,  232,  188,   99,  242,  718,  416, 1159,
- /*   160 */   867,  867,  940,  940,  867, 1103,  417,  574,  574,  574,
- /*   170 */   611,  139,  139, 2379, 2379, 1026, 1026, 1026,  536,  466,
- /*   180 */   466,  466,  466, 1017, 1017,  849,  718,  971, 1060,  867,
- /*   190 */   867,  867,  867,  867,  867,  867,  867,  867,  867,  867,
- /*   200 */   867,  867,  867,  867,  867,  867,  867,  867,  261,  712,
- /*   210 */   712,  867,  108, 1142, 1142,  977, 1108, 1108,  977,  977,
- /*   220 */  1243, 2379, 2379, 2379, 2379, 2379, 2379, 2379,  641,  789,
- /*   230 */   789,  635,  366,  721,  673,  782,  494,  787,  829,  867,
- /*   240 */   867,  867,  867,  867,  867,  867,  867,  867,  867,  867,
- /*   250 */   959,  867,  867,  867,  867,  867,  867,  867,  867,  867,
- /*   260 */   867,  867,  867,  867,  867,  820,  820,  820,  867,  867,
- /*   270 */   867, 1136,  867,  867,  867, 1119, 1007,  867, 1169,  867,
- /*   280 */   867,  867,  867,  867,  867,  867,  867, 1225, 1153,  869,
- /*   290 */   196,  618,  618,  618,  618, 1491,  196,  196,   91,  339,
- /*   300 */  1326, 1386,  383, 1163, 1364, 1426, 1364, 1538,  903, 1163,
- /*   310 */  1163,  903, 1163, 1426, 1538, 1018, 1535, 1241, 1528, 1528,
- /*   320 */  1528, 1394, 1394, 1394, 1394,  762,  762, 1403, 1466, 1475,
- /*   330 */  1551, 1746, 1805, 1746, 1746, 1729, 1729, 1840, 1840, 1729,
- /*   340 */  1730, 1732, 1859, 1842, 1870, 1870, 1870, 1870, 1729, 1876,
- /*   350 */  1751, 1732, 1732, 1751, 1859, 1842, 1751, 1842, 1751, 1729,
- /*   360 */  1876, 1760, 1857, 1729, 1876, 1906, 1729, 1876, 1729, 1876,
- /*   370 */  1906, 1746, 1746, 1746, 1873, 1922, 1922, 1906, 1746, 1822,
- /*   380 */  1746, 1873, 1746, 1746, 1786, 1929, 1843, 1843, 1906, 1729,
- /*   390 */  1872, 1872, 1894, 1894, 1831, 1836, 1966, 1729, 1833, 1831,
- /*   400 */  1851, 1860, 1751, 1983, 1996, 1996, 2009, 2009, 2009, 2379,
- /*   410 */  2379, 2379, 2379, 2379, 2379, 2379, 2379, 2379, 2379, 2379,
- /*   420 */  2379, 2379, 2379, 2379,  136, 1063, 1196,  530,  636, 1274,
- /*   430 */  1300, 1443, 1598, 1495, 1479,  967, 1083, 1602,  463, 1625,
- /*   440 */  1638, 1670, 1541, 1671, 1689, 1696, 1277, 1432, 1693,  808,
- /*   450 */  1700, 1607, 1657, 1587, 1704, 1707, 1631, 1708, 1733, 1608,
- /*   460 */  1611, 1743, 1747, 1620, 1592, 2026, 2030, 2013, 1914, 2018,
- /*   470 */  1916, 2020, 2019, 2021, 1915, 2027, 2029, 2024, 2025, 1909,
- /*   480 */  1899, 1923, 2028, 2028, 1913, 2037, 1917, 2042, 2059, 1918,
- /*   490 */  1932, 2028, 1933, 2003, 2031, 2028, 1919, 2012, 2015, 2016,
- /*   500 */  2022, 1936, 1956, 2040, 2053, 2077, 2074, 2058, 1967, 1924,
- /*   510 */  2034, 2060, 2036, 2008, 2046, 1946, 1978, 2066, 2075, 2078,
- /*   520 */  1968, 1972, 2084, 2041, 2086, 2088, 2076, 2089, 2048, 2054,
- /*   530 */  2093, 2023, 2091, 2099, 2055, 2085, 2101, 2092, 1975, 2105,
- /*   540 */  2110, 2111, 2112, 2115, 2113, 2043, 1997, 2117, 2120, 2032,
- /*   550 */  2114, 2122, 2001, 2121, 2116, 2118, 2119, 2124, 2062, 2071,
- /*   560 */  2068, 2123, 2080, 2065, 2126, 2138, 2140, 2139, 2141, 2143,
- /*   570 */  2130, 2033, 2035, 2142, 2121, 2146, 2147, 2148, 2150, 2149,
- /*   580 */  2152, 2156, 2151, 2164, 2158, 2159, 2161, 2162, 2160, 2165,
- /*   590 */  2163, 2050, 2049, 2051, 2052, 2167, 2172, 2181, 2197, 2204,
-};
-#define YY_REDUCE_COUNT (423)
-#define YY_REDUCE_MIN   (-303)
-#define YY_REDUCE_MAX   (1825)
-static const short yy_reduce_ofst[] = {
- /*     0 */   -67,  345,  -64, -178, -181,  143,  435,  -78, -183,  163,
- /*    10 */  -185,  284,  384, -174,  189,  352,  440,  444,  493,  -23,
- /*    20 */   227, -277,   -1,  305,  561,  755,  759,  764, -189,  839,
- /*    30 */   857,  354,  484,  859,  631,   67,  734,  780, -187,  616,
- /*    40 */   581,  730,  891,  449,  588,  795,  836, -238,  287, -238,
- /*    50 */   287, -256, -256, -256, -256, -256, -256, -256, -256, -256,
- /*    60 */  -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
- /*    70 */  -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
- /*    80 */  -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
- /*    90 */  -256,  205,  582,  715,  958,  985, 1003, 1005, 1010, 1012,
- /*   100 */  1059, 1066, 1092, 1094, 1097, 1122, 1137, 1141, 1143, 1147,
- /*   110 */  1151, 1172, 1249, 1251, 1269, 1271, 1276, 1290, 1316, 1318,
- /*   120 */  1337, 1371, 1373, 1375, 1400, 1413, 1418, 1420, 1422, 1425,
- /*   130 */  1427, 1433, 1438, 1447, 1454, 1459, 1463, 1467, 1480, 1484,
- /*   140 */  1518, 1523, 1525, 1527, 1529, 1531, -256, -256, -256, -256,
- /*   150 */  -256, -256, -256, -256, -256, -256, -256,  155,  210, -220,
- /*   160 */    86, -130,  943,  996,  402, -256, -113,  981, 1095, 1135,
- /*   170 */   395, -256, -256, -256, -256,  568,  568,  568,   -4, -153,
- /*   180 */  -133,  259,  306, -166,  523, -303, -126,  503,  503,  -37,
- /*   190 */  -149,  164,  690,  292,  412,  492,  651,  784,  332,  786,
- /*   200 */   841, 1149,  833, 1236,  792,  162,  796, 1253,  777,  288,
- /*   210 */   381,  380,  709,  487, 1027,  972, 1030, 1084,  991, 1120,
- /*   220 */  -152, 1062,  692, 1240, 1247, 1250, 1239, 1306, -207, -194,
- /*   230 */    57,  180,   74,  315,  355,  376,  452,  488,  630,  693,
- /*   240 */   965, 1004, 1025, 1099, 1154, 1289, 1305, 1310, 1469, 1489,
- /*   250 */   984, 1494, 1502, 1516, 1544, 1556, 1557, 1562, 1576, 1578,
- /*   260 */  1579, 1583, 1584, 1585, 1586, 1217, 1440, 1554, 1589, 1593,
- /*   270 */  1594, 1530, 1597, 1599, 1600, 1539, 1472, 1601, 1560, 1604,
- /*   280 */   355, 1605, 1609, 1610, 1612, 1613, 1614, 1503, 1512, 1520,
- /*   290 */  1567, 1548, 1558, 1559, 1561, 1530, 1567, 1567, 1569, 1596,
- /*   300 */  1622, 1519, 1521, 1547, 1565, 1581, 1568, 1534, 1582, 1563,
- /*   310 */  1566, 1591, 1570, 1606, 1536, 1619, 1615, 1616, 1624, 1626,
- /*   320 */  1633, 1590, 1595, 1603, 1617, 1618, 1621, 1572, 1623, 1628,
- /*   330 */  1663, 1644, 1577, 1647, 1648, 1673, 1675, 1588, 1627, 1678,
- /*   340 */  1630, 1629, 1634, 1651, 1650, 1652, 1653, 1654, 1688, 1701,
- /*   350 */  1655, 1635, 1636, 1658, 1639, 1672, 1661, 1677, 1666, 1715,
- /*   360 */  1717, 1632, 1642, 1724, 1726, 1712, 1728, 1736, 1737, 1739,
- /*   370 */  1718, 1722, 1723, 1725, 1719, 1720, 1721, 1727, 1731, 1734,
- /*   380 */  1735, 1738, 1740, 1742, 1643, 1656, 1669, 1674, 1753, 1759,
- /*   390 */  1645, 1646, 1711, 1713, 1748, 1744, 1709, 1789, 1716, 1749,
- /*   400 */  1752, 1755, 1758, 1807, 1816, 1818, 1823, 1824, 1825, 1745,
- /*   410 */  1754, 1714, 1811, 1806, 1808, 1809, 1810, 1813, 1802, 1803,
- /*   420 */  1812, 1815, 1817, 1820,
-};
-static const YYACTIONTYPE yy_default[] = {
- /*     0 */  1691, 1691, 1691, 1516, 1279, 1392, 1279, 1279, 1279, 1279,
- /*    10 */  1516, 1516, 1516, 1279, 1279, 1279, 1279, 1279, 1279, 1422,
- /*    20 */  1422, 1568, 1312, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*    30 */  1279, 1279, 1279, 1279, 1279, 1515, 1279, 1279, 1279, 1279,
- /*    40 */  1607, 1607, 1279, 1279, 1279, 1279, 1279, 1592, 1591, 1279,
- /*    50 */  1279, 1279, 1431, 1279, 1279, 1279, 1438, 1279, 1279, 1279,
- /*    60 */  1279, 1279, 1517, 1518, 1279, 1279, 1279, 1279, 1567, 1569,
- /*    70 */  1533, 1445, 1444, 1443, 1442, 1551, 1410, 1436, 1429, 1433,
- /*    80 */  1512, 1513, 1511, 1670, 1518, 1517, 1279, 1432, 1480, 1496,
- /*    90 */  1479, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   100 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   110 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   120 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   130 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   140 */  1279, 1279, 1279, 1279, 1279, 1279, 1488, 1495, 1494, 1493,
- /*   150 */  1502, 1492, 1489, 1482, 1481, 1483, 1484, 1303, 1300, 1354,
- /*   160 */  1279, 1279, 1279, 1279, 1279, 1485, 1312, 1473, 1472, 1471,
- /*   170 */  1279, 1499, 1486, 1498, 1497, 1575, 1644, 1643, 1534, 1279,
- /*   180 */  1279, 1279, 1279, 1279, 1279, 1607, 1279, 1279, 1279, 1279,
- /*   190 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   200 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1412, 1607,
- /*   210 */  1607, 1279, 1312, 1607, 1607, 1308, 1413, 1413, 1308, 1308,
- /*   220 */  1416, 1587, 1383, 1383, 1383, 1383, 1392, 1383, 1279, 1279,
- /*   230 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   240 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1572, 1570, 1279,
- /*   250 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   260 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   270 */  1279, 1279, 1279, 1279, 1279, 1388, 1279, 1279, 1279, 1279,
- /*   280 */  1279, 1279, 1279, 1279, 1279, 1279, 1637, 1683, 1279, 1546,
- /*   290 */  1368, 1388, 1388, 1388, 1388, 1390, 1369, 1367, 1382, 1313,
- /*   300 */  1286, 1683, 1683, 1448, 1437, 1389, 1437, 1680, 1435, 1448,
- /*   310 */  1448, 1435, 1448, 1389, 1680, 1329, 1659, 1324, 1422, 1422,
- /*   320 */  1422, 1412, 1412, 1412, 1412, 1416, 1416, 1514, 1389, 1382,
- /*   330 */  1279, 1355, 1683, 1355, 1355, 1398, 1398, 1682, 1682, 1398,
- /*   340 */  1534, 1667, 1457, 1357, 1363, 1363, 1363, 1363, 1398, 1297,
- /*   350 */  1435, 1667, 1667, 1435, 1457, 1357, 1435, 1357, 1435, 1398,
- /*   360 */  1297, 1550, 1678, 1398, 1297, 1524, 1398, 1297, 1398, 1297,
- /*   370 */  1524, 1355, 1355, 1355, 1344, 1279, 1279, 1524, 1355, 1329,
- /*   380 */  1355, 1344, 1355, 1355, 1625, 1279, 1528, 1528, 1524, 1398,
- /*   390 */  1617, 1617, 1425, 1425, 1430, 1416, 1519, 1398, 1279, 1430,
- /*   400 */  1428, 1426, 1435, 1347, 1640, 1640, 1636, 1636, 1636, 1688,
- /*   410 */  1688, 1587, 1652, 1312, 1312, 1312, 1312, 1652, 1331, 1331,
- /*   420 */  1313, 1313, 1312, 1652, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   430 */  1279, 1647, 1279, 1279, 1535, 1279, 1279, 1279, 1279, 1279,
- /*   440 */  1279, 1279, 1402, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   450 */  1279, 1279, 1593, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   460 */  1279, 1279, 1279, 1279, 1462, 1279, 1282, 1584, 1279, 1279,
- /*   470 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   480 */  1279, 1279, 1439, 1440, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   490 */  1279, 1454, 1279, 1279, 1279, 1449, 1279, 1279, 1279, 1279,
- /*   500 */  1279, 1279, 1279, 1279, 1403, 1279, 1279, 1279, 1279, 1279,
- /*   510 */  1279, 1549, 1548, 1279, 1279, 1400, 1279, 1279, 1279, 1279,
- /*   520 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1327,
- /*   530 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   540 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   550 */  1279, 1279, 1279, 1427, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   560 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1622, 1417,
- /*   570 */  1279, 1279, 1279, 1279, 1671, 1279, 1279, 1279, 1279, 1377,
- /*   580 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
- /*   590 */  1663, 1371, 1463, 1279, 1466, 1301, 1279, 1291, 1279, 1279,
-};
-/********** 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 */
-   60,  /*    EXPLAIN => ID */
-   60,  /*      QUERY => ID */
-   60,  /*       PLAN => ID */
-   60,  /*      BEGIN => ID */
-    0,  /* TRANSACTION => nothing */
-   60,  /*   DEFERRED => ID */
-   60,  /*  IMMEDIATE => ID */
-   60,  /*  EXCLUSIVE => ID */
-    0,  /*     COMMIT => nothing */
-   60,  /*        END => ID */
-   60,  /*   ROLLBACK => ID */
-   60,  /*  SAVEPOINT => ID */
-   60,  /*    RELEASE => ID */
-    0,  /*         TO => nothing */
-    0,  /*      TABLE => nothing */
-    0,  /*     CREATE => nothing */
-   60,  /*         IF => ID */
-    0,  /*        NOT => nothing */
-    0,  /*     EXISTS => nothing */
-   60,  /*       TEMP => ID */
-    0,  /*         LP => nothing */
-    0,  /*         RP => nothing */
-    0,  /*         AS => nothing */
-    0,  /*      COMMA => nothing */
-   60,  /*    WITHOUT => ID */
-   60,  /*      ABORT => ID */
-   60,  /*     ACTION => ID */
-   60,  /*      AFTER => ID */
-   60,  /*    ANALYZE => ID */
-   60,  /*        ASC => ID */
-   60,  /*     ATTACH => ID */
-   60,  /*     BEFORE => ID */
-   60,  /*         BY => ID */
-   60,  /*    CASCADE => ID */
-   60,  /*       CAST => ID */
-   60,  /*   CONFLICT => ID */
-   60,  /*   DATABASE => ID */
-   60,  /*       DESC => ID */
-   60,  /*     DETACH => ID */
-   60,  /*       EACH => ID */
-   60,  /*       FAIL => ID */
-    0,  /*         OR => nothing */
-    0,  /*        AND => nothing */
-    0,  /*         IS => nothing */
-    0,  /*      ISNOT => nothing */
-   60,  /*      MATCH => ID */
-   60,  /*    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 */
-   60,  /*   COLUMNKW => ID */
-   60,  /*         DO => ID */
-   60,  /*        FOR => ID */
-   60,  /*     IGNORE => ID */
-   60,  /*  INITIALLY => ID */
-   60,  /*    INSTEAD => ID */
-   60,  /*         NO => ID */
-   60,  /*        KEY => ID */
-   60,  /*         OF => ID */
-   60,  /*     OFFSET => ID */
-   60,  /*     PRAGMA => ID */
-   60,  /*      RAISE => ID */
-   60,  /*  RECURSIVE => ID */
-   60,  /*    REPLACE => ID */
-   60,  /*   RESTRICT => ID */
-   60,  /*        ROW => ID */
-   60,  /*       ROWS => ID */
-   60,  /*    TRIGGER => ID */
-   60,  /*     VACUUM => ID */
-   60,  /*       VIEW => ID */
-   60,  /*    VIRTUAL => ID */
-   60,  /*       WITH => ID */
-   60,  /*      NULLS => ID */
-   60,  /*      FIRST => ID */
-   60,  /*       LAST => ID */
-   60,  /*    CURRENT => ID */
-   60,  /*  FOLLOWING => ID */
-   60,  /*  PARTITION => ID */
-   60,  /*  PRECEDING => ID */
-   60,  /*      RANGE => ID */
-   60,  /*  UNBOUNDED => ID */
-   60,  /*    EXCLUDE => ID */
-   60,  /*     GROUPS => ID */
-   60,  /*     OTHERS => ID */
-   60,  /*       TIES => ID */
-   60,  /*  GENERATED => ID */
-   60,  /*     ALWAYS => ID */
-   60,  /* MATERIALIZED => ID */
-   60,  /*    REINDEX => ID */
-   60,  /*     RENAME => ID */
-   60,  /*   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,  /*   FUNCTION => nothing */
-    0,  /*      UPLUS => nothing */
-    0,  /*     UMINUS => 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,  /*    QNUMBER => nothing */
-    0,  /*      SPACE => nothing */
-    0,  /*    COMMENT => 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 */
-  yyStackEntry *yystackEnd;           /* Last entry in the stack */
-  yyStackEntry *yystack;              /* The parser stack */
-  yyStackEntry yystk0[YYSTACKDEPTH];  /* Initial stack space */
-};
-typedef struct yyParser yyParser;
-
-/* #include <assert.h> */
-#ifndef NDEBUG
-/* #include <stdio.h> */
-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:
-** <ul>
-** <li> A FILE* to which trace output should be written.
-**      If NULL, then tracing is turned off.
-** <li> A prefix string written at the beginning of every
-**      line of trace output.  If NULL, then tracing is
-**      turned off.
-** </ul>
-**
-** 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 */ "ISNOT",
-  /*   47 */ "MATCH",
-  /*   48 */ "LIKE_KW",
-  /*   49 */ "BETWEEN",
-  /*   50 */ "IN",
-  /*   51 */ "ISNULL",
-  /*   52 */ "NOTNULL",
-  /*   53 */ "NE",
-  /*   54 */ "EQ",
-  /*   55 */ "GT",
-  /*   56 */ "LE",
-  /*   57 */ "LT",
-  /*   58 */ "GE",
-  /*   59 */ "ESCAPE",
-  /*   60 */ "ID",
-  /*   61 */ "COLUMNKW",
-  /*   62 */ "DO",
-  /*   63 */ "FOR",
-  /*   64 */ "IGNORE",
-  /*   65 */ "INITIALLY",
-  /*   66 */ "INSTEAD",
-  /*   67 */ "NO",
-  /*   68 */ "KEY",
-  /*   69 */ "OF",
-  /*   70 */ "OFFSET",
-  /*   71 */ "PRAGMA",
-  /*   72 */ "RAISE",
-  /*   73 */ "RECURSIVE",
-  /*   74 */ "REPLACE",
-  /*   75 */ "RESTRICT",
-  /*   76 */ "ROW",
-  /*   77 */ "ROWS",
-  /*   78 */ "TRIGGER",
-  /*   79 */ "VACUUM",
-  /*   80 */ "VIEW",
-  /*   81 */ "VIRTUAL",
-  /*   82 */ "WITH",
-  /*   83 */ "NULLS",
-  /*   84 */ "FIRST",
-  /*   85 */ "LAST",
-  /*   86 */ "CURRENT",
-  /*   87 */ "FOLLOWING",
-  /*   88 */ "PARTITION",
-  /*   89 */ "PRECEDING",
-  /*   90 */ "RANGE",
-  /*   91 */ "UNBOUNDED",
-  /*   92 */ "EXCLUDE",
-  /*   93 */ "GROUPS",
-  /*   94 */ "OTHERS",
-  /*   95 */ "TIES",
-  /*   96 */ "GENERATED",
-  /*   97 */ "ALWAYS",
-  /*   98 */ "MATERIALIZED",
-  /*   99 */ "REINDEX",
-  /*  100 */ "RENAME",
-  /*  101 */ "CTIME_KW",
-  /*  102 */ "ANY",
-  /*  103 */ "BITAND",
-  /*  104 */ "BITOR",
-  /*  105 */ "LSHIFT",
-  /*  106 */ "RSHIFT",
-  /*  107 */ "PLUS",
-  /*  108 */ "MINUS",
-  /*  109 */ "STAR",
-  /*  110 */ "SLASH",
-  /*  111 */ "REM",
-  /*  112 */ "CONCAT",
-  /*  113 */ "PTR",
-  /*  114 */ "COLLATE",
-  /*  115 */ "BITNOT",
-  /*  116 */ "ON",
-  /*  117 */ "INDEXED",
-  /*  118 */ "STRING",
-  /*  119 */ "JOIN_KW",
-  /*  120 */ "CONSTRAINT",
-  /*  121 */ "DEFAULT",
-  /*  122 */ "NULL",
-  /*  123 */ "PRIMARY",
-  /*  124 */ "UNIQUE",
-  /*  125 */ "CHECK",
-  /*  126 */ "REFERENCES",
-  /*  127 */ "AUTOINCR",
-  /*  128 */ "INSERT",
-  /*  129 */ "DELETE",
-  /*  130 */ "UPDATE",
-  /*  131 */ "SET",
-  /*  132 */ "DEFERRABLE",
-  /*  133 */ "FOREIGN",
-  /*  134 */ "DROP",
-  /*  135 */ "UNION",
-  /*  136 */ "ALL",
-  /*  137 */ "EXCEPT",
-  /*  138 */ "INTERSECT",
-  /*  139 */ "SELECT",
-  /*  140 */ "VALUES",
-  /*  141 */ "DISTINCT",
-  /*  142 */ "DOT",
-  /*  143 */ "FROM",
-  /*  144 */ "JOIN",
-  /*  145 */ "USING",
-  /*  146 */ "ORDER",
-  /*  147 */ "GROUP",
-  /*  148 */ "HAVING",
-  /*  149 */ "LIMIT",
-  /*  150 */ "WHERE",
-  /*  151 */ "RETURNING",
-  /*  152 */ "INTO",
-  /*  153 */ "NOTHING",
-  /*  154 */ "FLOAT",
-  /*  155 */ "BLOB",
-  /*  156 */ "INTEGER",
-  /*  157 */ "VARIABLE",
-  /*  158 */ "CASE",
-  /*  159 */ "WHEN",
-  /*  160 */ "THEN",
-  /*  161 */ "ELSE",
-  /*  162 */ "INDEX",
-  /*  163 */ "ALTER",
-  /*  164 */ "ADD",
-  /*  165 */ "WINDOW",
-  /*  166 */ "OVER",
-  /*  167 */ "FILTER",
-  /*  168 */ "COLUMN",
-  /*  169 */ "AGG_FUNCTION",
-  /*  170 */ "AGG_COLUMN",
-  /*  171 */ "TRUEFALSE",
-  /*  172 */ "FUNCTION",
-  /*  173 */ "UPLUS",
-  /*  174 */ "UMINUS",
-  /*  175 */ "TRUTH",
-  /*  176 */ "REGISTER",
-  /*  177 */ "VECTOR",
-  /*  178 */ "SELECT_COLUMN",
-  /*  179 */ "IF_NULL_ROW",
-  /*  180 */ "ASTERISK",
-  /*  181 */ "SPAN",
-  /*  182 */ "ERROR",
-  /*  183 */ "QNUMBER",
-  /*  184 */ "SPACE",
-  /*  185 */ "COMMENT",
-  /*  186 */ "ILLEGAL",
-  /*  187 */ "input",
-  /*  188 */ "cmdlist",
-  /*  189 */ "ecmd",
-  /*  190 */ "cmdx",
-  /*  191 */ "explain",
-  /*  192 */ "cmd",
-  /*  193 */ "transtype",
-  /*  194 */ "trans_opt",
-  /*  195 */ "nm",
-  /*  196 */ "savepoint_opt",
-  /*  197 */ "create_table",
-  /*  198 */ "create_table_args",
-  /*  199 */ "createkw",
-  /*  200 */ "temp",
-  /*  201 */ "ifnotexists",
-  /*  202 */ "dbnm",
-  /*  203 */ "columnlist",
-  /*  204 */ "conslist_opt",
-  /*  205 */ "table_option_set",
-  /*  206 */ "select",
-  /*  207 */ "table_option",
-  /*  208 */ "columnname",
-  /*  209 */ "carglist",
-  /*  210 */ "typetoken",
-  /*  211 */ "typename",
-  /*  212 */ "signed",
-  /*  213 */ "plus_num",
-  /*  214 */ "minus_num",
-  /*  215 */ "scanpt",
-  /*  216 */ "scantok",
-  /*  217 */ "ccons",
-  /*  218 */ "term",
-  /*  219 */ "expr",
-  /*  220 */ "onconf",
-  /*  221 */ "sortorder",
-  /*  222 */ "autoinc",
-  /*  223 */ "eidlist_opt",
-  /*  224 */ "refargs",
-  /*  225 */ "defer_subclause",
-  /*  226 */ "generated",
-  /*  227 */ "refarg",
-  /*  228 */ "refact",
-  /*  229 */ "init_deferred_pred_opt",
-  /*  230 */ "conslist",
-  /*  231 */ "tconscomma",
-  /*  232 */ "tcons",
-  /*  233 */ "sortlist",
-  /*  234 */ "eidlist",
-  /*  235 */ "defer_subclause_opt",
-  /*  236 */ "orconf",
-  /*  237 */ "resolvetype",
-  /*  238 */ "raisetype",
-  /*  239 */ "ifexists",
-  /*  240 */ "fullname",
-  /*  241 */ "selectnowith",
-  /*  242 */ "oneselect",
-  /*  243 */ "wqlist",
-  /*  244 */ "multiselect_op",
-  /*  245 */ "distinct",
-  /*  246 */ "selcollist",
-  /*  247 */ "from",
-  /*  248 */ "where_opt",
-  /*  249 */ "groupby_opt",
-  /*  250 */ "having_opt",
-  /*  251 */ "orderby_opt",
-  /*  252 */ "limit_opt",
-  /*  253 */ "window_clause",
-  /*  254 */ "values",
-  /*  255 */ "nexprlist",
-  /*  256 */ "mvalues",
-  /*  257 */ "sclp",
-  /*  258 */ "as",
-  /*  259 */ "seltablist",
-  /*  260 */ "stl_prefix",
-  /*  261 */ "joinop",
-  /*  262 */ "on_using",
-  /*  263 */ "indexed_by",
-  /*  264 */ "exprlist",
-  /*  265 */ "xfullname",
-  /*  266 */ "idlist",
-  /*  267 */ "indexed_opt",
-  /*  268 */ "nulls",
-  /*  269 */ "with",
-  /*  270 */ "where_opt_ret",
-  /*  271 */ "setlist",
-  /*  272 */ "insert_cmd",
-  /*  273 */ "idlist_opt",
-  /*  274 */ "upsert",
-  /*  275 */ "returning",
-  /*  276 */ "filter_over",
-  /*  277 */ "likeop",
-  /*  278 */ "between_op",
-  /*  279 */ "in_op",
-  /*  280 */ "paren_exprlist",
-  /*  281 */ "case_operand",
-  /*  282 */ "case_exprlist",
-  /*  283 */ "case_else",
-  /*  284 */ "uniqueflag",
-  /*  285 */ "collate",
-  /*  286 */ "vinto",
-  /*  287 */ "nmnum",
-  /*  288 */ "trigger_decl",
-  /*  289 */ "trigger_cmd_list",
-  /*  290 */ "trigger_time",
-  /*  291 */ "trigger_event",
-  /*  292 */ "foreach_clause",
-  /*  293 */ "when_clause",
-  /*  294 */ "trigger_cmd",
-  /*  295 */ "tridxby",
-  /*  296 */ "database_kw_opt",
-  /*  297 */ "key_opt",
-  /*  298 */ "alter_add",
-  /*  299 */ "kwcolumn_opt",
-  /*  300 */ "create_vtab",
-  /*  301 */ "vtabarglist",
-  /*  302 */ "vtabarg",
-  /*  303 */ "vtabargtoken",
-  /*  304 */ "lp",
-  /*  305 */ "anylist",
-  /*  306 */ "wqitem",
-  /*  307 */ "wqas",
-  /*  308 */ "withnm",
-  /*  309 */ "windowdefn_list",
-  /*  310 */ "windowdefn",
-  /*  311 */ "window",
-  /*  312 */ "frame_opt",
-  /*  313 */ "part_opt",
-  /*  314 */ "filter_clause",
-  /*  315 */ "over_clause",
-  /*  316 */ "range_or_rows",
-  /*  317 */ "frame_bound",
-  /*  318 */ "frame_bound_s",
-  /*  319 */ "frame_bound_e",
-  /*  320 */ "frame_exclude_opt",
-  /*  321 */ "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 */ "oneselect ::= mvalues",
- /*  96 */ "mvalues ::= values COMMA LP nexprlist RP",
- /*  97 */ "mvalues ::= mvalues COMMA LP nexprlist RP",
- /*  98 */ "distinct ::= DISTINCT",
- /*  99 */ "distinct ::= ALL",
- /* 100 */ "distinct ::=",
- /* 101 */ "sclp ::=",
- /* 102 */ "selcollist ::= sclp scanpt expr scanpt as",
- /* 103 */ "selcollist ::= sclp scanpt STAR",
- /* 104 */ "selcollist ::= sclp scanpt nm DOT STAR",
- /* 105 */ "as ::= AS nm",
- /* 106 */ "as ::=",
- /* 107 */ "from ::=",
- /* 108 */ "from ::= FROM seltablist",
- /* 109 */ "stl_prefix ::= seltablist joinop",
- /* 110 */ "stl_prefix ::=",
- /* 111 */ "seltablist ::= stl_prefix nm dbnm as on_using",
- /* 112 */ "seltablist ::= stl_prefix nm dbnm as indexed_by on_using",
- /* 113 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using",
- /* 114 */ "seltablist ::= stl_prefix LP select RP as on_using",
- /* 115 */ "seltablist ::= stl_prefix LP seltablist RP as on_using",
- /* 116 */ "dbnm ::=",
- /* 117 */ "dbnm ::= DOT nm",
- /* 118 */ "fullname ::= nm",
- /* 119 */ "fullname ::= nm DOT nm",
- /* 120 */ "xfullname ::= nm",
- /* 121 */ "xfullname ::= nm DOT nm",
- /* 122 */ "xfullname ::= nm AS nm",
- /* 123 */ "xfullname ::= nm DOT nm AS nm",
- /* 124 */ "joinop ::= COMMA|JOIN",
- /* 125 */ "joinop ::= JOIN_KW JOIN",
- /* 126 */ "joinop ::= JOIN_KW nm JOIN",
- /* 127 */ "joinop ::= JOIN_KW nm nm JOIN",
- /* 128 */ "on_using ::= ON expr",
- /* 129 */ "on_using ::= USING LP idlist RP",
- /* 130 */ "on_using ::=",
- /* 131 */ "indexed_opt ::=",
- /* 132 */ "indexed_by ::= INDEXED BY nm",
- /* 133 */ "indexed_by ::= NOT INDEXED",
- /* 134 */ "orderby_opt ::=",
- /* 135 */ "orderby_opt ::= ORDER BY sortlist",
- /* 136 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
- /* 137 */ "sortlist ::= expr sortorder nulls",
- /* 138 */ "sortorder ::= ASC",
- /* 139 */ "sortorder ::= DESC",
- /* 140 */ "sortorder ::=",
- /* 141 */ "nulls ::= NULLS FIRST",
- /* 142 */ "nulls ::= NULLS LAST",
- /* 143 */ "nulls ::=",
- /* 144 */ "groupby_opt ::=",
- /* 145 */ "groupby_opt ::= GROUP BY nexprlist",
- /* 146 */ "having_opt ::=",
- /* 147 */ "having_opt ::= HAVING expr",
- /* 148 */ "limit_opt ::=",
- /* 149 */ "limit_opt ::= LIMIT expr",
- /* 150 */ "limit_opt ::= LIMIT expr OFFSET expr",
- /* 151 */ "limit_opt ::= LIMIT expr COMMA expr",
- /* 152 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret",
- /* 153 */ "where_opt ::=",
- /* 154 */ "where_opt ::= WHERE expr",
- /* 155 */ "where_opt_ret ::=",
- /* 156 */ "where_opt_ret ::= WHERE expr",
- /* 157 */ "where_opt_ret ::= RETURNING selcollist",
- /* 158 */ "where_opt_ret ::= WHERE expr RETURNING selcollist",
- /* 159 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret",
- /* 160 */ "setlist ::= setlist COMMA nm EQ expr",
- /* 161 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
- /* 162 */ "setlist ::= nm EQ expr",
- /* 163 */ "setlist ::= LP idlist RP EQ expr",
- /* 164 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
- /* 165 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning",
- /* 166 */ "upsert ::=",
- /* 167 */ "upsert ::= RETURNING selcollist",
- /* 168 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
- /* 169 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
- /* 170 */ "upsert ::= ON CONFLICT DO NOTHING returning",
- /* 171 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning",
- /* 172 */ "returning ::= RETURNING selcollist",
- /* 173 */ "insert_cmd ::= INSERT orconf",
- /* 174 */ "insert_cmd ::= REPLACE",
- /* 175 */ "idlist_opt ::=",
- /* 176 */ "idlist_opt ::= LP idlist RP",
- /* 177 */ "idlist ::= idlist COMMA nm",
- /* 178 */ "idlist ::= nm",
- /* 179 */ "expr ::= LP expr RP",
- /* 180 */ "expr ::= ID|INDEXED|JOIN_KW",
- /* 181 */ "expr ::= nm DOT nm",
- /* 182 */ "expr ::= nm DOT nm DOT nm",
- /* 183 */ "term ::= NULL|FLOAT|BLOB",
- /* 184 */ "term ::= STRING",
- /* 185 */ "term ::= INTEGER",
- /* 186 */ "expr ::= VARIABLE",
- /* 187 */ "expr ::= expr COLLATE ID|STRING",
- /* 188 */ "expr ::= CAST LP expr AS typetoken RP",
- /* 189 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP",
- /* 190 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP",
- /* 191 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP",
- /* 192 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over",
- /* 193 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over",
- /* 194 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over",
- /* 195 */ "term ::= CTIME_KW",
- /* 196 */ "expr ::= LP nexprlist COMMA expr RP",
- /* 197 */ "expr ::= expr AND expr",
- /* 198 */ "expr ::= expr OR expr",
- /* 199 */ "expr ::= expr LT|GT|GE|LE expr",
- /* 200 */ "expr ::= expr EQ|NE expr",
- /* 201 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
- /* 202 */ "expr ::= expr PLUS|MINUS expr",
- /* 203 */ "expr ::= expr STAR|SLASH|REM expr",
- /* 204 */ "expr ::= expr CONCAT expr",
- /* 205 */ "likeop ::= NOT LIKE_KW|MATCH",
- /* 206 */ "expr ::= expr likeop expr",
- /* 207 */ "expr ::= expr likeop expr ESCAPE expr",
- /* 208 */ "expr ::= expr ISNULL|NOTNULL",
- /* 209 */ "expr ::= expr NOT NULL",
- /* 210 */ "expr ::= expr IS expr",
- /* 211 */ "expr ::= expr IS NOT expr",
- /* 212 */ "expr ::= expr IS NOT DISTINCT FROM expr",
- /* 213 */ "expr ::= expr IS DISTINCT FROM expr",
- /* 214 */ "expr ::= NOT expr",
- /* 215 */ "expr ::= BITNOT expr",
- /* 216 */ "expr ::= PLUS|MINUS expr",
- /* 217 */ "expr ::= expr PTR expr",
- /* 218 */ "between_op ::= BETWEEN",
- /* 219 */ "between_op ::= NOT BETWEEN",
- /* 220 */ "expr ::= expr between_op expr AND expr",
- /* 221 */ "in_op ::= IN",
- /* 222 */ "in_op ::= NOT IN",
- /* 223 */ "expr ::= expr in_op LP exprlist RP",
- /* 224 */ "expr ::= LP select RP",
- /* 225 */ "expr ::= expr in_op LP select RP",
- /* 226 */ "expr ::= expr in_op nm dbnm paren_exprlist",
- /* 227 */ "expr ::= EXISTS LP select RP",
- /* 228 */ "expr ::= CASE case_operand case_exprlist case_else END",
- /* 229 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
- /* 230 */ "case_exprlist ::= WHEN expr THEN expr",
- /* 231 */ "case_else ::= ELSE expr",
- /* 232 */ "case_else ::=",
- /* 233 */ "case_operand ::=",
- /* 234 */ "exprlist ::=",
- /* 235 */ "nexprlist ::= nexprlist COMMA expr",
- /* 236 */ "nexprlist ::= expr",
- /* 237 */ "paren_exprlist ::=",
- /* 238 */ "paren_exprlist ::= LP exprlist RP",
- /* 239 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
- /* 240 */ "uniqueflag ::= UNIQUE",
- /* 241 */ "uniqueflag ::=",
- /* 242 */ "eidlist_opt ::=",
- /* 243 */ "eidlist_opt ::= LP eidlist RP",
- /* 244 */ "eidlist ::= eidlist COMMA nm collate sortorder",
- /* 245 */ "eidlist ::= nm collate sortorder",
- /* 246 */ "collate ::=",
- /* 247 */ "collate ::= COLLATE ID|STRING",
- /* 248 */ "cmd ::= DROP INDEX ifexists fullname",
- /* 249 */ "cmd ::= VACUUM vinto",
- /* 250 */ "cmd ::= VACUUM nm vinto",
- /* 251 */ "vinto ::= INTO expr",
- /* 252 */ "vinto ::=",
- /* 253 */ "cmd ::= PRAGMA nm dbnm",
- /* 254 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
- /* 255 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
- /* 256 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
- /* 257 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
- /* 258 */ "plus_num ::= PLUS INTEGER|FLOAT",
- /* 259 */ "minus_num ::= MINUS INTEGER|FLOAT",
- /* 260 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
- /* 261 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
- /* 262 */ "trigger_time ::= BEFORE|AFTER",
- /* 263 */ "trigger_time ::= INSTEAD OF",
- /* 264 */ "trigger_time ::=",
- /* 265 */ "trigger_event ::= DELETE|INSERT",
- /* 266 */ "trigger_event ::= UPDATE",
- /* 267 */ "trigger_event ::= UPDATE OF idlist",
- /* 268 */ "when_clause ::=",
- /* 269 */ "when_clause ::= WHEN expr",
- /* 270 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
- /* 271 */ "trigger_cmd_list ::= trigger_cmd SEMI",
- /* 272 */ "tridxby ::= INDEXED BY nm",
- /* 273 */ "tridxby ::= NOT INDEXED",
- /* 274 */ "trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt",
- /* 275 */ "trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt",
- /* 276 */ "trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt",
- /* 277 */ "trigger_cmd ::= scanpt select scanpt",
- /* 278 */ "expr ::= RAISE LP IGNORE RP",
- /* 279 */ "expr ::= RAISE LP raisetype COMMA expr RP",
- /* 280 */ "raisetype ::= ROLLBACK",
- /* 281 */ "raisetype ::= ABORT",
- /* 282 */ "raisetype ::= FAIL",
- /* 283 */ "cmd ::= DROP TRIGGER ifexists fullname",
- /* 284 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
- /* 285 */ "cmd ::= DETACH database_kw_opt expr",
- /* 286 */ "key_opt ::=",
- /* 287 */ "key_opt ::= KEY expr",
- /* 288 */ "cmd ::= REINDEX",
- /* 289 */ "cmd ::= REINDEX nm dbnm",
- /* 290 */ "cmd ::= ANALYZE",
- /* 291 */ "cmd ::= ANALYZE nm dbnm",
- /* 292 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
- /* 293 */ "cmd ::= alter_add carglist",
- /* 294 */ "alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken",
- /* 295 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
- /* 296 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
- /* 297 */ "cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm",
- /* 298 */ "cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL",
- /* 299 */ "cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf",
- /* 300 */ "cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf",
- /* 301 */ "cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf",
- /* 302 */ "cmd ::= create_vtab",
- /* 303 */ "cmd ::= create_vtab LP vtabarglist RP",
- /* 304 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
- /* 305 */ "vtabarg ::=",
- /* 306 */ "vtabargtoken ::= ANY",
- /* 307 */ "vtabargtoken ::= lp anylist RP",
- /* 308 */ "lp ::= LP",
- /* 309 */ "with ::= WITH wqlist",
- /* 310 */ "with ::= WITH RECURSIVE wqlist",
- /* 311 */ "wqas ::= AS",
- /* 312 */ "wqas ::= AS MATERIALIZED",
- /* 313 */ "wqas ::= AS NOT MATERIALIZED",
- /* 314 */ "wqitem ::= withnm eidlist_opt wqas LP select RP",
- /* 315 */ "withnm ::= nm",
- /* 316 */ "wqlist ::= wqitem",
- /* 317 */ "wqlist ::= wqlist COMMA wqitem",
- /* 318 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
- /* 319 */ "windowdefn ::= nm AS LP window RP",
- /* 320 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
- /* 321 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
- /* 322 */ "window ::= ORDER BY sortlist frame_opt",
- /* 323 */ "window ::= nm ORDER BY sortlist frame_opt",
- /* 324 */ "window ::= nm frame_opt",
- /* 325 */ "frame_opt ::=",
- /* 326 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
- /* 327 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
- /* 328 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
- /* 329 */ "frame_bound_s ::= frame_bound",
- /* 330 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
- /* 331 */ "frame_bound_e ::= frame_bound",
- /* 332 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
- /* 333 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
- /* 334 */ "frame_bound ::= CURRENT ROW",
- /* 335 */ "frame_exclude_opt ::=",
- /* 336 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
- /* 337 */ "frame_exclude ::= NO OTHERS",
- /* 338 */ "frame_exclude ::= CURRENT ROW",
- /* 339 */ "frame_exclude ::= GROUP|TIES",
- /* 340 */ "window_clause ::= WINDOW windowdefn_list",
- /* 341 */ "filter_over ::= filter_clause over_clause",
- /* 342 */ "filter_over ::= over_clause",
- /* 343 */ "filter_over ::= filter_clause",
- /* 344 */ "over_clause ::= OVER LP window RP",
- /* 345 */ "over_clause ::= OVER nm",
- /* 346 */ "filter_clause ::= FILTER LP WHERE expr RP",
- /* 347 */ "term ::= QNUMBER",
- /* 348 */ "input ::= cmdlist",
- /* 349 */ "cmdlist ::= cmdlist ecmd",
- /* 350 */ "cmdlist ::= ecmd",
- /* 351 */ "ecmd ::= SEMI",
- /* 352 */ "ecmd ::= cmdx SEMI",
- /* 353 */ "ecmd ::= explain cmdx SEMI",
- /* 354 */ "trans_opt ::=",
- /* 355 */ "trans_opt ::= TRANSACTION",
- /* 356 */ "trans_opt ::= TRANSACTION nm",
- /* 357 */ "savepoint_opt ::= SAVEPOINT",
- /* 358 */ "savepoint_opt ::=",
- /* 359 */ "cmd ::= create_table create_table_args",
- /* 360 */ "table_option_set ::= table_option",
- /* 361 */ "columnlist ::= columnlist COMMA columnname carglist",
- /* 362 */ "columnlist ::= columnname carglist",
- /* 363 */ "nm ::= ID|INDEXED|JOIN_KW",
- /* 364 */ "nm ::= STRING",
- /* 365 */ "typetoken ::= typename",
- /* 366 */ "typename ::= ID|STRING",
- /* 367 */ "signed ::= plus_num",
- /* 368 */ "signed ::= minus_num",
- /* 369 */ "carglist ::= carglist ccons",
- /* 370 */ "carglist ::=",
- /* 371 */ "ccons ::= NULL onconf",
- /* 372 */ "ccons ::= GENERATED ALWAYS AS generated",
- /* 373 */ "ccons ::= AS generated",
- /* 374 */ "conslist_opt ::= COMMA conslist",
- /* 375 */ "conslist ::= conslist tconscomma tcons",
- /* 376 */ "conslist ::= tcons",
- /* 377 */ "tconscomma ::=",
- /* 378 */ "defer_subclause_opt ::= defer_subclause",
- /* 379 */ "resolvetype ::= raisetype",
- /* 380 */ "selectnowith ::= oneselect",
- /* 381 */ "oneselect ::= values",
- /* 382 */ "sclp ::= selcollist COMMA",
- /* 383 */ "as ::= ID|STRING",
- /* 384 */ "indexed_opt ::= indexed_by",
- /* 385 */ "returning ::=",
- /* 386 */ "expr ::= term",
- /* 387 */ "likeop ::= LIKE_KW|MATCH",
- /* 388 */ "case_operand ::= expr",
- /* 389 */ "exprlist ::= nexprlist",
- /* 390 */ "nmnum ::= plus_num",
- /* 391 */ "nmnum ::= nm",
- /* 392 */ "nmnum ::= ON",
- /* 393 */ "nmnum ::= DELETE",
- /* 394 */ "nmnum ::= DEFAULT",
- /* 395 */ "plus_num ::= INTEGER|FLOAT",
- /* 396 */ "foreach_clause ::=",
- /* 397 */ "foreach_clause ::= FOR EACH ROW",
- /* 398 */ "tridxby ::=",
- /* 399 */ "database_kw_opt ::= DATABASE",
- /* 400 */ "database_kw_opt ::=",
- /* 401 */ "kwcolumn_opt ::=",
- /* 402 */ "kwcolumn_opt ::= COLUMNKW",
- /* 403 */ "vtabarglist ::= vtabarg",
- /* 404 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
- /* 405 */ "vtabarg ::= vtabarg vtabargtoken",
- /* 406 */ "anylist ::=",
- /* 407 */ "anylist ::= anylist LP anylist RP",
- /* 408 */ "anylist ::= anylist ANY",
- /* 409 */ "with ::=",
- /* 410 */ "windowdefn_list ::= windowdefn",
- /* 411 */ "window ::= frame_opt",
-};
-#endif /* NDEBUG */
-
-
-#if YYGROWABLESTACK
-/*
-** Try to increase the size of the parser stack.  Return the number
-** of errors.  Return 0 on success.
-*/
-static int yyGrowStack(yyParser *p){
-  int oldSize = 1 + (int)(p->yystackEnd - p->yystack);
-  int newSize;
-  int idx;
-  yyStackEntry *pNew;
-#ifdef YYSIZELIMIT
-  int nLimit = YYSIZELIMIT(sqlite3ParserCTX(p));
-#endif
-
-  newSize = oldSize*2 + 100;
-#ifdef YYSIZELIMIT
-  if( newSize>nLimit ){
-    newSize = nLimit;
-    if( newSize<=oldSize ) return 1;
-  }
-#endif
-  idx = (int)(p->yytos - p->yystack);
-  if( p->yystack==p->yystk0 ){
-    pNew = YYREALLOC(0, newSize*sizeof(pNew[0]), sqlite3ParserCTX(p));
-    if( pNew==0 ) return 1;
-    memcpy(pNew, p->yystack, oldSize*sizeof(pNew[0]));
-  }else{
-    pNew = YYREALLOC(p->yystack, newSize*sizeof(pNew[0]), sqlite3ParserCTX(p));
-    if( pNew==0 ) return 1;
-  }
-  p->yystack = pNew;
-  p->yytos = &p->yystack[idx];
-#ifndef NDEBUG
-  if( yyTraceFILE ){
-    fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",
-            yyTracePrompt, oldSize, newSize);
-  }
-#endif
-  p->yystackEnd = &p->yystack[newSize-1];
-  return 0;
-}
-#endif /* YYGROWABLESTACK */
-
-#if !YYGROWABLESTACK
-/* For builds that do no have a growable stack, yyGrowStack always
-** returns an error.
-*/
-# define yyGrowStack(X) 1
-#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
-  yypParser->yystack = yypParser->yystk0;
-  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
-#ifndef YYNOERRORRECOVERY
-  yypParser->yyerrcnt = -1;
-#endif
-  yypParser->yytos = yypParser->yystack;
-  yypParser->yystack[0].stateno = 0;
-  yypParser->yystack[0].major = 0;
-}
-
-#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 206: /* select */
-    case 241: /* selectnowith */
-    case 242: /* oneselect */
-    case 254: /* values */
-    case 256: /* mvalues */
-{
-sqlite3SelectDelete(pParse->db, (yypminor->yy555));
-}
-      break;
-    case 218: /* term */
-    case 219: /* expr */
-    case 248: /* where_opt */
-    case 250: /* having_opt */
-    case 270: /* where_opt_ret */
-    case 281: /* case_operand */
-    case 283: /* case_else */
-    case 286: /* vinto */
-    case 293: /* when_clause */
-    case 297: /* key_opt */
-    case 314: /* filter_clause */
-{
-sqlite3ExprDelete(pParse->db, (yypminor->yy454));
-}
-      break;
-    case 223: /* eidlist_opt */
-    case 233: /* sortlist */
-    case 234: /* eidlist */
-    case 246: /* selcollist */
-    case 249: /* groupby_opt */
-    case 251: /* orderby_opt */
-    case 255: /* nexprlist */
-    case 257: /* sclp */
-    case 264: /* exprlist */
-    case 271: /* setlist */
-    case 280: /* paren_exprlist */
-    case 282: /* case_exprlist */
-    case 313: /* part_opt */
-{
-sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
-}
-      break;
-    case 240: /* fullname */
-    case 247: /* from */
-    case 259: /* seltablist */
-    case 260: /* stl_prefix */
-    case 265: /* xfullname */
-{
-sqlite3SrcListDelete(pParse->db, (yypminor->yy203));
-}
-      break;
-    case 243: /* wqlist */
-{
-sqlite3WithDelete(pParse->db, (yypminor->yy59));
-}
-      break;
-    case 253: /* window_clause */
-    case 309: /* windowdefn_list */
-{
-sqlite3WindowListDelete(pParse->db, (yypminor->yy211));
-}
-      break;
-    case 266: /* idlist */
-    case 273: /* idlist_opt */
-{
-sqlite3IdListDelete(pParse->db, (yypminor->yy132));
-}
-      break;
-    case 276: /* filter_over */
-    case 310: /* windowdefn */
-    case 311: /* window */
-    case 312: /* frame_opt */
-    case 315: /* over_clause */
-{
-sqlite3WindowDelete(pParse->db, (yypminor->yy211));
-}
-      break;
-    case 289: /* trigger_cmd_list */
-    case 294: /* trigger_cmd */
-{
-sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy427));
-}
-      break;
-    case 291: /* trigger_event */
-{
-sqlite3IdListDelete(pParse->db, (yypminor->yy286).b);
-}
-      break;
-    case 317: /* frame_bound */
-    case 318: /* frame_bound_s */
-    case 319: /* frame_bound_e */
-{
-sqlite3ExprDelete(pParse->db, (yypminor->yy509).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;
-
-  /* In-lined version of calling yy_pop_parser_stack() for each
-  ** element left in the stack */
-  yyStackEntry *yytos = pParser->yytos;
-  while( yytos>pParser->yystack ){
-#ifndef NDEBUG
-    if( yyTraceFILE ){
-      fprintf(yyTraceFILE,"%sPopping %s\n",
-        yyTracePrompt,
-        yyTokenName[yytos->major]);
-    }
-#endif
-    if( yytos->major>=YY_MIN_DSTRCTR ){
-      yy_destructor(pParser, yytos->major, &yytos->minor);
-    }
-    yytos--;
-  }
-
-#if YYGROWABLESTACK
-  if( pParser->yystack!=pParser->yystk0 ){
-    YYFREE(pParser->yystack, sqlite3ParserCTX(pParser));
-  }
-#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; stateno<YYNSTATE; stateno++){
-    i = yy_shift_ofst[stateno];
-    for(iLookAhead=0; iLookAhead<YYNTOKEN; iLookAhead++){
-      if( yy_lookahead[i+iLookAhead]!=iLookAhead ) continue;
-      if( yycoverage[stateno][iLookAhead]==0 ) nMissed++;
-      if( out ){
-        fprintf(out,"State %d lookahead %s %s\n", stateno,
-                yyTokenName[iLookAhead],
-                yycoverage[stateno][iLookAhead] ? "ok" : "missed");
-      }
-    }
-  }
-  return nMissed;
-}
-#endif
-
-/*
-** Find the appropriate action for a parser given the terminal
-** look-ahead token iLookAhead.
-*/
-static YYACTIONTYPE yy_find_shift_action(
-  YYCODETYPE iLookAhead,    /* The look-ahead token */
-  YYACTIONTYPE stateno      /* Current state number */
-){
-  int i;
-
-  if( stateno>YY_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<sizeof(yyFallback)/sizeof(yyFallback[0]) );
-      iFallback = yyFallback[iLookAhead];
-      if( iFallback!=0 ){
-#ifndef NDEBUG
-        if( yyTraceFILE ){
-          fprintf(yyTraceFILE, "%sFALLBACK %s => %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 && i<YY_ACTTAB_COUNT );
-  assert( yy_lookahead[i]==iLookAhead );
-#endif
-  return yy_action[i];
-}
-
-/*
-** The following routine is called if the stack overflows.
-*/
-static void yyStackOverflow(yyParser *yypParser){
-   sqlite3ParserARG_FETCH
-   sqlite3ParserCTX_FETCH
-#ifndef NDEBUG
-   if( yyTraceFILE ){
-     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
-   }
-#endif
-   while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
-   /* Here code is inserted which will execute if the parser
-   ** stack every overflows */
-/******** Begin %stack_overflow code ******************************************/
-
-  if( pParse->nErr==0 ) sqlite3ErrorMsg(pParse, "Recursion limit");
-/******** 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( yyNewState<YYNSTATE ){
-      fprintf(yyTraceFILE,"%s%s '%s', go to state %d\n",
-         yyTracePrompt, zTag, yyTokenName[yypParser->yytos->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
-  yytos = yypParser->yytos;
-  if( yytos>yypParser->yystackEnd ){
-    if( yyGrowStack(yypParser) ){
-      yypParser->yytos--;
-      yyStackOverflow(yypParser);
-      return;
-    }
-    yytos = yypParser->yytos;
-    assert( yytos <= yypParser->yystackEnd );
-  }
-  if( yyNewState > YY_MAX_SHIFT ){
-    yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
-  }
-  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[] = {
-   191,  /* (0) explain ::= EXPLAIN */
-   191,  /* (1) explain ::= EXPLAIN QUERY PLAN */
-   190,  /* (2) cmdx ::= cmd */
-   192,  /* (3) cmd ::= BEGIN transtype trans_opt */
-   193,  /* (4) transtype ::= */
-   193,  /* (5) transtype ::= DEFERRED */
-   193,  /* (6) transtype ::= IMMEDIATE */
-   193,  /* (7) transtype ::= EXCLUSIVE */
-   192,  /* (8) cmd ::= COMMIT|END trans_opt */
-   192,  /* (9) cmd ::= ROLLBACK trans_opt */
-   192,  /* (10) cmd ::= SAVEPOINT nm */
-   192,  /* (11) cmd ::= RELEASE savepoint_opt nm */
-   192,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
-   197,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
-   199,  /* (14) createkw ::= CREATE */
-   201,  /* (15) ifnotexists ::= */
-   201,  /* (16) ifnotexists ::= IF NOT EXISTS */
-   200,  /* (17) temp ::= TEMP */
-   200,  /* (18) temp ::= */
-   198,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */
-   198,  /* (20) create_table_args ::= AS select */
-   205,  /* (21) table_option_set ::= */
-   205,  /* (22) table_option_set ::= table_option_set COMMA table_option */
-   207,  /* (23) table_option ::= WITHOUT nm */
-   207,  /* (24) table_option ::= nm */
-   208,  /* (25) columnname ::= nm typetoken */
-   210,  /* (26) typetoken ::= */
-   210,  /* (27) typetoken ::= typename LP signed RP */
-   210,  /* (28) typetoken ::= typename LP signed COMMA signed RP */
-   211,  /* (29) typename ::= typename ID|STRING */
-   215,  /* (30) scanpt ::= */
-   216,  /* (31) scantok ::= */
-   217,  /* (32) ccons ::= CONSTRAINT nm */
-   217,  /* (33) ccons ::= DEFAULT scantok term */
-   217,  /* (34) ccons ::= DEFAULT LP expr RP */
-   217,  /* (35) ccons ::= DEFAULT PLUS scantok term */
-   217,  /* (36) ccons ::= DEFAULT MINUS scantok term */
-   217,  /* (37) ccons ::= DEFAULT scantok ID|INDEXED */
-   217,  /* (38) ccons ::= NOT NULL onconf */
-   217,  /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */
-   217,  /* (40) ccons ::= UNIQUE onconf */
-   217,  /* (41) ccons ::= CHECK LP expr RP */
-   217,  /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */
-   217,  /* (43) ccons ::= defer_subclause */
-   217,  /* (44) ccons ::= COLLATE ID|STRING */
-   226,  /* (45) generated ::= LP expr RP */
-   226,  /* (46) generated ::= LP expr RP ID */
-   222,  /* (47) autoinc ::= */
-   222,  /* (48) autoinc ::= AUTOINCR */
-   224,  /* (49) refargs ::= */
-   224,  /* (50) refargs ::= refargs refarg */
-   227,  /* (51) refarg ::= MATCH nm */
-   227,  /* (52) refarg ::= ON INSERT refact */
-   227,  /* (53) refarg ::= ON DELETE refact */
-   227,  /* (54) refarg ::= ON UPDATE refact */
-   228,  /* (55) refact ::= SET NULL */
-   228,  /* (56) refact ::= SET DEFAULT */
-   228,  /* (57) refact ::= CASCADE */
-   228,  /* (58) refact ::= RESTRICT */
-   228,  /* (59) refact ::= NO ACTION */
-   225,  /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
-   225,  /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
-   229,  /* (62) init_deferred_pred_opt ::= */
-   229,  /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */
-   229,  /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
-   204,  /* (65) conslist_opt ::= */
-   231,  /* (66) tconscomma ::= COMMA */
-   232,  /* (67) tcons ::= CONSTRAINT nm */
-   232,  /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
-   232,  /* (69) tcons ::= UNIQUE LP sortlist RP onconf */
-   232,  /* (70) tcons ::= CHECK LP expr RP onconf */
-   232,  /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
-   235,  /* (72) defer_subclause_opt ::= */
-   220,  /* (73) onconf ::= */
-   220,  /* (74) onconf ::= ON CONFLICT resolvetype */
-   236,  /* (75) orconf ::= */
-   236,  /* (76) orconf ::= OR resolvetype */
-   237,  /* (77) resolvetype ::= IGNORE */
-   237,  /* (78) resolvetype ::= REPLACE */
-   192,  /* (79) cmd ::= DROP TABLE ifexists fullname */
-   239,  /* (80) ifexists ::= IF EXISTS */
-   239,  /* (81) ifexists ::= */
-   192,  /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
-   192,  /* (83) cmd ::= DROP VIEW ifexists fullname */
-   192,  /* (84) cmd ::= select */
-   206,  /* (85) select ::= WITH wqlist selectnowith */
-   206,  /* (86) select ::= WITH RECURSIVE wqlist selectnowith */
-   206,  /* (87) select ::= selectnowith */
-   241,  /* (88) selectnowith ::= selectnowith multiselect_op oneselect */
-   244,  /* (89) multiselect_op ::= UNION */
-   244,  /* (90) multiselect_op ::= UNION ALL */
-   244,  /* (91) multiselect_op ::= EXCEPT|INTERSECT */
-   242,  /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
-   242,  /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
-   254,  /* (94) values ::= VALUES LP nexprlist RP */
-   242,  /* (95) oneselect ::= mvalues */
-   256,  /* (96) mvalues ::= values COMMA LP nexprlist RP */
-   256,  /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
-   245,  /* (98) distinct ::= DISTINCT */
-   245,  /* (99) distinct ::= ALL */
-   245,  /* (100) distinct ::= */
-   257,  /* (101) sclp ::= */
-   246,  /* (102) selcollist ::= sclp scanpt expr scanpt as */
-   246,  /* (103) selcollist ::= sclp scanpt STAR */
-   246,  /* (104) selcollist ::= sclp scanpt nm DOT STAR */
-   258,  /* (105) as ::= AS nm */
-   258,  /* (106) as ::= */
-   247,  /* (107) from ::= */
-   247,  /* (108) from ::= FROM seltablist */
-   260,  /* (109) stl_prefix ::= seltablist joinop */
-   260,  /* (110) stl_prefix ::= */
-   259,  /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
-   259,  /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
-   259,  /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
-   259,  /* (114) seltablist ::= stl_prefix LP select RP as on_using */
-   259,  /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
-   202,  /* (116) dbnm ::= */
-   202,  /* (117) dbnm ::= DOT nm */
-   240,  /* (118) fullname ::= nm */
-   240,  /* (119) fullname ::= nm DOT nm */
-   265,  /* (120) xfullname ::= nm */
-   265,  /* (121) xfullname ::= nm DOT nm */
-   265,  /* (122) xfullname ::= nm AS nm */
-   265,  /* (123) xfullname ::= nm DOT nm AS nm */
-   261,  /* (124) joinop ::= COMMA|JOIN */
-   261,  /* (125) joinop ::= JOIN_KW JOIN */
-   261,  /* (126) joinop ::= JOIN_KW nm JOIN */
-   261,  /* (127) joinop ::= JOIN_KW nm nm JOIN */
-   262,  /* (128) on_using ::= ON expr */
-   262,  /* (129) on_using ::= USING LP idlist RP */
-   262,  /* (130) on_using ::= */
-   267,  /* (131) indexed_opt ::= */
-   263,  /* (132) indexed_by ::= INDEXED BY nm */
-   263,  /* (133) indexed_by ::= NOT INDEXED */
-   251,  /* (134) orderby_opt ::= */
-   251,  /* (135) orderby_opt ::= ORDER BY sortlist */
-   233,  /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
-   233,  /* (137) sortlist ::= expr sortorder nulls */
-   221,  /* (138) sortorder ::= ASC */
-   221,  /* (139) sortorder ::= DESC */
-   221,  /* (140) sortorder ::= */
-   268,  /* (141) nulls ::= NULLS FIRST */
-   268,  /* (142) nulls ::= NULLS LAST */
-   268,  /* (143) nulls ::= */
-   249,  /* (144) groupby_opt ::= */
-   249,  /* (145) groupby_opt ::= GROUP BY nexprlist */
-   250,  /* (146) having_opt ::= */
-   250,  /* (147) having_opt ::= HAVING expr */
-   252,  /* (148) limit_opt ::= */
-   252,  /* (149) limit_opt ::= LIMIT expr */
-   252,  /* (150) limit_opt ::= LIMIT expr OFFSET expr */
-   252,  /* (151) limit_opt ::= LIMIT expr COMMA expr */
-   192,  /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
-   248,  /* (153) where_opt ::= */
-   248,  /* (154) where_opt ::= WHERE expr */
-   270,  /* (155) where_opt_ret ::= */
-   270,  /* (156) where_opt_ret ::= WHERE expr */
-   270,  /* (157) where_opt_ret ::= RETURNING selcollist */
-   270,  /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
-   192,  /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
-   271,  /* (160) setlist ::= setlist COMMA nm EQ expr */
-   271,  /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
-   271,  /* (162) setlist ::= nm EQ expr */
-   271,  /* (163) setlist ::= LP idlist RP EQ expr */
-   192,  /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
-   192,  /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
-   274,  /* (166) upsert ::= */
-   274,  /* (167) upsert ::= RETURNING selcollist */
-   274,  /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
-   274,  /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
-   274,  /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
-   274,  /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
-   275,  /* (172) returning ::= RETURNING selcollist */
-   272,  /* (173) insert_cmd ::= INSERT orconf */
-   272,  /* (174) insert_cmd ::= REPLACE */
-   273,  /* (175) idlist_opt ::= */
-   273,  /* (176) idlist_opt ::= LP idlist RP */
-   266,  /* (177) idlist ::= idlist COMMA nm */
-   266,  /* (178) idlist ::= nm */
-   219,  /* (179) expr ::= LP expr RP */
-   219,  /* (180) expr ::= ID|INDEXED|JOIN_KW */
-   219,  /* (181) expr ::= nm DOT nm */
-   219,  /* (182) expr ::= nm DOT nm DOT nm */
-   218,  /* (183) term ::= NULL|FLOAT|BLOB */
-   218,  /* (184) term ::= STRING */
-   218,  /* (185) term ::= INTEGER */
-   219,  /* (186) expr ::= VARIABLE */
-   219,  /* (187) expr ::= expr COLLATE ID|STRING */
-   219,  /* (188) expr ::= CAST LP expr AS typetoken RP */
-   219,  /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
-   219,  /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
-   219,  /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
-   219,  /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
-   219,  /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
-   219,  /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
-   218,  /* (195) term ::= CTIME_KW */
-   219,  /* (196) expr ::= LP nexprlist COMMA expr RP */
-   219,  /* (197) expr ::= expr AND expr */
-   219,  /* (198) expr ::= expr OR expr */
-   219,  /* (199) expr ::= expr LT|GT|GE|LE expr */
-   219,  /* (200) expr ::= expr EQ|NE expr */
-   219,  /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
-   219,  /* (202) expr ::= expr PLUS|MINUS expr */
-   219,  /* (203) expr ::= expr STAR|SLASH|REM expr */
-   219,  /* (204) expr ::= expr CONCAT expr */
-   277,  /* (205) likeop ::= NOT LIKE_KW|MATCH */
-   219,  /* (206) expr ::= expr likeop expr */
-   219,  /* (207) expr ::= expr likeop expr ESCAPE expr */
-   219,  /* (208) expr ::= expr ISNULL|NOTNULL */
-   219,  /* (209) expr ::= expr NOT NULL */
-   219,  /* (210) expr ::= expr IS expr */
-   219,  /* (211) expr ::= expr IS NOT expr */
-   219,  /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
-   219,  /* (213) expr ::= expr IS DISTINCT FROM expr */
-   219,  /* (214) expr ::= NOT expr */
-   219,  /* (215) expr ::= BITNOT expr */
-   219,  /* (216) expr ::= PLUS|MINUS expr */
-   219,  /* (217) expr ::= expr PTR expr */
-   278,  /* (218) between_op ::= BETWEEN */
-   278,  /* (219) between_op ::= NOT BETWEEN */
-   219,  /* (220) expr ::= expr between_op expr AND expr */
-   279,  /* (221) in_op ::= IN */
-   279,  /* (222) in_op ::= NOT IN */
-   219,  /* (223) expr ::= expr in_op LP exprlist RP */
-   219,  /* (224) expr ::= LP select RP */
-   219,  /* (225) expr ::= expr in_op LP select RP */
-   219,  /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
-   219,  /* (227) expr ::= EXISTS LP select RP */
-   219,  /* (228) expr ::= CASE case_operand case_exprlist case_else END */
-   282,  /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
-   282,  /* (230) case_exprlist ::= WHEN expr THEN expr */
-   283,  /* (231) case_else ::= ELSE expr */
-   283,  /* (232) case_else ::= */
-   281,  /* (233) case_operand ::= */
-   264,  /* (234) exprlist ::= */
-   255,  /* (235) nexprlist ::= nexprlist COMMA expr */
-   255,  /* (236) nexprlist ::= expr */
-   280,  /* (237) paren_exprlist ::= */
-   280,  /* (238) paren_exprlist ::= LP exprlist RP */
-   192,  /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
-   284,  /* (240) uniqueflag ::= UNIQUE */
-   284,  /* (241) uniqueflag ::= */
-   223,  /* (242) eidlist_opt ::= */
-   223,  /* (243) eidlist_opt ::= LP eidlist RP */
-   234,  /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
-   234,  /* (245) eidlist ::= nm collate sortorder */
-   285,  /* (246) collate ::= */
-   285,  /* (247) collate ::= COLLATE ID|STRING */
-   192,  /* (248) cmd ::= DROP INDEX ifexists fullname */
-   192,  /* (249) cmd ::= VACUUM vinto */
-   192,  /* (250) cmd ::= VACUUM nm vinto */
-   286,  /* (251) vinto ::= INTO expr */
-   286,  /* (252) vinto ::= */
-   192,  /* (253) cmd ::= PRAGMA nm dbnm */
-   192,  /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
-   192,  /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
-   192,  /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
-   192,  /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
-   213,  /* (258) plus_num ::= PLUS INTEGER|FLOAT */
-   214,  /* (259) minus_num ::= MINUS INTEGER|FLOAT */
-   192,  /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
-   288,  /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
-   290,  /* (262) trigger_time ::= BEFORE|AFTER */
-   290,  /* (263) trigger_time ::= INSTEAD OF */
-   290,  /* (264) trigger_time ::= */
-   291,  /* (265) trigger_event ::= DELETE|INSERT */
-   291,  /* (266) trigger_event ::= UPDATE */
-   291,  /* (267) trigger_event ::= UPDATE OF idlist */
-   293,  /* (268) when_clause ::= */
-   293,  /* (269) when_clause ::= WHEN expr */
-   289,  /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
-   289,  /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
-   295,  /* (272) tridxby ::= INDEXED BY nm */
-   295,  /* (273) tridxby ::= NOT INDEXED */
-   294,  /* (274) trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt */
-   294,  /* (275) trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt */
-   294,  /* (276) trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt */
-   294,  /* (277) trigger_cmd ::= scanpt select scanpt */
-   219,  /* (278) expr ::= RAISE LP IGNORE RP */
-   219,  /* (279) expr ::= RAISE LP raisetype COMMA expr RP */
-   238,  /* (280) raisetype ::= ROLLBACK */
-   238,  /* (281) raisetype ::= ABORT */
-   238,  /* (282) raisetype ::= FAIL */
-   192,  /* (283) cmd ::= DROP TRIGGER ifexists fullname */
-   192,  /* (284) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
-   192,  /* (285) cmd ::= DETACH database_kw_opt expr */
-   297,  /* (286) key_opt ::= */
-   297,  /* (287) key_opt ::= KEY expr */
-   192,  /* (288) cmd ::= REINDEX */
-   192,  /* (289) cmd ::= REINDEX nm dbnm */
-   192,  /* (290) cmd ::= ANALYZE */
-   192,  /* (291) cmd ::= ANALYZE nm dbnm */
-   192,  /* (292) cmd ::= ALTER TABLE fullname RENAME TO nm */
-   192,  /* (293) cmd ::= alter_add carglist */
-   298,  /* (294) alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */
-   192,  /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
-   192,  /* (296) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
-   192,  /* (297) cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */
-   192,  /* (298) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */
-   192,  /* (299) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */
-   192,  /* (300) cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */
-   192,  /* (301) cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */
-   192,  /* (302) cmd ::= create_vtab */
-   192,  /* (303) cmd ::= create_vtab LP vtabarglist RP */
-   300,  /* (304) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
-   302,  /* (305) vtabarg ::= */
-   303,  /* (306) vtabargtoken ::= ANY */
-   303,  /* (307) vtabargtoken ::= lp anylist RP */
-   304,  /* (308) lp ::= LP */
-   269,  /* (309) with ::= WITH wqlist */
-   269,  /* (310) with ::= WITH RECURSIVE wqlist */
-   307,  /* (311) wqas ::= AS */
-   307,  /* (312) wqas ::= AS MATERIALIZED */
-   307,  /* (313) wqas ::= AS NOT MATERIALIZED */
-   306,  /* (314) wqitem ::= withnm eidlist_opt wqas LP select RP */
-   308,  /* (315) withnm ::= nm */
-   243,  /* (316) wqlist ::= wqitem */
-   243,  /* (317) wqlist ::= wqlist COMMA wqitem */
-   309,  /* (318) windowdefn_list ::= windowdefn_list COMMA windowdefn */
-   310,  /* (319) windowdefn ::= nm AS LP window RP */
-   311,  /* (320) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
-   311,  /* (321) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
-   311,  /* (322) window ::= ORDER BY sortlist frame_opt */
-   311,  /* (323) window ::= nm ORDER BY sortlist frame_opt */
-   311,  /* (324) window ::= nm frame_opt */
-   312,  /* (325) frame_opt ::= */
-   312,  /* (326) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
-   312,  /* (327) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
-   316,  /* (328) range_or_rows ::= RANGE|ROWS|GROUPS */
-   318,  /* (329) frame_bound_s ::= frame_bound */
-   318,  /* (330) frame_bound_s ::= UNBOUNDED PRECEDING */
-   319,  /* (331) frame_bound_e ::= frame_bound */
-   319,  /* (332) frame_bound_e ::= UNBOUNDED FOLLOWING */
-   317,  /* (333) frame_bound ::= expr PRECEDING|FOLLOWING */
-   317,  /* (334) frame_bound ::= CURRENT ROW */
-   320,  /* (335) frame_exclude_opt ::= */
-   320,  /* (336) frame_exclude_opt ::= EXCLUDE frame_exclude */
-   321,  /* (337) frame_exclude ::= NO OTHERS */
-   321,  /* (338) frame_exclude ::= CURRENT ROW */
-   321,  /* (339) frame_exclude ::= GROUP|TIES */
-   253,  /* (340) window_clause ::= WINDOW windowdefn_list */
-   276,  /* (341) filter_over ::= filter_clause over_clause */
-   276,  /* (342) filter_over ::= over_clause */
-   276,  /* (343) filter_over ::= filter_clause */
-   315,  /* (344) over_clause ::= OVER LP window RP */
-   315,  /* (345) over_clause ::= OVER nm */
-   314,  /* (346) filter_clause ::= FILTER LP WHERE expr RP */
-   218,  /* (347) term ::= QNUMBER */
-   187,  /* (348) input ::= cmdlist */
-   188,  /* (349) cmdlist ::= cmdlist ecmd */
-   188,  /* (350) cmdlist ::= ecmd */
-   189,  /* (351) ecmd ::= SEMI */
-   189,  /* (352) ecmd ::= cmdx SEMI */
-   189,  /* (353) ecmd ::= explain cmdx SEMI */
-   194,  /* (354) trans_opt ::= */
-   194,  /* (355) trans_opt ::= TRANSACTION */
-   194,  /* (356) trans_opt ::= TRANSACTION nm */
-   196,  /* (357) savepoint_opt ::= SAVEPOINT */
-   196,  /* (358) savepoint_opt ::= */
-   192,  /* (359) cmd ::= create_table create_table_args */
-   205,  /* (360) table_option_set ::= table_option */
-   203,  /* (361) columnlist ::= columnlist COMMA columnname carglist */
-   203,  /* (362) columnlist ::= columnname carglist */
-   195,  /* (363) nm ::= ID|INDEXED|JOIN_KW */
-   195,  /* (364) nm ::= STRING */
-   210,  /* (365) typetoken ::= typename */
-   211,  /* (366) typename ::= ID|STRING */
-   212,  /* (367) signed ::= plus_num */
-   212,  /* (368) signed ::= minus_num */
-   209,  /* (369) carglist ::= carglist ccons */
-   209,  /* (370) carglist ::= */
-   217,  /* (371) ccons ::= NULL onconf */
-   217,  /* (372) ccons ::= GENERATED ALWAYS AS generated */
-   217,  /* (373) ccons ::= AS generated */
-   204,  /* (374) conslist_opt ::= COMMA conslist */
-   230,  /* (375) conslist ::= conslist tconscomma tcons */
-   230,  /* (376) conslist ::= tcons */
-   231,  /* (377) tconscomma ::= */
-   235,  /* (378) defer_subclause_opt ::= defer_subclause */
-   237,  /* (379) resolvetype ::= raisetype */
-   241,  /* (380) selectnowith ::= oneselect */
-   242,  /* (381) oneselect ::= values */
-   257,  /* (382) sclp ::= selcollist COMMA */
-   258,  /* (383) as ::= ID|STRING */
-   267,  /* (384) indexed_opt ::= indexed_by */
-   275,  /* (385) returning ::= */
-   219,  /* (386) expr ::= term */
-   277,  /* (387) likeop ::= LIKE_KW|MATCH */
-   281,  /* (388) case_operand ::= expr */
-   264,  /* (389) exprlist ::= nexprlist */
-   287,  /* (390) nmnum ::= plus_num */
-   287,  /* (391) nmnum ::= nm */
-   287,  /* (392) nmnum ::= ON */
-   287,  /* (393) nmnum ::= DELETE */
-   287,  /* (394) nmnum ::= DEFAULT */
-   213,  /* (395) plus_num ::= INTEGER|FLOAT */
-   292,  /* (396) foreach_clause ::= */
-   292,  /* (397) foreach_clause ::= FOR EACH ROW */
-   295,  /* (398) tridxby ::= */
-   296,  /* (399) database_kw_opt ::= DATABASE */
-   296,  /* (400) database_kw_opt ::= */
-   299,  /* (401) kwcolumn_opt ::= */
-   299,  /* (402) kwcolumn_opt ::= COLUMNKW */
-   301,  /* (403) vtabarglist ::= vtabarg */
-   301,  /* (404) vtabarglist ::= vtabarglist COMMA vtabarg */
-   302,  /* (405) vtabarg ::= vtabarg vtabargtoken */
-   305,  /* (406) anylist ::= */
-   305,  /* (407) anylist ::= anylist LP anylist RP */
-   305,  /* (408) anylist ::= anylist ANY */
-   269,  /* (409) with ::= */
-   309,  /* (410) windowdefn_list ::= windowdefn */
-   311,  /* (411) window ::= frame_opt */
-};
-
-/* 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 */
-   -1,  /* (95) oneselect ::= mvalues */
-   -5,  /* (96) mvalues ::= values COMMA LP nexprlist RP */
-   -5,  /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
-   -1,  /* (98) distinct ::= DISTINCT */
-   -1,  /* (99) distinct ::= ALL */
-    0,  /* (100) distinct ::= */
-    0,  /* (101) sclp ::= */
-   -5,  /* (102) selcollist ::= sclp scanpt expr scanpt as */
-   -3,  /* (103) selcollist ::= sclp scanpt STAR */
-   -5,  /* (104) selcollist ::= sclp scanpt nm DOT STAR */
-   -2,  /* (105) as ::= AS nm */
-    0,  /* (106) as ::= */
-    0,  /* (107) from ::= */
-   -2,  /* (108) from ::= FROM seltablist */
-   -2,  /* (109) stl_prefix ::= seltablist joinop */
-    0,  /* (110) stl_prefix ::= */
-   -5,  /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
-   -6,  /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
-   -8,  /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
-   -6,  /* (114) seltablist ::= stl_prefix LP select RP as on_using */
-   -6,  /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
-    0,  /* (116) dbnm ::= */
-   -2,  /* (117) dbnm ::= DOT nm */
-   -1,  /* (118) fullname ::= nm */
-   -3,  /* (119) fullname ::= nm DOT nm */
-   -1,  /* (120) xfullname ::= nm */
-   -3,  /* (121) xfullname ::= nm DOT nm */
-   -3,  /* (122) xfullname ::= nm AS nm */
-   -5,  /* (123) xfullname ::= nm DOT nm AS nm */
-   -1,  /* (124) joinop ::= COMMA|JOIN */
-   -2,  /* (125) joinop ::= JOIN_KW JOIN */
-   -3,  /* (126) joinop ::= JOIN_KW nm JOIN */
-   -4,  /* (127) joinop ::= JOIN_KW nm nm JOIN */
-   -2,  /* (128) on_using ::= ON expr */
-   -4,  /* (129) on_using ::= USING LP idlist RP */
-    0,  /* (130) on_using ::= */
-    0,  /* (131) indexed_opt ::= */
-   -3,  /* (132) indexed_by ::= INDEXED BY nm */
-   -2,  /* (133) indexed_by ::= NOT INDEXED */
-    0,  /* (134) orderby_opt ::= */
-   -3,  /* (135) orderby_opt ::= ORDER BY sortlist */
-   -5,  /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
-   -3,  /* (137) sortlist ::= expr sortorder nulls */
-   -1,  /* (138) sortorder ::= ASC */
-   -1,  /* (139) sortorder ::= DESC */
-    0,  /* (140) sortorder ::= */
-   -2,  /* (141) nulls ::= NULLS FIRST */
-   -2,  /* (142) nulls ::= NULLS LAST */
-    0,  /* (143) nulls ::= */
-    0,  /* (144) groupby_opt ::= */
-   -3,  /* (145) groupby_opt ::= GROUP BY nexprlist */
-    0,  /* (146) having_opt ::= */
-   -2,  /* (147) having_opt ::= HAVING expr */
-    0,  /* (148) limit_opt ::= */
-   -2,  /* (149) limit_opt ::= LIMIT expr */
-   -4,  /* (150) limit_opt ::= LIMIT expr OFFSET expr */
-   -4,  /* (151) limit_opt ::= LIMIT expr COMMA expr */
-   -6,  /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
-    0,  /* (153) where_opt ::= */
-   -2,  /* (154) where_opt ::= WHERE expr */
-    0,  /* (155) where_opt_ret ::= */
-   -2,  /* (156) where_opt_ret ::= WHERE expr */
-   -2,  /* (157) where_opt_ret ::= RETURNING selcollist */
-   -4,  /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
-   -9,  /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
-   -5,  /* (160) setlist ::= setlist COMMA nm EQ expr */
-   -7,  /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
-   -3,  /* (162) setlist ::= nm EQ expr */
-   -5,  /* (163) setlist ::= LP idlist RP EQ expr */
-   -7,  /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
-   -8,  /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
-    0,  /* (166) upsert ::= */
-   -2,  /* (167) upsert ::= RETURNING selcollist */
-  -12,  /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
-   -9,  /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
-   -5,  /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
-   -8,  /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
-   -2,  /* (172) returning ::= RETURNING selcollist */
-   -2,  /* (173) insert_cmd ::= INSERT orconf */
-   -1,  /* (174) insert_cmd ::= REPLACE */
-    0,  /* (175) idlist_opt ::= */
-   -3,  /* (176) idlist_opt ::= LP idlist RP */
-   -3,  /* (177) idlist ::= idlist COMMA nm */
-   -1,  /* (178) idlist ::= nm */
-   -3,  /* (179) expr ::= LP expr RP */
-   -1,  /* (180) expr ::= ID|INDEXED|JOIN_KW */
-   -3,  /* (181) expr ::= nm DOT nm */
-   -5,  /* (182) expr ::= nm DOT nm DOT nm */
-   -1,  /* (183) term ::= NULL|FLOAT|BLOB */
-   -1,  /* (184) term ::= STRING */
-   -1,  /* (185) term ::= INTEGER */
-   -1,  /* (186) expr ::= VARIABLE */
-   -3,  /* (187) expr ::= expr COLLATE ID|STRING */
-   -6,  /* (188) expr ::= CAST LP expr AS typetoken RP */
-   -5,  /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
-   -8,  /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
-   -4,  /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
-   -6,  /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
-   -9,  /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
-   -5,  /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
-   -1,  /* (195) term ::= CTIME_KW */
-   -5,  /* (196) expr ::= LP nexprlist COMMA expr RP */
-   -3,  /* (197) expr ::= expr AND expr */
-   -3,  /* (198) expr ::= expr OR expr */
-   -3,  /* (199) expr ::= expr LT|GT|GE|LE expr */
-   -3,  /* (200) expr ::= expr EQ|NE expr */
-   -3,  /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
-   -3,  /* (202) expr ::= expr PLUS|MINUS expr */
-   -3,  /* (203) expr ::= expr STAR|SLASH|REM expr */
-   -3,  /* (204) expr ::= expr CONCAT expr */
-   -2,  /* (205) likeop ::= NOT LIKE_KW|MATCH */
-   -3,  /* (206) expr ::= expr likeop expr */
-   -5,  /* (207) expr ::= expr likeop expr ESCAPE expr */
-   -2,  /* (208) expr ::= expr ISNULL|NOTNULL */
-   -3,  /* (209) expr ::= expr NOT NULL */
-   -3,  /* (210) expr ::= expr IS expr */
-   -4,  /* (211) expr ::= expr IS NOT expr */
-   -6,  /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
-   -5,  /* (213) expr ::= expr IS DISTINCT FROM expr */
-   -2,  /* (214) expr ::= NOT expr */
-   -2,  /* (215) expr ::= BITNOT expr */
-   -2,  /* (216) expr ::= PLUS|MINUS expr */
-   -3,  /* (217) expr ::= expr PTR expr */
-   -1,  /* (218) between_op ::= BETWEEN */
-   -2,  /* (219) between_op ::= NOT BETWEEN */
-   -5,  /* (220) expr ::= expr between_op expr AND expr */
-   -1,  /* (221) in_op ::= IN */
-   -2,  /* (222) in_op ::= NOT IN */
-   -5,  /* (223) expr ::= expr in_op LP exprlist RP */
-   -3,  /* (224) expr ::= LP select RP */
-   -5,  /* (225) expr ::= expr in_op LP select RP */
-   -5,  /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
-   -4,  /* (227) expr ::= EXISTS LP select RP */
-   -5,  /* (228) expr ::= CASE case_operand case_exprlist case_else END */
-   -5,  /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
-   -4,  /* (230) case_exprlist ::= WHEN expr THEN expr */
-   -2,  /* (231) case_else ::= ELSE expr */
-    0,  /* (232) case_else ::= */
-    0,  /* (233) case_operand ::= */
-    0,  /* (234) exprlist ::= */
-   -3,  /* (235) nexprlist ::= nexprlist COMMA expr */
-   -1,  /* (236) nexprlist ::= expr */
-    0,  /* (237) paren_exprlist ::= */
-   -3,  /* (238) paren_exprlist ::= LP exprlist RP */
-  -12,  /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
-   -1,  /* (240) uniqueflag ::= UNIQUE */
-    0,  /* (241) uniqueflag ::= */
-    0,  /* (242) eidlist_opt ::= */
-   -3,  /* (243) eidlist_opt ::= LP eidlist RP */
-   -5,  /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
-   -3,  /* (245) eidlist ::= nm collate sortorder */
-    0,  /* (246) collate ::= */
-   -2,  /* (247) collate ::= COLLATE ID|STRING */
-   -4,  /* (248) cmd ::= DROP INDEX ifexists fullname */
-   -2,  /* (249) cmd ::= VACUUM vinto */
-   -3,  /* (250) cmd ::= VACUUM nm vinto */
-   -2,  /* (251) vinto ::= INTO expr */
-    0,  /* (252) vinto ::= */
-   -3,  /* (253) cmd ::= PRAGMA nm dbnm */
-   -5,  /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
-   -6,  /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
-   -5,  /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
-   -6,  /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
-   -2,  /* (258) plus_num ::= PLUS INTEGER|FLOAT */
-   -2,  /* (259) minus_num ::= MINUS INTEGER|FLOAT */
-   -5,  /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
-  -11,  /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
-   -1,  /* (262) trigger_time ::= BEFORE|AFTER */
-   -2,  /* (263) trigger_time ::= INSTEAD OF */
-    0,  /* (264) trigger_time ::= */
-   -1,  /* (265) trigger_event ::= DELETE|INSERT */
-   -1,  /* (266) trigger_event ::= UPDATE */
-   -3,  /* (267) trigger_event ::= UPDATE OF idlist */
-    0,  /* (268) when_clause ::= */
-   -2,  /* (269) when_clause ::= WHEN expr */
-   -3,  /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
-   -2,  /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
-   -3,  /* (272) tridxby ::= INDEXED BY nm */
-   -2,  /* (273) tridxby ::= NOT INDEXED */
-   -9,  /* (274) trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt */
-   -8,  /* (275) trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt */
-   -6,  /* (276) trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt */
-   -3,  /* (277) trigger_cmd ::= scanpt select scanpt */
-   -4,  /* (278) expr ::= RAISE LP IGNORE RP */
-   -6,  /* (279) expr ::= RAISE LP raisetype COMMA expr RP */
-   -1,  /* (280) raisetype ::= ROLLBACK */
-   -1,  /* (281) raisetype ::= ABORT */
-   -1,  /* (282) raisetype ::= FAIL */
-   -4,  /* (283) cmd ::= DROP TRIGGER ifexists fullname */
-   -6,  /* (284) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
-   -3,  /* (285) cmd ::= DETACH database_kw_opt expr */
-    0,  /* (286) key_opt ::= */
-   -2,  /* (287) key_opt ::= KEY expr */
-   -1,  /* (288) cmd ::= REINDEX */
-   -3,  /* (289) cmd ::= REINDEX nm dbnm */
-   -1,  /* (290) cmd ::= ANALYZE */
-   -3,  /* (291) cmd ::= ANALYZE nm dbnm */
-   -6,  /* (292) cmd ::= ALTER TABLE fullname RENAME TO nm */
-   -2,  /* (293) cmd ::= alter_add carglist */
-   -7,  /* (294) alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */
-   -6,  /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
-   -8,  /* (296) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
-   -6,  /* (297) cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */
-   -9,  /* (298) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */
-  -10,  /* (299) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */
-  -11,  /* (300) cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */
-   -9,  /* (301) cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */
-   -1,  /* (302) cmd ::= create_vtab */
-   -4,  /* (303) cmd ::= create_vtab LP vtabarglist RP */
-   -8,  /* (304) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
-    0,  /* (305) vtabarg ::= */
-   -1,  /* (306) vtabargtoken ::= ANY */
-   -3,  /* (307) vtabargtoken ::= lp anylist RP */
-   -1,  /* (308) lp ::= LP */
-   -2,  /* (309) with ::= WITH wqlist */
-   -3,  /* (310) with ::= WITH RECURSIVE wqlist */
-   -1,  /* (311) wqas ::= AS */
-   -2,  /* (312) wqas ::= AS MATERIALIZED */
-   -3,  /* (313) wqas ::= AS NOT MATERIALIZED */
-   -6,  /* (314) wqitem ::= withnm eidlist_opt wqas LP select RP */
-   -1,  /* (315) withnm ::= nm */
-   -1,  /* (316) wqlist ::= wqitem */
-   -3,  /* (317) wqlist ::= wqlist COMMA wqitem */
-   -3,  /* (318) windowdefn_list ::= windowdefn_list COMMA windowdefn */
-   -5,  /* (319) windowdefn ::= nm AS LP window RP */
-   -5,  /* (320) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
-   -6,  /* (321) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
-   -4,  /* (322) window ::= ORDER BY sortlist frame_opt */
-   -5,  /* (323) window ::= nm ORDER BY sortlist frame_opt */
-   -2,  /* (324) window ::= nm frame_opt */
-    0,  /* (325) frame_opt ::= */
-   -3,  /* (326) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
-   -6,  /* (327) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
-   -1,  /* (328) range_or_rows ::= RANGE|ROWS|GROUPS */
-   -1,  /* (329) frame_bound_s ::= frame_bound */
-   -2,  /* (330) frame_bound_s ::= UNBOUNDED PRECEDING */
-   -1,  /* (331) frame_bound_e ::= frame_bound */
-   -2,  /* (332) frame_bound_e ::= UNBOUNDED FOLLOWING */
-   -2,  /* (333) frame_bound ::= expr PRECEDING|FOLLOWING */
-   -2,  /* (334) frame_bound ::= CURRENT ROW */
-    0,  /* (335) frame_exclude_opt ::= */
-   -2,  /* (336) frame_exclude_opt ::= EXCLUDE frame_exclude */
-   -2,  /* (337) frame_exclude ::= NO OTHERS */
-   -2,  /* (338) frame_exclude ::= CURRENT ROW */
-   -1,  /* (339) frame_exclude ::= GROUP|TIES */
-   -2,  /* (340) window_clause ::= WINDOW windowdefn_list */
-   -2,  /* (341) filter_over ::= filter_clause over_clause */
-   -1,  /* (342) filter_over ::= over_clause */
-   -1,  /* (343) filter_over ::= filter_clause */
-   -4,  /* (344) over_clause ::= OVER LP window RP */
-   -2,  /* (345) over_clause ::= OVER nm */
-   -5,  /* (346) filter_clause ::= FILTER LP WHERE expr RP */
-   -1,  /* (347) term ::= QNUMBER */
-   -1,  /* (348) input ::= cmdlist */
-   -2,  /* (349) cmdlist ::= cmdlist ecmd */
-   -1,  /* (350) cmdlist ::= ecmd */
-   -1,  /* (351) ecmd ::= SEMI */
-   -2,  /* (352) ecmd ::= cmdx SEMI */
-   -3,  /* (353) ecmd ::= explain cmdx SEMI */
-    0,  /* (354) trans_opt ::= */
-   -1,  /* (355) trans_opt ::= TRANSACTION */
-   -2,  /* (356) trans_opt ::= TRANSACTION nm */
-   -1,  /* (357) savepoint_opt ::= SAVEPOINT */
-    0,  /* (358) savepoint_opt ::= */
-   -2,  /* (359) cmd ::= create_table create_table_args */
-   -1,  /* (360) table_option_set ::= table_option */
-   -4,  /* (361) columnlist ::= columnlist COMMA columnname carglist */
-   -2,  /* (362) columnlist ::= columnname carglist */
-   -1,  /* (363) nm ::= ID|INDEXED|JOIN_KW */
-   -1,  /* (364) nm ::= STRING */
-   -1,  /* (365) typetoken ::= typename */
-   -1,  /* (366) typename ::= ID|STRING */
-   -1,  /* (367) signed ::= plus_num */
-   -1,  /* (368) signed ::= minus_num */
-   -2,  /* (369) carglist ::= carglist ccons */
-    0,  /* (370) carglist ::= */
-   -2,  /* (371) ccons ::= NULL onconf */
-   -4,  /* (372) ccons ::= GENERATED ALWAYS AS generated */
-   -2,  /* (373) ccons ::= AS generated */
-   -2,  /* (374) conslist_opt ::= COMMA conslist */
-   -3,  /* (375) conslist ::= conslist tconscomma tcons */
-   -1,  /* (376) conslist ::= tcons */
-    0,  /* (377) tconscomma ::= */
-   -1,  /* (378) defer_subclause_opt ::= defer_subclause */
-   -1,  /* (379) resolvetype ::= raisetype */
-   -1,  /* (380) selectnowith ::= oneselect */
-   -1,  /* (381) oneselect ::= values */
-   -2,  /* (382) sclp ::= selcollist COMMA */
-   -1,  /* (383) as ::= ID|STRING */
-   -1,  /* (384) indexed_opt ::= indexed_by */
-    0,  /* (385) returning ::= */
-   -1,  /* (386) expr ::= term */
-   -1,  /* (387) likeop ::= LIKE_KW|MATCH */
-   -1,  /* (388) case_operand ::= expr */
-   -1,  /* (389) exprlist ::= nexprlist */
-   -1,  /* (390) nmnum ::= plus_num */
-   -1,  /* (391) nmnum ::= nm */
-   -1,  /* (392) nmnum ::= ON */
-   -1,  /* (393) nmnum ::= DELETE */
-   -1,  /* (394) nmnum ::= DEFAULT */
-   -1,  /* (395) plus_num ::= INTEGER|FLOAT */
-    0,  /* (396) foreach_clause ::= */
-   -3,  /* (397) foreach_clause ::= FOR EACH ROW */
-    0,  /* (398) tridxby ::= */
-   -1,  /* (399) database_kw_opt ::= DATABASE */
-    0,  /* (400) database_kw_opt ::= */
-    0,  /* (401) kwcolumn_opt ::= */
-   -1,  /* (402) kwcolumn_opt ::= COLUMNKW */
-   -1,  /* (403) vtabarglist ::= vtabarg */
-   -3,  /* (404) vtabarglist ::= vtabarglist COMMA vtabarg */
-   -2,  /* (405) vtabarg ::= vtabarg vtabargtoken */
-    0,  /* (406) anylist ::= */
-   -4,  /* (407) anylist ::= anylist LP anylist RP */
-   -2,  /* (408) anylist ::= anylist ANY */
-    0,  /* (409) with ::= */
-   -1,  /* (410) windowdefn_list ::= windowdefn */
-   -1,  /* (411) window ::= frame_opt */
-};
-
-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 <lineno> <grammarfile>
-  **     { ... }           // User supplied code
-  **  #line <lineno> <thisfile>
-  **     break;
-  */
-/********** Begin reduce actions **********************************************/
-        YYMINORTYPE yylhsminor;
-      case 0: /* explain ::= EXPLAIN */
-{ if( pParse->pReprepare==0 ) pParse->explain = 1; }
-        break;
-      case 1: /* explain ::= EXPLAIN QUERY PLAN */
-{ if( pParse->pReprepare==0 ) pParse->explain = 2; }
-        break;
-      case 2: /* cmdx ::= cmd */
-{ sqlite3FinishCoding(pParse); }
-        break;
-      case 3: /* cmd ::= BEGIN transtype trans_opt */
-{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy144);}
-        break;
-      case 4: /* transtype ::= */
-{yymsp[1].minor.yy144 = TK_DEFERRED;}
-        break;
-      case 5: /* transtype ::= DEFERRED */
-      case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
-      case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
-      case 328: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==328);
-{yymsp[0].minor.yy144 = 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.yy144,0,0,yymsp[-2].minor.yy144);
-}
-        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 100: /* distinct ::= */ yytestcase(yyruleno==100);
-      case 246: /* collate ::= */ yytestcase(yyruleno==246);
-{yymsp[1].minor.yy144 = 0;}
-        break;
-      case 16: /* ifnotexists ::= IF NOT EXISTS */
-{yymsp[-2].minor.yy144 = 1;}
-        break;
-      case 17: /* temp ::= TEMP */
-{yymsp[0].minor.yy144 = 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.yy391,0);
-}
-        break;
-      case 20: /* create_table_args ::= AS select */
-{
-  sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy555);
-  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
-}
-        break;
-      case 21: /* table_option_set ::= */
-{yymsp[1].minor.yy391 = 0;}
-        break;
-      case 22: /* table_option_set ::= table_option_set COMMA table_option */
-{yylhsminor.yy391 = yymsp[-2].minor.yy391|yymsp[0].minor.yy391;}
-  yymsp[-2].minor.yy391 = yylhsminor.yy391;
-        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.yy391 = TF_WithoutRowid | TF_NoVisibleRowid;
-  }else{
-    yymsp[-1].minor.yy391 = 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.yy391 = TF_Strict;
-  }else{
-    yylhsminor.yy391 = 0;
-    sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
-  }
-}
-  yymsp[0].minor.yy391 = yylhsminor.yy391;
-        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 106: /* as ::= */ yytestcase(yyruleno==106);
-{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.yy168 = 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);
-{ASSERT_IS_CREATE; pParse->u1.cr.constraintName = yymsp[0].minor.yy0;}
-        break;
-      case 33: /* ccons ::= DEFAULT scantok term */
-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,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.yy454,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
-        break;
-      case 35: /* ccons ::= DEFAULT PLUS scantok term */
-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,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.yy454, 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.yy144);}
-        break;
-      case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
-{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy144,yymsp[0].minor.yy144,yymsp[-2].minor.yy144);}
-        break;
-      case 40: /* ccons ::= UNIQUE onconf */
-{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy144,0,0,0,0,
-                                   SQLITE_IDXTYPE_UNIQUE);}
-        break;
-      case 41: /* ccons ::= CHECK LP expr RP */
-{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy454,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.yy14,yymsp[0].minor.yy144);}
-        break;
-      case 43: /* ccons ::= defer_subclause */
-{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy144);}
-        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.yy454,0);}
-        break;
-      case 46: /* generated ::= LP expr RP ID */
-{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy454,&yymsp[0].minor.yy0);}
-        break;
-      case 48: /* autoinc ::= AUTOINCR */
-{yymsp[0].minor.yy144 = 1;}
-        break;
-      case 49: /* refargs ::= */
-{ yymsp[1].minor.yy144 = OE_None*0x0101; /* EV: R-19803-45884 */}
-        break;
-      case 50: /* refargs ::= refargs refarg */
-{ yymsp[-1].minor.yy144 = (yymsp[-1].minor.yy144 & ~yymsp[0].minor.yy383.mask) | yymsp[0].minor.yy383.value; }
-        break;
-      case 51: /* refarg ::= MATCH nm */
-{ yymsp[-1].minor.yy383.value = 0;     yymsp[-1].minor.yy383.mask = 0x000000; }
-        break;
-      case 52: /* refarg ::= ON INSERT refact */
-{ yymsp[-2].minor.yy383.value = 0;     yymsp[-2].minor.yy383.mask = 0x000000; }
-        break;
-      case 53: /* refarg ::= ON DELETE refact */
-{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144;     yymsp[-2].minor.yy383.mask = 0x0000ff; }
-        break;
-      case 54: /* refarg ::= ON UPDATE refact */
-{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144<<8;  yymsp[-2].minor.yy383.mask = 0x00ff00; }
-        break;
-      case 55: /* refact ::= SET NULL */
-{ yymsp[-1].minor.yy144 = OE_SetNull;  /* EV: R-33326-45252 */}
-        break;
-      case 56: /* refact ::= SET DEFAULT */
-{ yymsp[-1].minor.yy144 = OE_SetDflt;  /* EV: R-33326-45252 */}
-        break;
-      case 57: /* refact ::= CASCADE */
-{ yymsp[0].minor.yy144 = OE_Cascade;  /* EV: R-33326-45252 */}
-        break;
-      case 58: /* refact ::= RESTRICT */
-{ yymsp[0].minor.yy144 = OE_Restrict; /* EV: R-33326-45252 */}
-        break;
-      case 59: /* refact ::= NO ACTION */
-{ yymsp[-1].minor.yy144 = OE_None;     /* EV: R-33326-45252 */}
-        break;
-      case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
-{yymsp[-2].minor.yy144 = 0;}
-        break;
-      case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
-      case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76);
-      case 173: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==173);
-{yymsp[-1].minor.yy144 = yymsp[0].minor.yy144;}
-        break;
-      case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
-      case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80);
-      case 219: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==219);
-      case 222: /* in_op ::= NOT IN */ yytestcase(yyruleno==222);
-      case 247: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==247);
-{yymsp[-1].minor.yy144 = 1;}
-        break;
-      case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
-{yymsp[-1].minor.yy144 = 0;}
-        break;
-      case 66: /* tconscomma ::= COMMA */
-{ASSERT_IS_CREATE; pParse->u1.cr.constraintName.n = 0;}
-        break;
-      case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
-{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy144,yymsp[-2].minor.yy144,0);}
-        break;
-      case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */
-{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy144,0,0,0,0,
-                                       SQLITE_IDXTYPE_UNIQUE);}
-        break;
-      case 70: /* tcons ::= CHECK LP expr RP onconf */
-{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy454,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.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy144);
-    sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy144);
-}
-        break;
-      case 73: /* onconf ::= */
-      case 75: /* orconf ::= */ yytestcase(yyruleno==75);
-{yymsp[1].minor.yy144 = OE_Default;}
-        break;
-      case 74: /* onconf ::= ON CONFLICT resolvetype */
-{yymsp[-2].minor.yy144 = yymsp[0].minor.yy144;}
-        break;
-      case 77: /* resolvetype ::= IGNORE */
-{yymsp[0].minor.yy144 = OE_Ignore;}
-        break;
-      case 78: /* resolvetype ::= REPLACE */
-      case 174: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==174);
-{yymsp[0].minor.yy144 = OE_Replace;}
-        break;
-      case 79: /* cmd ::= DROP TABLE ifexists fullname */
-{
-  sqlite3DropTable(pParse, yymsp[0].minor.yy203, 0, yymsp[-1].minor.yy144);
-}
-        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.yy14, yymsp[0].minor.yy555, yymsp[-7].minor.yy144, yymsp[-5].minor.yy144);
-}
-        break;
-      case 83: /* cmd ::= DROP VIEW ifexists fullname */
-{
-  sqlite3DropTable(pParse, yymsp[0].minor.yy203, 1, yymsp[-1].minor.yy144);
-}
-        break;
-      case 84: /* cmd ::= select */
-{
-  SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
-  if( (pParse->db->mDbFlags & DBFLAG_EncodingFixed)!=0
-   || sqlite3ReadSchema(pParse)==SQLITE_OK
-  ){
-    sqlite3Select(pParse, yymsp[0].minor.yy555, &dest);
-  }
-  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
-}
-        break;
-      case 85: /* select ::= WITH wqlist selectnowith */
-{yymsp[-2].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
-        break;
-      case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */
-{yymsp[-3].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
-        break;
-      case 87: /* select ::= selectnowith */
-{
-  Select *p = yymsp[0].minor.yy555;
-  if( p ){
-    parserDoubleLinkSelect(pParse, p);
-  }
-}
-        break;
-      case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */
-{
-  Select *pRhs = yymsp[0].minor.yy555;
-  Select *pLhs = yymsp[-2].minor.yy555;
-  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.yy144;
-    pRhs->pPrior = pLhs;
-    if( ALWAYS(pLhs) ) pLhs->selFlags &= ~(u32)SF_MultiValue;
-    pRhs->selFlags &= ~(u32)SF_MultiValue;
-    if( yymsp[-1].minor.yy144!=TK_ALL ) pParse->hasCompound = 1;
-  }else{
-    sqlite3SelectDelete(pParse->db, pLhs);
-  }
-  yymsp[-2].minor.yy555 = pRhs;
-}
-        break;
-      case 89: /* multiselect_op ::= UNION */
-      case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91);
-{yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-OP*/}
-        break;
-      case 90: /* multiselect_op ::= UNION ALL */
-{yymsp[-1].minor.yy144 = TK_ALL;}
-        break;
-      case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
-{
-  yymsp[-8].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy203,yymsp[-4].minor.yy454,yymsp[-3].minor.yy14,yymsp[-2].minor.yy454,yymsp[-1].minor.yy14,yymsp[-7].minor.yy144,yymsp[0].minor.yy454);
-}
-        break;
-      case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
-{
-  yymsp[-9].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy14,yymsp[-6].minor.yy203,yymsp[-5].minor.yy454,yymsp[-4].minor.yy14,yymsp[-3].minor.yy454,yymsp[-1].minor.yy14,yymsp[-8].minor.yy144,yymsp[0].minor.yy454);
-  if( yymsp[-9].minor.yy555 ){
-    yymsp[-9].minor.yy555->pWinDefn = yymsp[-2].minor.yy211;
-  }else{
-    sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy211);
-  }
-}
-        break;
-      case 94: /* values ::= VALUES LP nexprlist RP */
-{
-  yymsp[-3].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0);
-}
-        break;
-      case 95: /* oneselect ::= mvalues */
-{
-  sqlite3MultiValuesEnd(pParse, yymsp[0].minor.yy555);
-}
-        break;
-      case 96: /* mvalues ::= values COMMA LP nexprlist RP */
-      case 97: /* mvalues ::= mvalues COMMA LP nexprlist RP */ yytestcase(yyruleno==97);
-{
-  yymsp[-4].minor.yy555 = sqlite3MultiValues(pParse, yymsp[-4].minor.yy555, yymsp[-1].minor.yy14);
-}
-        break;
-      case 98: /* distinct ::= DISTINCT */
-{yymsp[0].minor.yy144 = SF_Distinct;}
-        break;
-      case 99: /* distinct ::= ALL */
-{yymsp[0].minor.yy144 = SF_All;}
-        break;
-      case 101: /* sclp ::= */
-      case 134: /* orderby_opt ::= */ yytestcase(yyruleno==134);
-      case 144: /* groupby_opt ::= */ yytestcase(yyruleno==144);
-      case 234: /* exprlist ::= */ yytestcase(yyruleno==234);
-      case 237: /* paren_exprlist ::= */ yytestcase(yyruleno==237);
-      case 242: /* eidlist_opt ::= */ yytestcase(yyruleno==242);
-{yymsp[1].minor.yy14 = 0;}
-        break;
-      case 102: /* selcollist ::= sclp scanpt expr scanpt as */
-{
-   yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
-   if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[0].minor.yy0, 1);
-   sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy14,yymsp[-3].minor.yy168,yymsp[-1].minor.yy168);
-}
-        break;
-      case 103: /* selcollist ::= sclp scanpt STAR */
-{
-  Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
-  sqlite3ExprSetErrorOffset(p, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
-  yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, p);
-}
-        break;
-      case 104: /* selcollist ::= sclp scanpt nm DOT STAR */
-{
-  Expr *pRight, *pLeft, *pDot;
-  pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
-  sqlite3ExprSetErrorOffset(pRight, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
-  pLeft = tokenExpr(pParse, TK_ID, yymsp[-2].minor.yy0);
-  pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
-  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, pDot);
-}
-        break;
-      case 105: /* as ::= AS nm */
-      case 117: /* dbnm ::= DOT nm */ yytestcase(yyruleno==117);
-      case 258: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==258);
-      case 259: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==259);
-{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
-        break;
-      case 107: /* from ::= */
-      case 110: /* stl_prefix ::= */ yytestcase(yyruleno==110);
-{yymsp[1].minor.yy203 = 0;}
-        break;
-      case 108: /* from ::= FROM seltablist */
-{
-  yymsp[-1].minor.yy203 = yymsp[0].minor.yy203;
-  sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy203);
-}
-        break;
-      case 109: /* stl_prefix ::= seltablist joinop */
-{
-   if( ALWAYS(yymsp[-1].minor.yy203 && yymsp[-1].minor.yy203->nSrc>0) ) yymsp[-1].minor.yy203->a[yymsp[-1].minor.yy203->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy144;
-}
-        break;
-      case 111: /* seltablist ::= stl_prefix nm dbnm as on_using */
-{
-  yymsp[-4].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy203,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
-}
-        break;
-      case 112: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
-{
-  yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy269);
-  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-1].minor.yy0);
-}
-        break;
-      case 113: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
-{
-  yymsp[-7].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy203,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
-  sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy203, yymsp[-3].minor.yy14);
-}
-        break;
-      case 114: /* seltablist ::= stl_prefix LP select RP as on_using */
-{
-    yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy555,&yymsp[0].minor.yy269);
-  }
-        break;
-      case 115: /* seltablist ::= stl_prefix LP seltablist RP as on_using */
-{
-    if( yymsp[-5].minor.yy203==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy269.pOn==0 && yymsp[0].minor.yy269.pUsing==0 ){
-      yymsp[-5].minor.yy203 = yymsp[-3].minor.yy203;
-    }else if( ALWAYS(yymsp[-3].minor.yy203!=0) && yymsp[-3].minor.yy203->nSrc==1 ){
-      yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
-      if( yymsp[-5].minor.yy203 ){
-        SrcItem *pNew = &yymsp[-5].minor.yy203->a[yymsp[-5].minor.yy203->nSrc-1];
-        SrcItem *pOld = yymsp[-3].minor.yy203->a;
-        assert( pOld->fg.fixedSchema==0 );
-        pNew->zName = pOld->zName;
-        assert( pOld->fg.fixedSchema==0 );
-        if( pOld->fg.isSubquery ){
-          pNew->fg.isSubquery = 1;
-          pNew->u4.pSubq = pOld->u4.pSubq;
-          pOld->u4.pSubq = 0;
-          pOld->fg.isSubquery = 0;
-          assert( pNew->u4.pSubq!=0 && pNew->u4.pSubq->pSelect!=0 );
-          if( (pNew->u4.pSubq->pSelect->selFlags & SF_NestedFrom)!=0 ){
-            pNew->fg.isNestedFrom = 1;
-          }
-        }else{
-          pNew->u4.zDatabase = pOld->u4.zDatabase;
-          pOld->u4.zDatabase = 0;
-        }
-        if( pOld->fg.isTabFunc ){
-          pNew->u1.pFuncArg = pOld->u1.pFuncArg;
-          pOld->u1.pFuncArg = 0;
-          pOld->fg.isTabFunc = 0;
-          pNew->fg.isTabFunc = 1;
-        }
-        pOld->zName = 0;
-      }
-      sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy203);
-    }else{
-      Select *pSubquery;
-      sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy203);
-      pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy203,0,0,0,0,SF_NestedFrom,0);
-      yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy269);
-    }
-  }
-        break;
-      case 116: /* dbnm ::= */
-      case 131: /* indexed_opt ::= */ yytestcase(yyruleno==131);
-{yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
-        break;
-      case 118: /* fullname ::= nm */
-      case 120: /* xfullname ::= nm */ yytestcase(yyruleno==120);
-{
-  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
-  if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
-}
-  yymsp[0].minor.yy203 = yylhsminor.yy203;
-        break;
-      case 119: /* fullname ::= nm DOT nm */
-      case 121: /* xfullname ::= nm DOT nm */ yytestcase(yyruleno==121);
-{
-  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
-  if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
-}
-  yymsp[-2].minor.yy203 = yylhsminor.yy203;
-        break;
-      case 122: /* xfullname ::= nm AS nm */
-{
-  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0);
-  if( yylhsminor.yy203 ){
-    if( IN_RENAME_OBJECT ){
-      sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[-2].minor.yy0);
-    }else{
-      yylhsminor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
-    }
-  }
-}
-  yymsp[-2].minor.yy203 = yylhsminor.yy203;
-        break;
-      case 123: /* xfullname ::= nm DOT nm AS nm */
-{
-  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0);
-  if( yylhsminor.yy203 ){
-    if( IN_RENAME_OBJECT ){
-      sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[-2].minor.yy0);
-    }else{
-      yylhsminor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
-    }
-  }
-}
-  yymsp[-4].minor.yy203 = yylhsminor.yy203;
-        break;
-      case 124: /* joinop ::= COMMA|JOIN */
-{ yymsp[0].minor.yy144 = JT_INNER; }
-        break;
-      case 125: /* joinop ::= JOIN_KW JOIN */
-{yymsp[-1].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0);  /*X-overwrites-A*/}
-        break;
-      case 126: /* joinop ::= JOIN_KW nm JOIN */
-{yymsp[-2].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
-        break;
-      case 127: /* joinop ::= JOIN_KW nm nm JOIN */
-{yymsp[-3].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
-        break;
-      case 128: /* on_using ::= ON expr */
-{yymsp[-1].minor.yy269.pOn = yymsp[0].minor.yy454; yymsp[-1].minor.yy269.pUsing = 0;}
-        break;
-      case 129: /* on_using ::= USING LP idlist RP */
-{yymsp[-3].minor.yy269.pOn = 0; yymsp[-3].minor.yy269.pUsing = yymsp[-1].minor.yy132;}
-        break;
-      case 130: /* on_using ::= */
-{yymsp[1].minor.yy269.pOn = 0; yymsp[1].minor.yy269.pUsing = 0;}
-        break;
-      case 132: /* indexed_by ::= INDEXED BY nm */
-{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
-        break;
-      case 133: /* indexed_by ::= NOT INDEXED */
-{yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
-        break;
-      case 135: /* orderby_opt ::= ORDER BY sortlist */
-      case 145: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==145);
-{yymsp[-2].minor.yy14 = yymsp[0].minor.yy14;}
-        break;
-      case 136: /* sortlist ::= sortlist COMMA expr sortorder nulls */
-{
-  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14,yymsp[-2].minor.yy454);
-  sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
-}
-        break;
-      case 137: /* sortlist ::= expr sortorder nulls */
-{
-  yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy454); /*A-overwrites-Y*/
-  sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
-}
-        break;
-      case 138: /* sortorder ::= ASC */
-{yymsp[0].minor.yy144 = SQLITE_SO_ASC;}
-        break;
-      case 139: /* sortorder ::= DESC */
-{yymsp[0].minor.yy144 = SQLITE_SO_DESC;}
-        break;
-      case 140: /* sortorder ::= */
-      case 143: /* nulls ::= */ yytestcase(yyruleno==143);
-{yymsp[1].minor.yy144 = SQLITE_SO_UNDEFINED;}
-        break;
-      case 141: /* nulls ::= NULLS FIRST */
-{yymsp[-1].minor.yy144 = SQLITE_SO_ASC;}
-        break;
-      case 142: /* nulls ::= NULLS LAST */
-{yymsp[-1].minor.yy144 = SQLITE_SO_DESC;}
-        break;
-      case 146: /* having_opt ::= */
-      case 148: /* limit_opt ::= */ yytestcase(yyruleno==148);
-      case 153: /* where_opt ::= */ yytestcase(yyruleno==153);
-      case 155: /* where_opt_ret ::= */ yytestcase(yyruleno==155);
-      case 232: /* case_else ::= */ yytestcase(yyruleno==232);
-      case 233: /* case_operand ::= */ yytestcase(yyruleno==233);
-      case 252: /* vinto ::= */ yytestcase(yyruleno==252);
-{yymsp[1].minor.yy454 = 0;}
-        break;
-      case 147: /* having_opt ::= HAVING expr */
-      case 154: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==154);
-      case 156: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==156);
-      case 231: /* case_else ::= ELSE expr */ yytestcase(yyruleno==231);
-      case 251: /* vinto ::= INTO expr */ yytestcase(yyruleno==251);
-{yymsp[-1].minor.yy454 = yymsp[0].minor.yy454;}
-        break;
-      case 149: /* limit_opt ::= LIMIT expr */
-{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,0);}
-        break;
-      case 150: /* limit_opt ::= LIMIT expr OFFSET expr */
-{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
-        break;
-      case 151: /* limit_opt ::= LIMIT expr COMMA expr */
-{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,yymsp[-2].minor.yy454);}
-        break;
-      case 152: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
-{
-  sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy203, &yymsp[-1].minor.yy0);
-  sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy203,yymsp[0].minor.yy454,0,0);
-}
-        break;
-      case 157: /* where_opt_ret ::= RETURNING selcollist */
-{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-1].minor.yy454 = 0;}
-        break;
-      case 158: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
-{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-3].minor.yy454 = yymsp[-2].minor.yy454;}
-        break;
-      case 159: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
-{
-  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-4].minor.yy0);
-  sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy14,"set list");
-  if( yymsp[-1].minor.yy203 ){
-    SrcList *pFromClause = yymsp[-1].minor.yy203;
-    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.yy203 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy203, pFromClause);
-  }
-  sqlite3Update(pParse,yymsp[-5].minor.yy203,yymsp[-2].minor.yy14,yymsp[0].minor.yy454,yymsp[-6].minor.yy144,0,0,0);
-}
-        break;
-      case 160: /* setlist ::= setlist COMMA nm EQ expr */
-{
-  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
-  sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, 1);
-}
-        break;
-      case 161: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
-{
-  yymsp[-6].minor.yy14 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy14, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
-}
-        break;
-      case 162: /* setlist ::= nm EQ expr */
-{
-  yylhsminor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy454);
-  sqlite3ExprListSetName(pParse, yylhsminor.yy14, &yymsp[-2].minor.yy0, 1);
-}
-  yymsp[-2].minor.yy14 = yylhsminor.yy14;
-        break;
-      case 163: /* setlist ::= LP idlist RP EQ expr */
-{
-  yymsp[-4].minor.yy14 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
-}
-        break;
-      case 164: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
-{
-  sqlite3Insert(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy555, yymsp[-2].minor.yy132, yymsp[-5].minor.yy144, yymsp[0].minor.yy122);
-}
-        break;
-      case 165: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
-{
-  sqlite3Insert(pParse, yymsp[-4].minor.yy203, 0, yymsp[-3].minor.yy132, yymsp[-6].minor.yy144, 0);
-}
-        break;
-      case 166: /* upsert ::= */
-{ yymsp[1].minor.yy122 = 0; }
-        break;
-      case 167: /* upsert ::= RETURNING selcollist */
-{ yymsp[-1].minor.yy122 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy14); }
-        break;
-      case 168: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
-{ yymsp[-11].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy14,yymsp[-6].minor.yy454,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,yymsp[0].minor.yy122);}
-        break;
-      case 169: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
-{ yymsp[-8].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy14,yymsp[-3].minor.yy454,0,0,yymsp[0].minor.yy122); }
-        break;
-      case 170: /* upsert ::= ON CONFLICT DO NOTHING returning */
-{ yymsp[-4].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
-        break;
-      case 171: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
-{ yymsp[-7].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,0);}
-        break;
-      case 172: /* returning ::= RETURNING selcollist */
-{sqlite3AddReturning(pParse,yymsp[0].minor.yy14);}
-        break;
-      case 175: /* idlist_opt ::= */
-{yymsp[1].minor.yy132 = 0;}
-        break;
-      case 176: /* idlist_opt ::= LP idlist RP */
-{yymsp[-2].minor.yy132 = yymsp[-1].minor.yy132;}
-        break;
-      case 177: /* idlist ::= idlist COMMA nm */
-{yymsp[-2].minor.yy132 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy132,&yymsp[0].minor.yy0);}
-        break;
-      case 178: /* idlist ::= nm */
-{yymsp[0].minor.yy132 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
-        break;
-      case 179: /* expr ::= LP expr RP */
-{yymsp[-2].minor.yy454 = yymsp[-1].minor.yy454;}
-        break;
-      case 180: /* expr ::= ID|INDEXED|JOIN_KW */
-{yymsp[0].minor.yy454=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
-        break;
-      case 181: /* 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.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
-}
-  yymsp[-2].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 182: /* 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.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
-}
-  yymsp[-4].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 183: /* term ::= NULL|FLOAT|BLOB */
-      case 184: /* term ::= STRING */ yytestcase(yyruleno==184);
-{yymsp[0].minor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
-        break;
-      case 185: /* term ::= INTEGER */
-{
-  int iValue;
-  if( sqlite3GetInt32(yymsp[0].minor.yy0.z, &iValue)==0 ){
-    yylhsminor.yy454 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 0);
-  }else{
-    yylhsminor.yy454 = sqlite3ExprInt32(pParse->db, iValue);
-  }
-  if( yylhsminor.yy454 ) yylhsminor.yy454->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail);
-}
-  yymsp[0].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 186: /* 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.yy454 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
-    sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy454, 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 ){
-      parserSyntaxError(pParse, &t);
-      yymsp[0].minor.yy454 = 0;
-    }else{
-      yymsp[0].minor.yy454 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
-      if( yymsp[0].minor.yy454 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy454->iTable);
-    }
-  }
-}
-        break;
-      case 187: /* expr ::= expr COLLATE ID|STRING */
-{
-  yymsp[-2].minor.yy454 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy454, &yymsp[0].minor.yy0, 1);
-}
-        break;
-      case 188: /* expr ::= CAST LP expr AS typetoken RP */
-{
-  yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
-  sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy454, yymsp[-3].minor.yy454, 0);
-}
-        break;
-      case 189: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
-{
-  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy144);
-}
-  yymsp[-4].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 190: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
-{
-  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy14, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy144);
-  sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-1].minor.yy14);
-}
-  yymsp[-7].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 191: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
-{
-  yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
-}
-  yymsp[-3].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 192: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
-{
-  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy14, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy144);
-  sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
-}
-  yymsp[-5].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 193: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
-{
-  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy14, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy144);
-  sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
-  sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-2].minor.yy14);
-}
-  yymsp[-8].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 194: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
-{
-  yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
-  sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
-}
-  yymsp[-4].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 195: /* term ::= CTIME_KW */
-{
-  yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
-}
-  yymsp[0].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 196: /* expr ::= LP nexprlist COMMA expr RP */
-{
-  ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454);
-  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
-  if( yymsp[-4].minor.yy454 ){
-    yymsp[-4].minor.yy454->x.pList = pList;
-    if( ALWAYS(pList->nExpr) ){
-      yymsp[-4].minor.yy454->flags |= pList->a[0].pExpr->flags & EP_Propagate;
-    }
-  }else{
-    sqlite3ExprListDelete(pParse->db, pList);
-  }
-}
-        break;
-      case 197: /* expr ::= expr AND expr */
-{yymsp[-2].minor.yy454=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
-        break;
-      case 198: /* expr ::= expr OR expr */
-      case 199: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==199);
-      case 200: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==200);
-      case 201: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==201);
-      case 202: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==202);
-      case 203: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==203);
-      case 204: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==204);
-{yymsp[-2].minor.yy454=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
-        break;
-      case 205: /* 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 206: /* 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.yy454);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy454);
-  yymsp[-2].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
-  if( bNot ) yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy454, 0);
-  if( yymsp[-2].minor.yy454 ) yymsp[-2].minor.yy454->flags |= EP_InfixFunc;
-}
-        break;
-      case 207: /* 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.yy454);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy454);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
-  yymsp[-4].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
-  if( bNot ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
-  if( yymsp[-4].minor.yy454 ) yymsp[-4].minor.yy454->flags |= EP_InfixFunc;
-}
-        break;
-      case 208: /* expr ::= expr ISNULL|NOTNULL */
-{yymsp[-1].minor.yy454 = sqlite3PExprIsNull(pParse,yymsp[0].major,yymsp[-1].minor.yy454);}
-        break;
-      case 209: /* expr ::= expr NOT NULL */
-{yymsp[-2].minor.yy454 = sqlite3PExprIsNull(pParse,TK_NOTNULL,yymsp[-2].minor.yy454);}
-        break;
-      case 210: /* expr ::= expr IS expr */
-{
-  yymsp[-2].minor.yy454 = sqlite3PExprIs(pParse, TK_IS, yymsp[-2].minor.yy454, yymsp[0].minor.yy454);
-}
-        break;
-      case 211: /* expr ::= expr IS NOT expr */
-{
-  yymsp[-3].minor.yy454 = sqlite3PExprIs(pParse, TK_ISNOT, yymsp[-3].minor.yy454, yymsp[0].minor.yy454);
-}
-        break;
-      case 212: /* expr ::= expr IS NOT DISTINCT FROM expr */
-{
-  yymsp[-5].minor.yy454 = sqlite3PExprIs(pParse, TK_IS, yymsp[-5].minor.yy454, yymsp[0].minor.yy454);
-}
-        break;
-      case 213: /* expr ::= expr IS DISTINCT FROM expr */
-{
-  yymsp[-4].minor.yy454 = sqlite3PExprIs(pParse, TK_ISNOT, yymsp[-4].minor.yy454, yymsp[0].minor.yy454);
-}
-        break;
-      case 214: /* expr ::= NOT expr */
-      case 215: /* expr ::= BITNOT expr */ yytestcase(yyruleno==215);
-{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy454, 0);/*A-overwrites-B*/}
-        break;
-      case 216: /* expr ::= PLUS|MINUS expr */
-{
-  Expr *p = yymsp[0].minor.yy454;
-  u8 op = yymsp[-1].major + (TK_UPLUS-TK_PLUS);
-  assert( TK_UPLUS>TK_PLUS );
-  assert( TK_UMINUS == TK_MINUS + (TK_UPLUS - TK_PLUS) );
-  if( p && p->op==TK_UPLUS ){
-    p->op = op;
-    yymsp[-1].minor.yy454 = p;
-  }else{
-    yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, op, p, 0);
-    /*A-overwrites-B*/
-  }
-}
-        break;
-      case 217: /* expr ::= expr PTR expr */
-{
-  ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy454);
-  pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy454);
-  yylhsminor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
-}
-  yymsp[-2].minor.yy454 = yylhsminor.yy454;
-        break;
-      case 218: /* between_op ::= BETWEEN */
-      case 221: /* in_op ::= IN */ yytestcase(yyruleno==221);
-{yymsp[0].minor.yy144 = 0;}
-        break;
-      case 220: /* expr ::= expr between_op expr AND expr */
-{
-  ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
-  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy454, 0);
-  if( yymsp[-4].minor.yy454 ){
-    yymsp[-4].minor.yy454->x.pList = pList;
-    sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
-  }else{
-    sqlite3ExprListDelete(pParse->db, pList);
-  }
-  if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
-}
-        break;
-      case 223: /* expr ::= expr in_op LP exprlist RP */
-{
-    if( yymsp[-1].minor.yy14==0 ){
-      /* Expressions of the form
-      **
-      **      expr1 IN ()
-      **      expr1 NOT IN ()
-      **
-      ** simplify to constants 0 (false) and 1 (true), respectively.
-      **
-      ** Except, do not apply this optimization if expr1 contains a function
-      ** because that function might be an aggregate (we don't know yet whether
-      ** it is or not) and if it is an aggregate, that could change the meaning
-      ** of the whole query.
-      */
-      Expr *pB = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy144 ? "true" : "false");
-      if( pB ) sqlite3ExprIdToTrueFalse(pB);
-      if( !ExprHasProperty(yymsp[-4].minor.yy454, EP_HasFunc) ){
-        sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy454);
-        yymsp[-4].minor.yy454 = pB;
-      }else{
-        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, yymsp[-3].minor.yy144 ? TK_OR : TK_AND, pB, yymsp[-4].minor.yy454);
-      }
-    }else{
-      Expr *pRHS = yymsp[-1].minor.yy14->a[0].pExpr;
-      if( yymsp[-1].minor.yy14->nExpr==1 && sqlite3ExprIsConstant(pParse,pRHS) && yymsp[-4].minor.yy454->op!=TK_VECTOR ){
-        yymsp[-1].minor.yy14->a[0].pExpr = 0;
-        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
-        pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
-        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy454, pRHS);
-      }else if( yymsp[-1].minor.yy14->nExpr==1 && pRHS->op==TK_SELECT ){
-        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
-        sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pRHS->x.pSelect);
-        pRHS->x.pSelect = 0;
-        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
-      }else{
-        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
-        if( yymsp[-4].minor.yy454==0 ){
-          sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
-        }else if( yymsp[-4].minor.yy454->pLeft->op==TK_VECTOR ){
-          int nExpr = yymsp[-4].minor.yy454->pLeft->x.pList->nExpr;
-          Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy14);
-          if( pSelectRHS ){
-            parserDoubleLinkSelect(pParse, pSelectRHS);
-            sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelectRHS);
-          }
-        }else{
-          yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy14;
-          sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
-        }
-      }
-      if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
-    }
-  }
-        break;
-      case 224: /* expr ::= LP select RP */
-{
-    yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
-    sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy454, yymsp[-1].minor.yy555);
-  }
-        break;
-      case 225: /* expr ::= expr in_op LP select RP */
-{
-    yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
-    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, yymsp[-1].minor.yy555);
-    if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
-  }
-        break;
-      case 226: /* 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.yy14 )  sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy14);
-    yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
-    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelect);
-    if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
-  }
-        break;
-      case 227: /* expr ::= EXISTS LP select RP */
-{
-    Expr *p;
-    p = yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
-    sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy555);
-  }
-        break;
-      case 228: /* expr ::= CASE case_operand case_exprlist case_else END */
-{
-  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy454, 0);
-  if( yymsp[-4].minor.yy454 ){
-    yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy454 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454) : yymsp[-2].minor.yy14;
-    sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
-  }else{
-    sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
-    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
-  }
-}
-        break;
-      case 229: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
-{
-  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
-  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
-}
-        break;
-      case 230: /* case_exprlist ::= WHEN expr THEN expr */
-{
-  yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
-  yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, yymsp[0].minor.yy454);
-}
-        break;
-      case 235: /* nexprlist ::= nexprlist COMMA expr */
-{yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy454);}
-        break;
-      case 236: /* nexprlist ::= expr */
-{yymsp[0].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy454); /*A-overwrites-Y*/}
-        break;
-      case 238: /* paren_exprlist ::= LP exprlist RP */
-      case 243: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==243);
-{yymsp[-2].minor.yy14 = yymsp[-1].minor.yy14;}
-        break;
-      case 239: /* 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.yy14, yymsp[-10].minor.yy144,
-                      &yymsp[-11].minor.yy0, yymsp[0].minor.yy454, SQLITE_SO_ASC, yymsp[-8].minor.yy144, SQLITE_IDXTYPE_APPDEF);
-  if( IN_RENAME_OBJECT && pParse->pNewIndex ){
-    sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
-  }
-}
-        break;
-      case 240: /* uniqueflag ::= UNIQUE */
-      case 281: /* raisetype ::= ABORT */ yytestcase(yyruleno==281);
-{yymsp[0].minor.yy144 = OE_Abort;}
-        break;
-      case 241: /* uniqueflag ::= */
-{yymsp[1].minor.yy144 = OE_None;}
-        break;
-      case 244: /* eidlist ::= eidlist COMMA nm collate sortorder */
-{
-  yymsp[-4].minor.yy14 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144);
-}
-        break;
-      case 245: /* eidlist ::= nm collate sortorder */
-{
-  yymsp[-2].minor.yy14 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144); /*A-overwrites-Y*/
-}
-        break;
-      case 248: /* cmd ::= DROP INDEX ifexists fullname */
-{sqlite3DropIndex(pParse, yymsp[0].minor.yy203, yymsp[-1].minor.yy144);}
-        break;
-      case 249: /* cmd ::= VACUUM vinto */
-{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy454);}
-        break;
-      case 250: /* cmd ::= VACUUM nm vinto */
-{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy454);}
-        break;
-      case 253: /* cmd ::= PRAGMA nm dbnm */
-{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
-        break;
-      case 254: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
-{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
-        break;
-      case 255: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
-{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
-        break;
-      case 256: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
-{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
-        break;
-      case 257: /* 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 260: /* 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.yy427, &all);
-}
-        break;
-      case 261: /* 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.yy144, yymsp[-4].minor.yy286.a, yymsp[-4].minor.yy286.b, yymsp[-2].minor.yy203, yymsp[0].minor.yy454, yymsp[-10].minor.yy144, yymsp[-8].minor.yy144);
-  yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/
-#ifdef SQLITE_DEBUG
-  assert( pParse->isCreate ); /* Set by createkw reduce action */
-  pParse->isCreate = 0;       /* But, should not be set for CREATE TRIGGER */
-#endif
-}
-        break;
-      case 262: /* trigger_time ::= BEFORE|AFTER */
-{ yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/ }
-        break;
-      case 263: /* trigger_time ::= INSTEAD OF */
-{ yymsp[-1].minor.yy144 = TK_INSTEAD;}
-        break;
-      case 264: /* trigger_time ::= */
-{ yymsp[1].minor.yy144 = TK_BEFORE; }
-        break;
-      case 265: /* trigger_event ::= DELETE|INSERT */
-      case 266: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==266);
-{yymsp[0].minor.yy286.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy286.b = 0;}
-        break;
-      case 267: /* trigger_event ::= UPDATE OF idlist */
-{yymsp[-2].minor.yy286.a = TK_UPDATE; yymsp[-2].minor.yy286.b = yymsp[0].minor.yy132;}
-        break;
-      case 268: /* when_clause ::= */
-      case 286: /* key_opt ::= */ yytestcase(yyruleno==286);
-{ yymsp[1].minor.yy454 = 0; }
-        break;
-      case 269: /* when_clause ::= WHEN expr */
-      case 287: /* key_opt ::= KEY expr */ yytestcase(yyruleno==287);
-{ yymsp[-1].minor.yy454 = yymsp[0].minor.yy454; }
-        break;
-      case 270: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
-{
-  yymsp[-2].minor.yy427->pLast->pNext = yymsp[-1].minor.yy427;
-  yymsp[-2].minor.yy427->pLast = yymsp[-1].minor.yy427;
-}
-        break;
-      case 271: /* trigger_cmd_list ::= trigger_cmd SEMI */
-{
-  yymsp[-1].minor.yy427->pLast = yymsp[-1].minor.yy427;
-}
-        break;
-      case 272: /* tridxby ::= INDEXED BY nm */
-{
-  sqlite3ErrorMsg(pParse,
-        "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
-        "within triggers");
-}
-        break;
-      case 273: /* tridxby ::= NOT INDEXED */
-{
-  sqlite3ErrorMsg(pParse,
-        "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
-        "within triggers");
-}
-        break;
-      case 274: /* trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt */
-{yylhsminor.yy427 = sqlite3TriggerUpdateStep(pParse, yymsp[-6].minor.yy203, yymsp[-2].minor.yy203, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454, yymsp[-7].minor.yy144, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy168);}
-  yymsp[-8].minor.yy427 = yylhsminor.yy427;
-        break;
-      case 275: /* trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt */
-{
-   yylhsminor.yy427 = sqlite3TriggerInsertStep(pParse,yymsp[-4].minor.yy203,yymsp[-3].minor.yy132,yymsp[-2].minor.yy555,yymsp[-6].minor.yy144,yymsp[-1].minor.yy122,yymsp[-7].minor.yy168,yymsp[0].minor.yy168);/*yylhsminor.yy427-overwrites-yymsp[-6].minor.yy144*/
-}
-  yymsp[-7].minor.yy427 = yylhsminor.yy427;
-        break;
-      case 276: /* trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt */
-{yylhsminor.yy427 = sqlite3TriggerDeleteStep(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy454, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy168);}
-  yymsp[-5].minor.yy427 = yylhsminor.yy427;
-        break;
-      case 277: /* trigger_cmd ::= scanpt select scanpt */
-{yylhsminor.yy427 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy555, yymsp[-2].minor.yy168, yymsp[0].minor.yy168); /*yylhsminor.yy427-overwrites-yymsp[-1].minor.yy555*/}
-  yymsp[-2].minor.yy427 = yylhsminor.yy427;
-        break;
-      case 278: /* expr ::= RAISE LP IGNORE RP */
-{
-  yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
-  if( yymsp[-3].minor.yy454 ){
-    yymsp[-3].minor.yy454->affExpr = OE_Ignore;
-  }
-}
-        break;
-      case 279: /* expr ::= RAISE LP raisetype COMMA expr RP */
-{
-  yymsp[-5].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, yymsp[-1].minor.yy454, 0);
-  if( yymsp[-5].minor.yy454 ) {
-    yymsp[-5].minor.yy454->affExpr = (char)yymsp[-3].minor.yy144;
-  }
-}
-        break;
-      case 280: /* raisetype ::= ROLLBACK */
-{yymsp[0].minor.yy144 = OE_Rollback;}
-        break;
-      case 282: /* raisetype ::= FAIL */
-{yymsp[0].minor.yy144 = OE_Fail;}
-        break;
-      case 283: /* cmd ::= DROP TRIGGER ifexists fullname */
-{
-  sqlite3DropTrigger(pParse,yymsp[0].minor.yy203,yymsp[-1].minor.yy144);
-}
-        break;
-      case 284: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
-{
-  sqlite3Attach(pParse, yymsp[-3].minor.yy454, yymsp[-1].minor.yy454, yymsp[0].minor.yy454);
-}
-        break;
-      case 285: /* cmd ::= DETACH database_kw_opt expr */
-{
-  sqlite3Detach(pParse, yymsp[0].minor.yy454);
-}
-        break;
-      case 288: /* cmd ::= REINDEX */
-{sqlite3Reindex(pParse, 0, 0);}
-        break;
-      case 289: /* cmd ::= REINDEX nm dbnm */
-{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
-        break;
-      case 290: /* cmd ::= ANALYZE */
-{sqlite3Analyze(pParse, 0, 0);}
-        break;
-      case 291: /* cmd ::= ANALYZE nm dbnm */
-{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
-        break;
-      case 292: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
-{
-  sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy203,&yymsp[0].minor.yy0);
-}
-        break;
-      case 293: /* cmd ::= alter_add 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 294: /* alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */
-{
-  disableLookaside(pParse);
-  sqlite3AlterBeginAddColumn(pParse, yymsp[-4].minor.yy203);
-  sqlite3AddColumn(pParse, yymsp[-1].minor.yy0, yymsp[0].minor.yy0);
-  yymsp[-6].minor.yy0 = yymsp[-1].minor.yy0;
-}
-        break;
-      case 295: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
-{
-  sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0);
-}
-        break;
-      case 296: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
-{
-  sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy203, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
-}
-        break;
-      case 297: /* cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */
-{
-  sqlite3AlterDropConstraint(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0, 0);
-}
-        break;
-      case 298: /* cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */
-{
-  sqlite3AlterDropConstraint(pParse, yymsp[-6].minor.yy203, 0, &yymsp[-3].minor.yy0);
-}
-        break;
-      case 299: /* cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */
-{
-  sqlite3AlterSetNotNull(pParse, yymsp[-7].minor.yy203, &yymsp[-4].minor.yy0, &yymsp[-2].minor.yy0);
-}
-        break;
-      case 300: /* cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */
-{
-  sqlite3AlterAddConstraint(pParse, yymsp[-8].minor.yy203, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy0.z+1, (yymsp[-1].minor.yy0.z-yymsp[-3].minor.yy0.z-1));
-}
-  yy_destructor(yypParser,219,&yymsp[-2].minor);
-        break;
-      case 301: /* cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */
-{
-  sqlite3AlterAddConstraint(pParse, yymsp[-6].minor.yy203, &yymsp[-4].minor.yy0, 0, yymsp[-3].minor.yy0.z+1, (yymsp[-1].minor.yy0.z-yymsp[-3].minor.yy0.z-1));
-}
-  yy_destructor(yypParser,219,&yymsp[-2].minor);
-        break;
-      case 302: /* cmd ::= create_vtab */
-{sqlite3VtabFinishParse(pParse,0);}
-        break;
-      case 303: /* cmd ::= create_vtab LP vtabarglist RP */
-{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
-        break;
-      case 304: /* 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.yy144);
-}
-        break;
-      case 305: /* vtabarg ::= */
-{sqlite3VtabArgInit(pParse);}
-        break;
-      case 306: /* vtabargtoken ::= ANY */
-      case 307: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==307);
-      case 308: /* lp ::= LP */ yytestcase(yyruleno==308);
-{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
-        break;
-      case 309: /* with ::= WITH wqlist */
-      case 310: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==310);
-{ sqlite3WithPush(pParse, yymsp[0].minor.yy59, 1); }
-        break;
-      case 311: /* wqas ::= AS */
-{yymsp[0].minor.yy462 = M10d_Any;}
-        break;
-      case 312: /* wqas ::= AS MATERIALIZED */
-{yymsp[-1].minor.yy462 = M10d_Yes;}
-        break;
-      case 313: /* wqas ::= AS NOT MATERIALIZED */
-{yymsp[-2].minor.yy462 = M10d_No;}
-        break;
-      case 314: /* wqitem ::= withnm eidlist_opt wqas LP select RP */
-{
-  yymsp[-5].minor.yy67 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy555, yymsp[-3].minor.yy462); /*A-overwrites-X*/
-}
-        break;
-      case 315: /* withnm ::= nm */
-{pParse->bHasWith = 1;}
-        break;
-      case 316: /* wqlist ::= wqitem */
-{
-  yymsp[0].minor.yy59 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy67); /*A-overwrites-X*/
-}
-        break;
-      case 317: /* wqlist ::= wqlist COMMA wqitem */
-{
-  yymsp[-2].minor.yy59 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy59, yymsp[0].minor.yy67);
-}
-        break;
-      case 318: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
-{
-  assert( yymsp[0].minor.yy211!=0 );
-  sqlite3WindowChain(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy211);
-  yymsp[0].minor.yy211->pNextWin = yymsp[-2].minor.yy211;
-  yylhsminor.yy211 = yymsp[0].minor.yy211;
-}
-  yymsp[-2].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 319: /* windowdefn ::= nm AS LP window RP */
-{
-  if( ALWAYS(yymsp[-1].minor.yy211) ){
-    yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
-  }
-  yylhsminor.yy211 = yymsp[-1].minor.yy211;
-}
-  yymsp[-4].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 320: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
-{
-  yymsp[-4].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, 0);
-}
-        break;
-      case 321: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
-{
-  yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, &yymsp[-5].minor.yy0);
-}
-  yymsp[-5].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 322: /* window ::= ORDER BY sortlist frame_opt */
-{
-  yymsp[-3].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, 0);
-}
-        break;
-      case 323: /* window ::= nm ORDER BY sortlist frame_opt */
-{
-  yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
-}
-  yymsp[-4].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 324: /* window ::= nm frame_opt */
-{
-  yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, 0, &yymsp[-1].minor.yy0);
-}
-  yymsp[-1].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 325: /* frame_opt ::= */
-{
-  yymsp[1].minor.yy211 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
-}
-        break;
-      case 326: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
-{
-  yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy144, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy462);
-}
-  yymsp[-2].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 327: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
-{
-  yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy144, yymsp[-3].minor.yy509.eType, yymsp[-3].minor.yy509.pExpr, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, yymsp[0].minor.yy462);
-}
-  yymsp[-5].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 329: /* frame_bound_s ::= frame_bound */
-      case 331: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==331);
-{yylhsminor.yy509 = yymsp[0].minor.yy509;}
-  yymsp[0].minor.yy509 = yylhsminor.yy509;
-        break;
-      case 330: /* frame_bound_s ::= UNBOUNDED PRECEDING */
-      case 332: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==332);
-      case 334: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==334);
-{yylhsminor.yy509.eType = yymsp[-1].major; yylhsminor.yy509.pExpr = 0;}
-  yymsp[-1].minor.yy509 = yylhsminor.yy509;
-        break;
-      case 333: /* frame_bound ::= expr PRECEDING|FOLLOWING */
-{yylhsminor.yy509.eType = yymsp[0].major; yylhsminor.yy509.pExpr = yymsp[-1].minor.yy454;}
-  yymsp[-1].minor.yy509 = yylhsminor.yy509;
-        break;
-      case 335: /* frame_exclude_opt ::= */
-{yymsp[1].minor.yy462 = 0;}
-        break;
-      case 336: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
-{yymsp[-1].minor.yy462 = yymsp[0].minor.yy462;}
-        break;
-      case 337: /* frame_exclude ::= NO OTHERS */
-      case 338: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==338);
-{yymsp[-1].minor.yy462 = yymsp[-1].major; /*A-overwrites-X*/}
-        break;
-      case 339: /* frame_exclude ::= GROUP|TIES */
-{yymsp[0].minor.yy462 = yymsp[0].major; /*A-overwrites-X*/}
-        break;
-      case 340: /* window_clause ::= WINDOW windowdefn_list */
-{ yymsp[-1].minor.yy211 = yymsp[0].minor.yy211; }
-        break;
-      case 341: /* filter_over ::= filter_clause over_clause */
-{
-  if( yymsp[0].minor.yy211 ){
-    yymsp[0].minor.yy211->pFilter = yymsp[-1].minor.yy454;
-  }else{
-    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
-  }
-  yylhsminor.yy211 = yymsp[0].minor.yy211;
-}
-  yymsp[-1].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 342: /* filter_over ::= over_clause */
-{
-  yylhsminor.yy211 = yymsp[0].minor.yy211;
-}
-  yymsp[0].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 343: /* filter_over ::= filter_clause */
-{
-  yylhsminor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
-  if( yylhsminor.yy211 ){
-    yylhsminor.yy211->eFrmType = TK_FILTER;
-    yylhsminor.yy211->pFilter = yymsp[0].minor.yy454;
-  }else{
-    sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy454);
-  }
-}
-  yymsp[0].minor.yy211 = yylhsminor.yy211;
-        break;
-      case 344: /* over_clause ::= OVER LP window RP */
-{
-  yymsp[-3].minor.yy211 = yymsp[-1].minor.yy211;
-  assert( yymsp[-3].minor.yy211!=0 );
-}
-        break;
-      case 345: /* over_clause ::= OVER nm */
-{
-  yymsp[-1].minor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
-  if( yymsp[-1].minor.yy211 ){
-    yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
-  }
-}
-        break;
-      case 346: /* filter_clause ::= FILTER LP WHERE expr RP */
-{ yymsp[-4].minor.yy454 = yymsp[-1].minor.yy454; }
-        break;
-      case 347: /* term ::= QNUMBER */
-{
-  yylhsminor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0);
-  sqlite3DequoteNumber(pParse, yylhsminor.yy454);
-}
-  yymsp[0].minor.yy454 = yylhsminor.yy454;
-        break;
-      default:
-      /* (348) input ::= cmdlist */ yytestcase(yyruleno==348);
-      /* (349) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==349);
-      /* (350) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=350);
-      /* (351) ecmd ::= SEMI */ yytestcase(yyruleno==351);
-      /* (352) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==352);
-      /* (353) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=353);
-      /* (354) trans_opt ::= */ yytestcase(yyruleno==354);
-      /* (355) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==355);
-      /* (356) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==356);
-      /* (357) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==357);
-      /* (358) savepoint_opt ::= */ yytestcase(yyruleno==358);
-      /* (359) cmd ::= create_table create_table_args */ yytestcase(yyruleno==359);
-      /* (360) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=360);
-      /* (361) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==361);
-      /* (362) columnlist ::= columnname carglist */ yytestcase(yyruleno==362);
-      /* (363) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==363);
-      /* (364) nm ::= STRING */ yytestcase(yyruleno==364);
-      /* (365) typetoken ::= typename */ yytestcase(yyruleno==365);
-      /* (366) typename ::= ID|STRING */ yytestcase(yyruleno==366);
-      /* (367) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=367);
-      /* (368) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=368);
-      /* (369) carglist ::= carglist ccons */ yytestcase(yyruleno==369);
-      /* (370) carglist ::= */ yytestcase(yyruleno==370);
-      /* (371) ccons ::= NULL onconf */ yytestcase(yyruleno==371);
-      /* (372) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==372);
-      /* (373) ccons ::= AS generated */ yytestcase(yyruleno==373);
-      /* (374) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==374);
-      /* (375) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==375);
-      /* (376) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=376);
-      /* (377) tconscomma ::= */ yytestcase(yyruleno==377);
-      /* (378) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=378);
-      /* (379) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=379);
-      /* (380) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=380);
-      /* (381) oneselect ::= values */ yytestcase(yyruleno==381);
-      /* (382) sclp ::= selcollist COMMA */ yytestcase(yyruleno==382);
-      /* (383) as ::= ID|STRING */ yytestcase(yyruleno==383);
-      /* (384) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=384);
-      /* (385) returning ::= */ yytestcase(yyruleno==385);
-      /* (386) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=386);
-      /* (387) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==387);
-      /* (388) case_operand ::= expr */ yytestcase(yyruleno==388);
-      /* (389) exprlist ::= nexprlist */ yytestcase(yyruleno==389);
-      /* (390) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=390);
-      /* (391) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=391);
-      /* (392) nmnum ::= ON */ yytestcase(yyruleno==392);
-      /* (393) nmnum ::= DELETE */ yytestcase(yyruleno==393);
-      /* (394) nmnum ::= DEFAULT */ yytestcase(yyruleno==394);
-      /* (395) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==395);
-      /* (396) foreach_clause ::= */ yytestcase(yyruleno==396);
-      /* (397) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==397);
-      /* (398) tridxby ::= */ yytestcase(yyruleno==398);
-      /* (399) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==399);
-      /* (400) database_kw_opt ::= */ yytestcase(yyruleno==400);
-      /* (401) kwcolumn_opt ::= */ yytestcase(yyruleno==401);
-      /* (402) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==402);
-      /* (403) vtabarglist ::= vtabarg */ yytestcase(yyruleno==403);
-      /* (404) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==404);
-      /* (405) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==405);
-      /* (406) anylist ::= */ yytestcase(yyruleno==406);
-      /* (407) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==407);
-      /* (408) anylist ::= anylist ANY */ yytestcase(yyruleno==408);
-      /* (409) with ::= */ yytestcase(yyruleno==409);
-      /* (410) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=410);
-      /* (411) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=411);
-        break;
-/********** End reduce actions ************************************************/
-  };
-  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
-  yygoto = yyRuleInfoLhs[yyruleno];
-  yysize = yyRuleInfoNRhs[yyruleno];
-  yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
-
-  /* There are no SHIFTREDUCE actions on nonterminals because the table
-  ** generator has simplified them to pure REDUCE actions. */
-  assert( !(yyact>YY_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] ){
-    parserSyntaxError(pParse, &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:
-** <ul>
-** <li> A pointer to the parser (an opaque structure.)
-** <li> The major token number.
-** <li> The minor token number.
-** <li> An option argument of a grammar-specified type.
-** </ul>
-**
-** 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],
-            yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
-            yypParser->yytos[yysize].stateno);
-        }else{
-          fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
-            yyTracePrompt, yyruleno, yyRuleName[yyruleno],
-            yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
-        }
-      }
-#endif /* NDEBUG */
-
-      /* Check that the stack is large enough to grow by a single entry
-      ** if the RHS of the rule is empty.  This ensures that there is room
-      ** enough on the stack to push the LHS value */
-      if( yyRuleInfoNRhs[yyruleno]==0 ){
-#ifdef YYTRACKMAXSTACKDEPTH
-        if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
-          yypParser->yyhwm++;
-          assert( yypParser->yyhwm ==
-                  (int)(yypParser->yytos - yypParser->yystack));
-        }
-#endif
-        if( yypParser->yytos>=yypParser->yystackEnd ){
-          if( yyGrowStack(yypParser) ){
-            yyStackOverflow(yypParser);
-            break;
-          }
-        }
-      }
-      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 <stdlib.h> */
-
-/* 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 i64 keywordCode(const char *z, i64 n, int *pType){
-  i64 i, j;
-  const char *zKW;
-  assert( 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<n && (z[j]&~0x20)==zKW[j] ){ j++; }
-#endif
-#ifdef SQLITE_EBCDIC
-    if( toupper(z[0])!=zKW[0] ) continue;
-    if( toupper(z[1])!=zKW[1] ) continue;
-    j = 2;
-    while( j<n && toupper(z[j])==zKW[j] ){ j++; }
-#endif
-    if( j<n ) continue;
-    testcase( i==1 ); /* REINDEX */
-    testcase( i==2 ); /* INDEXED */
-    testcase( i==3 ); /* INDEX */
-    testcase( i==4 ); /* DESC */
-    testcase( i==5 ); /* ESCAPE */
-    testcase( i==6 ); /* EACH */
-    testcase( i==7 ); /* CHECK */
-    testcase( i==8 ); /* KEY */
-    testcase( i==9 ); /* BEFORE */
-    testcase( i==10 ); /* FOREIGN */
-    testcase( i==11 ); /* FOR */
-    testcase( i==12 ); /* IGNORE */
-    testcase( i==13 ); /* REGEXP */
-    testcase( i==14 ); /* EXPLAIN */
-    testcase( i==15 ); /* INSTEAD */
-    testcase( i==16 ); /* ADD */
-    testcase( i==17 ); /* DATABASE */
-    testcase( i==18 ); /* AS */
-    testcase( i==19 ); /* SELECT */
-    testcase( i==20 ); /* TABLE */
-    testcase( i==21 ); /* LEFT */
-    testcase( i==22 ); /* THEN */
-    testcase( i==23 ); /* END */
-    testcase( i==24 ); /* DEFERRABLE */
-    testcase( i==25 ); /* ELSE */
-    testcase( i==26 ); /* EXCLUDE */
-    testcase( i==27 ); /* DELETE */
-    testcase( i==28 ); /* TEMPORARY */
-    testcase( i==29 ); /* TEMP */
-    testcase( i==30 ); /* OR */
-    testcase( i==31 ); /* ISNULL */
-    testcase( i==32 ); /* NULLS */
-    testcase( i==33 ); /* SAVEPOINT */
-    testcase( i==34 ); /* INTERSECT */
-    testcase( i==35 ); /* TIES */
-    testcase( i==36 ); /* NOTNULL */
-    testcase( i==37 ); /* NOT */
-    testcase( i==38 ); /* NO */
-    testcase( i==39 ); /* NULL */
-    testcase( i==40 ); /* LIKE */
-    testcase( i==41 ); /* EXCEPT */
-    testcase( i==42 ); /* TRANSACTION */
-    testcase( i==43 ); /* ACTION */
-    testcase( i==44 ); /* ON */
-    testcase( i==45 ); /* NATURAL */
-    testcase( i==46 ); /* ALTER */
-    testcase( i==47 ); /* RAISE */
-    testcase( i==48 ); /* EXCLUSIVE */
-    testcase( i==49 ); /* EXISTS */
-    testcase( i==50 ); /* CONSTRAINT */
-    testcase( i==51 ); /* INTO */
-    testcase( i==52 ); /* OFFSET */
-    testcase( i==53 ); /* OF */
-    testcase( i==54 ); /* SET */
-    testcase( i==55 ); /* TRIGGER */
-    testcase( i==56 ); /* RANGE */
-    testcase( i==57 ); /* GENERATED */
-    testcase( i==58 ); /* DETACH */
-    testcase( i==59 ); /* HAVING */
-    testcase( i==60 ); /* GLOB */
-    testcase( i==61 ); /* BEGIN */
-    testcase( i==62 ); /* INNER */
-    testcase( i==63 ); /* REFERENCES */
-    testcase( i==64 ); /* UNIQUE */
-    testcase( i==65 ); /* QUERY */
-    testcase( i==66 ); /* WITHOUT */
-    testcase( i==67 ); /* WITH */
-    testcase( i==68 ); /* OUTER */
-    testcase( i==69 ); /* RELEASE */
-    testcase( i==70 ); /* ATTACH */
-    testcase( i==71 ); /* BETWEEN */
-    testcase( i==72 ); /* NOTHING */
-    testcase( i==73 ); /* GROUPS */
-    testcase( i==74 ); /* GROUP */
-    testcase( i==75 ); /* CASCADE */
-    testcase( i==76 ); /* ASC */
-    testcase( i==77 ); /* DEFAULT */
-    testcase( i==78 ); /* CASE */
-    testcase( i==79 ); /* COLLATE */
-    testcase( i==80 ); /* CREATE */
-    testcase( i==81 ); /* CURRENT_DATE */
-    testcase( i==82 ); /* IMMEDIATE */
-    testcase( i==83 ); /* JOIN */
-    testcase( i==84 ); /* INSERT */
-    testcase( i==85 ); /* MATCH */
-    testcase( i==86 ); /* PLAN */
-    testcase( i==87 ); /* ANALYZE */
-    testcase( i==88 ); /* PRAGMA */
-    testcase( i==89 ); /* MATERIALIZED */
-    testcase( i==90 ); /* DEFERRED */
-    testcase( i==91 ); /* DISTINCT */
-    testcase( i==92 ); /* IS */
-    testcase( i==93 ); /* UPDATE */
-    testcase( i==94 ); /* VALUES */
-    testcase( i==95 ); /* VIRTUAL */
-    testcase( i==96 ); /* ALWAYS */
-    testcase( i==97 ); /* WHEN */
-    testcase( i==98 ); /* WHERE */
-    testcase( i==99 ); /* RECURSIVE */
-    testcase( i==100 ); /* ABORT */
-    testcase( i==101 ); /* AFTER */
-    testcase( i==102 ); /* RENAME */
-    testcase( i==103 ); /* AND */
-    testcase( i==104 ); /* DROP */
-    testcase( i==105 ); /* PARTITION */
-    testcase( i==106 ); /* AUTOINCREMENT */
-    testcase( i==107 ); /* TO */
-    testcase( i==108 ); /* IN */
-    testcase( i==109 ); /* CAST */
-    testcase( i==110 ); /* COLUMN */
-    testcase( i==111 ); /* COMMIT */
-    testcase( i==112 ); /* CONFLICT */
-    testcase( i==113 ); /* CROSS */
-    testcase( i==114 ); /* CURRENT_TIMESTAMP */
-    testcase( i==115 ); /* CURRENT_TIME */
-    testcase( i==116 ); /* CURRENT */
-    testcase( i==117 ); /* PRECEDING */
-    testcase( i==118 ); /* FAIL */
-    testcase( i==119 ); /* LAST */
-    testcase( i==120 ); /* FILTER */
-    testcase( i==121 ); /* REPLACE */
-    testcase( i==122 ); /* FIRST */
-    testcase( i==123 ); /* FOLLOWING */
-    testcase( i==124 ); /* FROM */
-    testcase( i==125 ); /* FULL */
-    testcase( i==126 ); /* LIMIT */
-    testcase( i==127 ); /* IF */
-    testcase( i==128 ); /* ORDER */
-    testcase( i==129 ); /* RESTRICT */
-    testcase( i==130 ); /* OTHERS */
-    testcase( i==131 ); /* OVER */
-    testcase( i==132 ); /* RETURNING */
-    testcase( i==133 ); /* RIGHT */
-    testcase( i==134 ); /* ROLLBACK */
-    testcase( i==135 ); /* ROWS */
-    testcase( i==136 ); /* ROW */
-    testcase( i==137 ); /* UNBOUNDED */
-    testcase( i==138 ); /* UNION */
-    testcase( i==139 ); /* USING */
-    testcase( i==140 ); /* VACUUM */
-    testcase( i==141 ); /* VIEW */
-    testcase( i==142 ); /* WINDOW */
-    testcase( i==143 ); /* DO */
-    testcase( i==144 ); /* BY */
-    testcase( i==145 ); /* INITIALLY */
-    testcase( i==146 ); /* ALL */
-    testcase( i==147 ); /* PRIMARY */
-    *pType = aKWCode[i];
-    break;
-  }
-  return n;
-}
-SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){
-  int id = TK_ID;
-  if( n>=2 ) keywordCode((char*)z, n, &id);
-  return id;
-}
-#define SQLITE_N_KEYWORD 147
-SQLITE_API int sqlite3_keyword_name(int i,const char **pzName,int *pnName){
-  if( i<0 || i>=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 || t==TK_COMMENT );
-  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 i64 sqlite3GetToken(const unsigned char *z, int *tokenType){
-  i64 i;
-  int 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_COMMENT;
-        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_COMMENT;
-      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' );  testcase( z[0]=='.' );
-      *tokenType = TK_INTEGER;
-#ifndef SQLITE_OMIT_HEX_INTEGER
-      if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){
-        for(i=3; 1; i++){
-          if( sqlite3Isxdigit(z[i])==0 ){
-            if( z[i]==SQLITE_DIGIT_SEPARATOR ){
-              *tokenType = TK_QNUMBER;
-            }else{
-              break;
-            }
-          }
-        }
-      }else
-#endif
-        {
-        for(i=0; 1; i++){
-          if( sqlite3Isdigit(z[i])==0 ){
-            if( z[i]==SQLITE_DIGIT_SEPARATOR ){
-              *tokenType = TK_QNUMBER;
-            }else{
-              break;
-            }
-          }
-        }
-#ifndef SQLITE_OMIT_FLOATING_POINT
-        if( z[i]=='.' ){
-          if( *tokenType==TK_INTEGER ) *tokenType = TK_FLOAT;
-          for(i++; 1; i++){
-            if( sqlite3Isdigit(z[i])==0 ){
-              if( z[i]==SQLITE_DIGIT_SEPARATOR ){
-                *tokenType = TK_QNUMBER;
-              }else{
-                break;
-              }
-            }
-          }
-        }
-        if( (z[i]=='e' || z[i]=='E') &&
-             ( sqlite3Isdigit(z[i+1])
-              || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2]))
-             )
-        ){
-          if( *tokenType==TK_INTEGER ) *tokenType = TK_FLOAT;
-          for(i+=2; 1; i++){
-            if( sqlite3Isdigit(z[i])==0 ){
-              if( z[i]==SQLITE_DIGIT_SEPARATOR ){
-                *tokenType = TK_QNUMBER;
-              }else{
-                break;
-              }
-            }
-          }
-        }
-#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: {
-      i64 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: {
-      if( aiClass[z[1]]>CC_KYWD ){ i = 1;  break; }
-      for(i=2; 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 */
-  i64 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 */
-  i64 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
-           || tokenType==TK_QNUMBER || tokenType==TK_COMMENT
-      );
-#else
-    if( tokenType>=TK_SPACE ){
-      assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL
-           || tokenType==TK_QNUMBER || tokenType==TK_COMMENT
-      );
-#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 if( tokenType==TK_COMMENT
-             && (db->init.busy || (db->flags & SQLITE_Comments)!=0)
-      ){
-        /* Ignore SQL comments if either (1) we are reparsing the schema or
-        ** (2) SQLITE_DBCONFIG_ENABLE_COMMENTS is turned on (the default). */
-        zSql += n;
-        continue;
-      }else if( tokenType!=TK_QNUMBER ){
-        Token x;
-        x.z = zSql;
-        x.n = (u32)n;
-        sqlite3ErrorMsg(pParse, "unrecognized token: \"%T\"", &x);
-        break;
-      }
-    }
-    pParse->sLastToken.z = zSql;
-    pParse->sLastToken.n = (u32)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 = sqlite3DbStrDup(db, sqlite3ErrStr(pParse->rc));
-    }
-    if( (pParse->prepFlags & SQLITE_PREPARE_DONT_LOG)==0 ){
-      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[] */
-  i64 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_COMMENT:
-      case TK_SPACE: {
-        break;
-      }
-      case TK_NULL: {
-        if( prevType==TK_IS || prevType==TK_NOT ){
-          sqlite3_str_append(pStr, " NULL", 5);
-          break;
-        }
-        /* no break */ deliberate_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( j<pStr->nChar ){
-          pStr->zText[j] = sqlite3Tolower(pStr->zText[j]);
-          j++;
-        }
-        break;
-      }
-      case TK_SELECT: {
-        iStartIN = 0;
-        /* no break */ deliberate_fall_through
-      }
-      default: {
-        if( sqlite3IsIdChar(zSql[i]) ) addSpaceSeparator(pStr);
-        j = pStr->nChar;
-        sqlite3_str_append(pStr, zSql+i, n);
-        while( j<pStr->nChar ){
-          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_FTS5
-SQLITE_PRIVATE int sqlite3Fts5Init(sqlite3*);
-#endif
-#ifdef SQLITE_ENABLE_STMTVTAB
-SQLITE_PRIVATE int sqlite3StmtVtabInit(sqlite3*);
-#endif
-#ifdef SQLITE_EXTRA_AUTOEXT
-int SQLITE_EXTRA_AUTOEXT(sqlite3*);
-#endif
-/*
-** An array of pointers to extension initializer functions for
-** built-in extensions.
-*/
-static int (*const sqlite3BuiltinExtensions[])(sqlite3*) = {
-#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,
-#ifdef SQLITE_ENABLE_STMTVTAB
-  sqlite3StmtVtabInit,
-#endif
-#ifdef SQLITE_ENABLE_BYTECODE_VTAB
-  sqlite3VdbeBytecodeVtabInit,
-#endif
-#ifdef SQLITE_EXTRA_AUTOEXT
-  SQLITE_EXTRA_AUTOEXT,
-#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);
-#ifdef SQLITE_EXTRA_INIT_MUTEXED
-      {
-        int SQLITE_EXTRA_INIT_MUTEXED(const char*);
-        rc = SQLITE_EXTRA_INIT_MUTEXED(0);
-      }
-#endif
-    }
-    if( rc==SQLITE_OK ){
-      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 */
-
-    case SQLITE_CONFIG_ROWID_IN_VIEW: {
-      int *pVal = va_arg(ap,int*);
-#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
-      if( 0==*pVal ) sqlite3GlobalConfig.mNoVisibleRowid = TF_NoVisibleRowid;
-      if( 1==*pVal ) sqlite3GlobalConfig.mNoVisibleRowid = 0;
-      *pVal = (sqlite3GlobalConfig.mNoVisibleRowid==0);
-#else
-      *pVal = 0;
-#endif
-      break;
-    }
-
-    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 pBuf is NULL the
-** space for the lookaside memory is obtained from sqlite3_malloc()
-** or similar.  If pBuf is not NULL then it is sz*cnt bytes of memory
-** to use for the lookaside memory.
-*/
-static int setupLookaside(
-  sqlite3 *db,    /* Database connection being configured */
-  void *pBuf,     /* Memory to use for lookaside.  May be NULL */
-  int sz,         /* Desired size of each lookaside memory slot */
-  int cnt         /* Number of slots to allocate */
-){
-#ifndef SQLITE_OMIT_LOOKASIDE
-  void *pStart;          /* Start of the lookaside buffer */
-  sqlite3_int64 szAlloc; /* Total space set aside for lookaside memory */
-  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 and small enough to fit in a u16.
-  */
-  sz = ROUNDDOWN8(sz);
-  if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0;
-  if( sz>65528 ) sz = 65528;
-  /* Count must be at least 1 to be useful, but not so large as to use
-  ** more than 0x7fff0000 total bytes for lookaside. */
-  if( cnt<1 ) cnt = 0;
-  if( sz>0 && cnt>(0x7fff0000/sz) ) cnt = 0x7fff0000/sz;
-  szAlloc = (i64)sz*(i64)cnt;
-  if( szAlloc==0 ){
-    sz = 0;
-    pStart = 0;
-  }else if( pBuf==0 ){
-    sqlite3BeginBenignMalloc();
-    pStart = sqlite3Malloc( szAlloc );
-    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 - (i64)sz*(i64)nBig)/LOOKASIDE_SMALL;
-  }else if( sz>=LOOKASIDE_SMALL*2 ){
-    nBig = szAlloc/(LOOKASIDE_SMALL+sz);
-    nSm = (szAlloc - (i64)sz*(i64)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; i<nBig; i++){
-      p->pNext = 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; i<nSm; i++){
-      p->pNext = 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; i<db->nDb; 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 && i<db->nDb; 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;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
-#endif
-  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;
-    }
-    case SQLITE_DBCONFIG_FP_DIGITS: {
-      int nIn = va_arg(ap, int);
-      int *pOut = va_arg(ap, int*);
-      if( nIn>3 && nIn<24 ) db->nFpDigit = (u8)nIn;
-      if( pOut ) *pOut = db->nFpDigit;
-      rc = SQLITE_OK;
-      break;
-    }
-    default: {
-      static const struct {
-        int op;      /* The opcode */
-        u64 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   },
-        { SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE,  SQLITE_AttachCreate   },
-        { SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE,   SQLITE_AttachWrite    },
-        { SQLITE_DBCONFIG_ENABLE_COMMENTS,       SQLITE_Comments       },
-      };
-      unsigned int i;
-      rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
-      for(i=0; i<ArraySize(aFlagOp); i++){
-        if( aFlagOp[i].op==op ){
-          int onoff = va_arg(ap, int);
-          int *pRes = va_arg(ap, int*);
-          u64 oldFlags = db->flags;
-          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 = nKey1<nKey2 ? nKey1 : nKey2;
-  /* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares
-  ** strings byte by byte using the memcmp() function from the standard C
-  ** library. */
-  assert( pKey1 && pKey2 );
-  rc = memcmp(pKey1, pKey2, n);
-  if( rc==0 ){
-    rc = nKey1 - nKey2;
-  }
-  return rc;
-}
-
-/*
-** This is the collating function named "RTRIM" which is always
-** available.  Ignore trailing spaces.
-*/
-static int rtrimCollFunc(
-  void *pUser,
-  int nKey1, const void *pKey1,
-  int nKey2, const void *pKey2
-){
-  const u8 *pK1 = (const u8*)pKey1;
-  const u8 *pK2 = (const u8*)pKey2;
-  while( nKey1 && pK1[nKey1-1]==' ' ) nKey1--;
-  while( nKey2 && pK2[nKey2-1]==' ' ) nKey2--;
-  return binCollFunc(pUser, nKey1, pKey1, nKey2, pKey2);
-}
-
-/*
-** Return true if CollSeq is the default built-in BINARY.
-*/
-SQLITE_PRIVATE int sqlite3IsBinary(const CollSeq *p){
-  assert( p==0 || p->xCmp!=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, (nKey1<nKey2)?nKey1:nKey2);
-  UNUSED_PARAMETER(NotUsed);
-  if( 0==r ){
-    r = nKey1-nKey2;
-  }
-  return r;
-}
-
-/*
-** Return the ROWID of the most recent insert
-*/
-SQLITE_API sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) ){
-    (void)SQLITE_MISUSE_BKPT;
-    return 0;
-  }
-#endif
-  return db->lastRowid;
-}
-
-/*
-** 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; i<db->nDb; 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; j<db->nDb; 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
-
-  while( db->pDbData ){
-    DbClientData *p = db->pDbData;
-    db->pDbData = p->pNext;
-    assert( p->pData!=0 );
-    if( p->xDestructor ) p->xDestructor(p->pData);
-    sqlite3_free(p);
-  }
-
-  /* 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; j<db->nDb; 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);
-    assert( db->aDb[1].pSchema->trigHash.count==0 );
-  }
-  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);
-
-  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; i<db->nDb; 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_ERROR_RETRY:        zName = "SQLITE_ERROR_RETRY";       break;
-      case SQLITE_ERROR_MISSING_COLLSEQ:
-                                zName = "SQLITE_ERROR_MISSING_COLLSEQ";   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) && rc<ArraySize(aMsg) && aMsg[rc]!=0 ){
-        zErr = aMsg[rc];
-      }
-      break;
-    }
-  }
-  return zErr;
-}
-
-/*
-** This routine implements a busy callback that sleeps and tries
-** again until a timeout value is reached.  The timeout value is
-** an integer number of milliseconds passed in as the first
-** argument.
-**
-** Return non-zero to retry the lock.  Return zero to stop trying
-** and cause SQLite to return SQLITE_BUSY.
-*/
-static int sqliteDefaultBusyCallback(
-  void *ptr,               /* Database connection */
-  int count                /* Number of times table has been busy */
-){
-#if SQLITE_OS_WIN || !defined(HAVE_NANOSLEEP) || HAVE_NANOSLEEP
-  /* This case is for systems that have support for sleeping for fractions of
-  ** a second.  Examples:  All windows systems, unix systems with nanosleep() */
-  static const u8 delays[] =
-     { 1, 2, 5, 10, 15, 20, 25, 25,  25,  50,  50, 100 };
-  static const u8 totals[] =
-     { 0, 1, 3,  8, 18, 33, 53, 78, 103, 128, 178, 228 };
-# define NDELAY ArraySize(delays)
-  sqlite3 *db = (sqlite3 *)ptr;
-  int tmout = db->busyTimeout;
-  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;
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  db->setlkTimeout = 0;
-#endif
-  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;
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    db->setlkTimeout = ms;
-#endif
-  }else{
-    sqlite3_busy_handler(db, 0, 0);
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Set the setlk timeout value.
-*/
-SQLITE_API int sqlite3_setlk_timeout(sqlite3 *db, int ms, int flags){
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  int iDb;
-  int bBOC = ((flags & SQLITE_SETLK_BLOCK_ON_CONNECT) ? 1 : 0);
-#endif
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
-#endif
-  if( ms<-1 ) return SQLITE_RANGE;
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  sqlite3_mutex_enter(db->mutex);
-  db->setlkTimeout = ms;
-  db->setlkFlags = flags;
-  sqlite3BtreeEnterAll(db);
-  for(iDb=0; iDb<db->nDb; iDb++){
-    Btree *pBt = db->aDb[iDb].pBt;
-    if( pBt ){
-      sqlite3_file *fd = sqlite3PagerFile(sqlite3BtreePager(pBt));
-      sqlite3OsFileControlHint(fd, SQLITE_FCNTL_BLOCK_ON_CONNECT, (void*)&bBOC);
-    }
-  }
-  sqlite3BtreeLeaveAll(db);
-  sqlite3_mutex_leave(db->mutex);
-#endif
-#if !defined(SQLITE_ENABLE_API_ARMOR) && !defined(SQLITE_ENABLE_SETLK_TIMEOUT)
-  UNUSED_PARAMETER(db);
-  UNUSED_PARAMETER(flags);
-#endif
-  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)
-   || (255<sqlite3Strlen30(zFunctionName))
-  ){
-    return SQLITE_MISUSE_BKPT;
-  }
-
-  assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
-  assert( SQLITE_FUNC_DIRECT==SQLITE_DIRECTONLY );
-  extraFlags = enc &  (SQLITE_DETERMINISTIC|SQLITE_DIRECTONLY|
-                       SQLITE_SUBTYPE|SQLITE_INNOCUOUS|
-                       SQLITE_RESULT_SUBTYPE|SQLITE_SELFORDER1);
-  enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY);
-
-  /* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE.  But
-  ** the meaning is inverted.  So flip the bit. */
-  assert( SQLITE_FUNC_UNSAFE==SQLITE_INNOCUOUS );
-  extraFlags ^= SQLITE_FUNC_UNSAFE;  /* tag-20230109-1 */
-
-
-#ifndef SQLITE_OMIT_UTF16
-  /* 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.
-  **
-  ** If SQLITE_ANY is specified, add three versions of the function
-  ** to the hash table.
-  */
-  switch( enc ){
-    case SQLITE_UTF16:
-      enc = SQLITE_UTF16NATIVE;
-      break;
-    case SQLITE_ANY: {
-      int rc;
-      rc = sqlite3CreateFunc(db, zFunctionName, nArg,
-           (SQLITE_UTF8|extraFlags)^SQLITE_FUNC_UNSAFE, /* tag-20230109-1 */
-           pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);
-      if( rc==SQLITE_OK ){
-        rc = sqlite3CreateFunc(db, zFunctionName, nArg,
-             (SQLITE_UTF16LE|extraFlags)^SQLITE_FUNC_UNSAFE, /* tag-20230109-1*/
-             pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);
-      }
-      if( rc!=SQLITE_OK ){
-        return rc;
-      }
-      enc = SQLITE_UTF16BE;
-      break;
-    }
-    case SQLITE_UTF8:
-    case SQLITE_UTF16LE:
-    case SQLITE_UTF16BE:
-      break;
-    default:
-      enc = SQLITE_UTF8;
-      break;
-  }
-#else
-  enc = SQLITE_UTF8;
-#endif
-
-  /* Check if an existing function is being overridden or deleted. If so,
-  ** and there are active VMs, then return SQLITE_BUSY. If a function
-  ** is being overridden/deleted but there are no active VMs, allow the
-  ** operation to continue but invalidate all precompiled statements.
-  */
-  p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 0);
-  if( p && (p->funcFlags & 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;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( db==0 ){
-    return 0;
-  }
-#endif
-  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
-  UNUSED_PARAMETER(db);
-  UNUSED_PARAMETER(xCallback);
-  UNUSED_PARAMETER(pArg);
-  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
-  UNUSED_PARAMETER(db);
-  UNUSED_PARAMETER(zDb);
-  UNUSED_PARAMETER(eMode);
-  UNUSED_PARAMETER(pnLog);
-  UNUSED_PARAMETER(pnCkpt);
-  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_NOOP==-1 );
-  assert( SQLITE_CHECKPOINT_PASSIVE==0 );
-  assert( SQLITE_CHECKPOINT_FULL==1 );
-  assert( SQLITE_CHECKPOINT_RESTART==2 );
-  assert( SQLITE_CHECKPOINT_TRUNCATE==3 );
-  if( eMode<SQLITE_CHECKPOINT_NOOP || eMode>SQLITE_CHECKPOINT_TRUNCATE ){
-    /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
-    ** mode: */
-    return SQLITE_MISUSE_BKPT;
-  }
-
-  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; i<db->nDb && 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;
-}
-
-/*
-** Set the error code and error message associated with the database handle.
-**
-** This routine is intended to be called by outside extensions (ex: the
-** Session extension). Internal logic should invoke sqlite3Error() or
-** sqlite3ErrorWithMsg() directly.
-*/
-SQLITE_API int sqlite3_set_errmsg(sqlite3 *db, int errcode, const char *zMsg){
-  int rc = SQLITE_OK;
-  if( !sqlite3SafetyCheckOk(db) ){
-    return SQLITE_MISUSE_BKPT;
-  }
-  sqlite3_mutex_enter(db->mutex);
-  if( zMsg ){
-    sqlite3ErrorWithMsg(db, errcode, "%s", zMsg);
-  }else{
-    sqlite3Error(db, errcode);
-  }
-  rc = sqlite3ApiExit(db, rc);
-  sqlite3_mutex_leave(db->mutex);
-  return rc;
-}
-
-/*
-** 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( enc2<SQLITE_UTF8 || enc2>SQLITE_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,
-  SQLITE_MAX_PARSER_DEPTH,
-};
-
-/*
-** 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_SQL_LENGTH>2147482624     /* 1024 less than 2^31 */
-# error SQLITE_MAX_SQL_LENGTH must not be greater than 2147482624
-#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>32767
-# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 32767
-#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_PARSER_DEPTH]==SQLITE_MAX_PARSER_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_PARSER_DEPTH==(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<SQLITE_MIN_LENGTH && limitId==SQLITE_LIMIT_LENGTH ){
-      newLimit = SQLITE_MIN_LENGTH;
-    }
-    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<nUri; iIn++) nByte += (zUri[iIn]=='&');
-    zFile = sqlite3_malloc64(nByte);
-    if( !zFile ) return SQLITE_NOMEM_BKPT;
-
-    memset(zFile, 0, 4);  /* 4-byte of 0x00 is the start of DB name marker */
-    zFile += 4;
-
-    iIn = 5;
-#ifdef SQLITE_ALLOW_URI_AUTHORITY
-    if( strncmp(zUri+5, "///", 3)==0 ){
-      iIn = 7;
-      /* The following condition causes URIs with five leading / characters
-      ** like file://///host/path to be converted into UNCs like //host/path.
-      ** The correct URI for that UNC has only two or four leading / characters
-      ** file://host/path or file:////host/path.  But 5 leading slashes is a
-      ** common error, we are told, so we handle it as a special case. */
-      if( strncmp(zUri+7, "///", 3)==0 ){ iIn++; }
-    }else if( strncmp(zUri+5, "//localhost/", 12)==0 ){
-      iIn = 16;
-    }
-#else
-    /* Discard the scheme and authority segments of the URI. */
-    if( zUri[5]=='/' && zUri[6]=='/' ){
-      iIn = 7;
-      while( zUri[iIn] && zUri[iIn]!='/' ) iIn++;
-      if( iIn!=7 && (iIn!=16 || memcmp("localhost", &zUri[7], 9)) ){
-        *pzErrMsg = sqlite3_mprintf("invalid uri authority: %.*s",
-            iIn-7, &zUri[7]);
-        rc = SQLITE_ERROR;
-        goto parse_uri_out;
-      }
-    }
-#endif
-
-    /* Copy the filename and any query parameters into the zFile buffer.
-    ** Decode %HH escape codes along the way.
-    **
-    ** Within this loop, variable eState may be set to 0, 1 or 2, depending
-    ** on the parsing context. As follows:
-    **
-    **   0: Parsing file-name.
-    **   1: Parsing name section of a name=value query parameter.
-    **   2: Parsing value section of a name=value query parameter.
-    */
-    eState = 0;
-    while( (c = zUri[iIn])!=0 && c!='#' ){
-      iIn++;
-      if( c=='%'
-       && sqlite3Isxdigit(zUri[iIn])
-       && sqlite3Isxdigit(zUri[iIn+1])
-      ){
-        int octet = (sqlite3HexToInt(zUri[iIn++]) << 4);
-        octet += sqlite3HexToInt(zUri[iIn++]);
-
-        assert( octet>=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;
-}
-
-
-
-/*
-** This routine does the work of opening a database on behalf of
-** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
-** is UTF-8 encoded.
-*/
-static int openDatabase(
-  const char *zFilename, /* Database filename UTF-8 encoded */
-  sqlite3 **ppDb,        /* OUT: Returned database handle */
-  unsigned int flags,    /* Operational flags */
-  const char *zVfs       /* Name of the VFS to use */
-){
-  sqlite3 *db;                    /* Store allocated handle here */
-  int rc;                         /* Return code */
-  int isThreadsafe;               /* True for threadsafe connections */
-  char *zOpen = 0;                /* Filename argument to pass to BtreeOpen() */
-  char *zErrMsg = 0;              /* Error message from sqlite3ParseUri() */
-  int i;                          /* Loop counter */
-
-#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( sqlite3GlobalConfig.bCoreMutex==0 ){
-    isThreadsafe = 0;
-  }else if( flags & SQLITE_OPEN_NOMUTEX ){
-    isThreadsafe = 0;
-  }else if( flags & SQLITE_OPEN_FULLMUTEX ){
-    isThreadsafe = 1;
-  }else{
-    isThreadsafe = sqlite3GlobalConfig.bFullMutex;
-  }
-
-  if( flags & SQLITE_OPEN_PRIVATECACHE ){
-    flags &= ~SQLITE_OPEN_SHAREDCACHE;
-  }else if( sqlite3GlobalConfig.sharedCacheEnabled ){
-    flags |= SQLITE_OPEN_SHAREDCACHE;
-  }
-
-  /* Remove harmful bits from the flags parameter
-  **
-  ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were
-  ** dealt with in the previous code block.  Besides these, the only
-  ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
-  ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE,
-  ** SQLITE_OPEN_PRIVATECACHE, SQLITE_OPEN_EXRESCODE, and some reserved
-  ** bits.  Silently mask off all other flags.
-  */
-  flags &=  ~( SQLITE_OPEN_DELETEONCLOSE |
-               SQLITE_OPEN_EXCLUSIVE |
-               SQLITE_OPEN_MAIN_DB |
-               SQLITE_OPEN_TEMP_DB |
-               SQLITE_OPEN_TRANSIENT_DB |
-               SQLITE_OPEN_MAIN_JOURNAL |
-               SQLITE_OPEN_TEMP_JOURNAL |
-               SQLITE_OPEN_SUBJOURNAL |
-               SQLITE_OPEN_SUPER_JOURNAL |
-               SQLITE_OPEN_NOMUTEX |
-               SQLITE_OPEN_FULLMUTEX |
-               SQLITE_OPEN_WAL
-             );
-
-  /* Allocate the sqlite data structure */
-  db = sqlite3MallocZero( sizeof(sqlite3) );
-  if( db==0 ) goto opendb_out;
-  if( isThreadsafe
-#if defined(SQLITE_THREAD_MISUSE_WARNINGS)
-   || sqlite3GlobalConfig.bCoreMutex
-#endif
-  ){
-    db->mutex = 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;
-  db->nFpDigit = 17;
-
-  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
-                 | SQLITE_AttachCreate
-                 | SQLITE_AttachWrite
-                 | SQLITE_Comments
-#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 encouraged 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{
-    if( zFilename==0 ) zFilename = ":memory:";
-    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 && i<ArraySize(sqlite3BuiltinExtensions); i++){
-    rc = sqlite3BuiltinExtensions[i](db);
-  }
-
-  /* Load automatic extensions - extensions that have been registered
-  ** using the sqlite3_automatic_extension() API.
-  */
-  if( rc==SQLITE_OK ){
-    sqlite3AutoLoadExtensions(db);
-    rc = sqlite3_errcode(db);
-    if( rc!=SQLITE_OK ){
-      goto opendb_out;
-    }
-  }
-
-#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
-  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 */
-
-/*
-** Find existing client data.
-*/
-SQLITE_API void *sqlite3_get_clientdata(sqlite3 *db, const char *zName){
-  DbClientData *p;
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !zName || !sqlite3SafetyCheckOk(db) ){
-    (void)SQLITE_MISUSE_BKPT;
-    return 0;
-  }
-#endif
-  sqlite3_mutex_enter(db->mutex);
-  for(p=db->pDbData; p; p=p->pNext){
-    if( strcmp(p->zName, zName)==0 ){
-      void *pResult = p->pData;
-      sqlite3_mutex_leave(db->mutex);
-      return pResult;
-    }
-  }
-  sqlite3_mutex_leave(db->mutex);
-  return 0;
-}
-
-/*
-** Add new client data to a database connection.
-*/
-SQLITE_API int sqlite3_set_clientdata(
-  sqlite3 *db,                   /* Attach client data to this connection */
-  const char *zName,             /* Name of the client data */
-  void *pData,                   /* The client data itself */
-  void (*xDestructor)(void*)     /* Destructor */
-){
-  DbClientData *p, **pp;
-  sqlite3_mutex_enter(db->mutex);
-  pp = &db->pDbData;
-  for(p=db->pDbData; p && strcmp(p->zName,zName); p=p->pNext){
-    pp = &p->pNext;
-  }
-  if( p ){
-    assert( p->pData!=0 );
-    if( p->xDestructor ) p->xDestructor(p->pData);
-    if( pData==0 ){
-      *pp = p->pNext;
-      sqlite3_free(p);
-      sqlite3_mutex_leave(db->mutex);
-      return SQLITE_OK;
-    }
-  }else if( pData==0 ){
-    sqlite3_mutex_leave(db->mutex);
-    return SQLITE_OK;
-  }else{
-    size_t n = strlen(zName);
-    p = sqlite3_malloc64( SZ_DBCLIENTDATA(n+1) );
-    if( p==0 ){
-      if( xDestructor ) xDestructor(pData);
-      sqlite3_mutex_leave(db->mutex);
-      return SQLITE_NOMEM;
-    }
-    memcpy(p->zName, zName, n+1);
-    p->pNext = db->pDbData;
-    db->pDbData = p;
-  }
-  p->pData = pData;
-  p->xDestructor = xDestructor;
-  sqlite3_mutex_leave(db->mutex);
-  return SQLITE_OK;
-}
-
-
-#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 existence of table only */
-  }else{
-    iCol = sqlite3ColumnIndex(pTab, zColumnName);
-    if( iCol>=0 ){
-      pCol = &pTab->aCol[iCol];
-    }else{
-      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(SQLITE_TESTCTRL_FK_NO_ACTION, sqlite3 *db, int b);
-    **
-    ** If b is true, then activate the SQLITE_FkNoAction setting.  If b is
-    ** false then clear that setting.  If the SQLITE_FkNoAction setting is
-    ** enabled, all foreign key ON DELETE and ON UPDATE actions behave as if
-    ** they were NO ACTION, regardless of how they are defined.
-    **
-    ** NB:  One must usually run "PRAGMA writable_schema=RESET" after
-    ** using this test-control, before it will take full effect.  failing
-    ** to reset the schema can result in some unexpected behavior.
-    */
-    case SQLITE_TESTCTRL_FK_NO_ACTION: {
-      sqlite3 *db = va_arg(ap, sqlite3*);
-      int b = va_arg(ap, int);
-      if( b ){
-        db->flags |= SQLITE_FkNoAction;
-      }else{
-        db->flags &= ~SQLITE_FkNoAction;
-      }
-      break;
-    }
-
-    /*
-    **  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);
-        sqlite3ShowExprList(0);
-        sqlite3ShowIdList(0);
-        sqlite3ShowSrcList(0);
-        sqlite3ShowWith(0);
-        sqlite3ShowUpsert(0);
-#ifndef SQLITE_OMIT_TRIGGER
-        sqlite3ShowTriggerStep(0);
-        sqlite3ShowTriggerStepList(0);
-        sqlite3ShowTrigger(0);
-        sqlite3ShowTriggerList(0);
-#endif
-#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_GETOPT, sqlite3 *db, int *N)
-    **
-    ** Write the current optimization settings into *N.  A zero bit means that
-    ** the optimization is on, and a 1 bit means that the optimization is off.
-    */
-    case SQLITE_TESTCTRL_GETOPT: {
-      sqlite3 *db = va_arg(ap, sqlite3*);
-      int *pN = va_arg(ap, int*);
-      *pN = db->dbOptFlags;
-      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 demonstrate 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, mode, 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.  "mode" turns imposter mode on
-    ** or off.  mode==0 means imposter mode is off.  mode==1 means imposter mode
-    ** is on.  mode==2 means imposter mode is on but results in an imposter
-    ** table that is read-only unless writable_schema is on.  "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==2       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;
-    }
-
-    /* sqlite3_test_control(SQLITE_TESTCTRL_ATOF, const char *z, double *p);
-    **
-    ** Test access to the sqlite3AtoF() routine.
-    */
-    case SQLITE_TESTCTRL_ATOF: {
-      const char *z = va_arg(ap,const char*);
-      double *pR = va_arg(ap,double*);
-      rc = sqlite3AtoF(z,pR);
-      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
-
-    /* sqlite3_test_control(SQLITE_TESTCTRL_JSON_SELFCHECK, &onOff);
-    **
-    ** Activate or deactivate validation of JSONB that is generated from
-    ** text.  Off by default, as the validation is slow.  Validation is
-    ** only available if compiled using SQLITE_DEBUG.
-    **
-    ** If onOff is initially 1, then turn it on.  If onOff is initially
-    ** off, turn it off.  If onOff is initially -1, then change onOff
-    ** to be the current setting.
-    */
-    case SQLITE_TESTCTRL_JSON_SELFCHECK: {
-#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD)
-      int *pOnOff = va_arg(ap, int*);
-      if( *pOnOff<0 ){
-        *pOnOff = sqlite3Config.bJsonSelfcheck;
-      }else{
-        sqlite3Config.bJsonSelfcheck = (u8)((*pOnOff)&0xff);
-      }
-#endif
-      break;
-    }
-  }
-  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; i<nParam*2; i++){
-    nByte += strlen(azParam[i])+1;
-  }
-  pResult = p = sqlite3_malloc64( nByte );
-  if( p==0 ) return 0;
-  memset(p, 0, 4);
-  p += 4;
-  p = appendText(p, zDatabase);
-  for(i=0; i<nParam*2; i++){
-    p = appendText(p, azParam[i]);
-  }
-  *(p++) = 0;
-  p = appendText(p, zJournal);
-  p = appendText(p, zWal);
-  *(p++) = 0;
-  *(p++) = 0;
-  assert( (sqlite3_int64)(p - pResult)==nByte );
-  return pResult + 4;
-}
-
-/*
-** Free memory obtained from sqlite3_create_filename().  It is a severe
-** error to call this routine with any parameter other than a pointer
-** previously obtained from sqlite3_create_filename() or a NULL pointer.
-*/
-SQLITE_API void sqlite3_free_filename(const char *p){
-  if( p==0 ) return;
-  p = databaseName(p);
-  sqlite3_free((char*)p - 4);
-}
-
-
-/*
-** This is a utility routine, useful to VFS implementations, that checks
-** to see if a database file was a URI that contained a specific query
-** parameter, and if so obtains the value of the query parameter.
-**
-** The zFilename argument is the filename pointer passed into the xOpen()
-** method of a VFS implementation.  The zParam argument is the name of the
-** query parameter we seek.  This routine returns the value of the zParam
-** parameter if it exists.  If the parameter does not exist, this routine
-** returns a NULL pointer.
-*/
-SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam){
-  if( zFilename==0 || zParam==0 ) return 0;
-  zFilename = databaseName(zFilename);
-  return uriParameter(zFilename, zParam);
-}
-
-/*
-** Return a pointer to the name of Nth query parameter of the filename.
-*/
-SQLITE_API const char *sqlite3_uri_key(const char *zFilename, int N){
-  if( zFilename==0 || N<0 ) return 0;
-  zFilename = databaseName(zFilename);
-  zFilename += sqlite3Strlen30(zFilename) + 1;
-  while( ALWAYS(zFilename) && zFilename[0] && (N--)>0 ){
-    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
-  UNUSED_PARAMETER(zFilename);
-  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) ){
-        Pager *pPager = sqlite3BtreePager(pBt);
-        i64 dummy = 0;
-        sqlite3PagerSnapshotOpen(pPager, (sqlite3_snapshot*)&dummy);
-        rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
-        sqlite3PagerSnapshotOpen(pPager, 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 identified 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;
-
-#ifdef 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<nOpt; i++){
-    if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
-     && sqlite3IsIdChar((unsigned char)azCompileOpt[i][n])==0
-    ){
-      return 1;
-    }
-  }
-  return 0;
-}
-
-/*
-** Return the N-th compile-time option string.  If N is out of range,
-** return a NULL pointer.
-*/
-SQLITE_API const char *sqlite3_compileoption_get(int N){
-  int nOpt;
-  const char **azCompileOpt;
-  azCompileOpt = sqlite3CompileOptions(&nOpt);
-  if( N>=0 && N<nOpt ){
-    return azCompileOpt[N];
-  }
-  return 0;
-}
-#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
-
-/************** End of main.c ************************************************/
-/************** Begin file notify.c ******************************************/
-/*
-** 2009 March 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 file contains the implementation of the sqlite3_unlock_notify()
-** API method and its associated functionality.
-*/
-/* #include "sqliteInt.h" */
-/* #include "btreeInt.h" */
-
-/* Omit this entire file if SQLITE_ENABLE_UNLOCK_NOTIFY is not defined. */
-#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
-
-/*
-** Public interfaces:
-**
-**   sqlite3ConnectionBlocked()
-**   sqlite3ConnectionUnlocked()
-**   sqlite3ConnectionClosed()
-**   sqlite3_unlock_notify()
-*/
-
-#define assertMutexHeld() \
-  assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)) )
-
-/*
-** Head of a linked list of all sqlite3 objects created by this process
-** for which either sqlite3.pBlockingConnection or sqlite3.pUnlockConnection
-** is not NULL. This variable may only accessed while the STATIC_MAIN
-** mutex is held.
-*/
-static sqlite3 *SQLITE_WSD sqlite3BlockedList = 0;
-
-#ifndef NDEBUG
-/*
-** This function is a complex assert() that verifies the following
-** properties of the blocked connections list:
-**
-**   1) Each entry in the list has a non-NULL value for either
-**      pUnlockConnection or pBlockingConnection, or both.
-**
-**   2) All entries in the list that share a common value for
-**      xUnlockNotify are grouped together.
-**
-**   3) If the argument db is not NULL, then none of the entries in the
-**      blocked connections list have pUnlockConnection or pBlockingConnection
-**      set to db. This is used when closing connection db.
-*/
-static void checkListProperties(sqlite3 *db){
-  sqlite3 *p;
-  for(p=sqlite3BlockedList; p; p=p->pNextBlocked){
-    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;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
-#endif
-  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 sentinels
-** 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
-
-/*
-** Activate assert() only if SQLITE_TEST is enabled.
-*/
-#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
-# define NDEBUG 1
-#endif
-
-/* #include <assert.h> */
-/* #include <stdlib.h> */
-/* #include <stddef.h> */
-/* #include <stdio.h> */
-/* #include <string.h> */
-/* #include <stdarg.h> */
-
-/* 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 <tokenizer-name> 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)
-
-/*
-** 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)
-
-#if !defined(deliberate_fall_through)
-# if defined(__has_attribute)
-#  if __has_attribute(fallthrough)
-#    define deliberate_fall_through __attribute__((fallthrough));
-#  endif
-# endif
-#endif
-#if !defined(deliberate_fall_through)
-# define deliberate_fall_through
-#endif
-
-/*
-** Macros needed to provide flexible arrays in a portable way
-*/
-#ifndef offsetof
-# define offsetof(ST,M) ((size_t)((char*)&((ST*)0)->M - (char*)0))
-#endif
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
-# define FLEXARRAY
-#else
-# define FLEXARRAY 1
-#endif
-
-
-#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 */
-  int iSavepoint;
-
-  /*
-  ** 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 controlled
-  ** 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.
-** Actually, 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[FLEXARRAY]; /* One for each token in the phrase */
-};
-
-/* Size (in bytes) of an Fts3Phrase object large enough to hold N tokens */
-#define SZ_FTS3PHRASE(N) \
-  (offsetof(Fts3Phrase,aToken)+(N)*sizeof(Fts3PhraseToken))
-
-/*
-** 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) \
-)
-
-SQLITE_PRIVATE int sqlite3Fts3PrepareStmt(
-  Fts3Table *p,                   /* Prepare for this connection */
-  const char *zSql,               /* SQL to prepare */
-  int bPersist,                   /* True to set SQLITE_PREPARE_PERSISTENT */
-  int bAllowVtab,                 /* True to omit SQLITE_PREPARE_NO_VTAB */
-  sqlite3_stmt **pp               /* OUT: Prepared statement */
-);
-
-
-/* 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);
-SQLITE_PRIVATE int sqlite3Fts3MsrCancel(Fts3Cursor*, Fts3Expr*);
-
-/* 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*);
-
-SQLITE_PRIVATE int sqlite3Fts3IntegrityCheck(Fts3Table *p, int *pbOk);
-
-#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 "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<pX ? *p : 0;
-    p++;
-    b += (c&0x7F) << shift;
-    if( (c & 0x80)==0 ) break;
-  }
-  *v = b;
-  return (int)(p - pStart);
-}
-
-/*
-** Similar to sqlite3Fts3GetVarint(), except that the output is truncated to
-** a non-negative 32-bit integer before it is returned.
-*/
-SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *p, int *pi){
-  const unsigned char *ptr = (const unsigned char*)p;
-  u32 a;
-
-#ifndef fts3GetVarint32
-  GETVARINT_INIT(a, ptr, 0,  0x00,     0x80, *pi, 1);
-#else
-  a = (*ptr++);
-  assert( a & 0x80 );
-#endif
-
-  GETVARINT_STEP(a, ptr, 7,  0x7F,     0x4000, *pi, 2);
-  GETVARINT_STEP(a, ptr, 14, 0x3FFF,   0x200000, *pi, 3);
-  GETVARINT_STEP(a, ptr, 21, 0x1FFFFF, 0x10000000, *pi, 4);
-  a = (a & 0x0FFFFFFF );
-  *pi = (int)(a | ((u32)(*ptr & 0x07) << 28));
-  assert( 0==(a & 0x80000000) );
-  assert( *pi>=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; i<SizeofArray(p->aStmt); 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);
-    sqlite3_vtab_config(p->db, SQLITE_VTAB_INNOCUOUS);
-
-    /* Create a list of user columns for the virtual table */
-    zCols = sqlite3_mprintf("%Q, ", p->azColumn[0]);
-    for(i=1; zCols && i<p->nColumn; 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 && i<p->nColumn; 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:
-**
-**   <key> = <value>
-**
-** There may not be whitespace surrounding the "=" character. The <value>
-** term may be quoted, but the <key> 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 <list of expressions> 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; i<p->nColumn; 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; i<p->nColumn; 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; i<p->nColumn; 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<nIndex; i++){
-      int nPrefix = 0;
-      if( fts3GobbleInt(&p, &nPrefix) ) return SQLITE_ERROR;
-      assert( nPrefix>=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<nCol; i++){
-      const char *zCol = sqlite3_column_name(pStmt, i);
-      nStr += strlen(zCol) + 1;
-    }
-
-    /* Allocate and populate the array to return. */
-    azCol = (const char **)sqlite3_malloc64(sizeof(char *) * nCol + nStr);
-    if( azCol==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      char *p = (char *)&azCol[nCol];
-      for(i=0; i<nCol; i++){
-        const char *zCol = sqlite3_column_name(pStmt, i);
-        int n = (int)strlen(zCol)+1;
-        memcpy(p, zCol, n);
-        azCol[i] = p;
-        p += n;
-      }
-    }
-    sqlite3_finalize(pStmt);
-
-    /* Set the output variables. */
-    *pnCol = nCol;
-    *pnStr = nStr;
-    *pazCol = azCol;
-  }
-
-  return rc;
-}
-
-/*
-** This function is the implementation of both the xConnect and xCreate
-** methods of the FTS3 virtual table.
-**
-** The argv[] array contains the following:
-**
-**   argv[0]   -> 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 && i<argc; i++){
-    char const *z = argv[i];
-    int nKey;
-    char *zVal;
-
-    /* Check if this is a tokenizer specification */
-    if( !pTokenizer
-     && strlen(z)>8
-     && 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; iOpt<SizeofArray(aFts4Opt); iOpt++){
-          struct Fts4Option *pOp = &aFts4Opt[iOpt];
-          if( nKey==pOp->nOpt && !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; j<nCol; j++){
-          if( sqlite3_stricmp(zLanguageid, aCol[j])==0 ){
-            int k;
-            for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
-            nCol--;
-            break;
-          }
-        }
-      }
-    }
-  }
-  if( rc!=SQLITE_OK ) goto fts3_init_out;
-
-  if( nCol==0 ){
-    assert( nString==0 );
-    aCol[0] = "content";
-    nString = 8;
-    nCol = 1;
-  }
-
-  if( pTokenizer==0 ){
-    rc = sqlite3Fts3InitTokenizer(pHash, "simple", &pTokenizer, pzErr);
-    if( rc!=SQLITE_OK ) goto fts3_init_out;
-  }
-  assert( pTokenizer );
-
-  rc = fts3PrefixParameter(zPrefix, &nIndex, &aIndex);
-  if( rc==SQLITE_ERROR ){
-    assert( zPrefix );
-    sqlite3Fts3ErrMsg(pzErr, "error parsing prefix parameter: %s", zPrefix);
-  }
-  if( rc!=SQLITE_OK ) goto fts3_init_out;
-
-  /* Allocate and populate the Fts3Table structure. */
-  nByte = sizeof(Fts3Table) +                  /* Fts3Table */
-          nCol * sizeof(char *) +              /* azColumn */
-          nIndex * sizeof(struct Fts3Index) +  /* aIndex */
-          nCol * sizeof(u8) +                  /* abNotindexed */
-          nName +                              /* zName */
-          nDb +                                /* zDb */
-          nString;                             /* Space for azColumn strings */
-  p = (Fts3Table*)sqlite3_malloc64(nByte);
-  if( p==0 ){
-    rc = SQLITE_NOMEM;
-    goto fts3_init_out;
-  }
-  memset(p, 0, nByte);
-  p->db = 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; i<nIndex; i++){
-    fts3HashInit(&p->aIndex[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; iCol<nCol; iCol++){
-    char *z;
-    int n = 0;
-    z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
-    if( n>0 ){
-      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; iCol<nCol; iCol++){
-    int n = (int)strlen(p->azColumn[iCol]);
-    for(i=0; i<nNotindexed; i++){
-      char *zNot = azNotindexed[i];
-      if( zNot && n==(int)strlen(zNot)
-       && 0==sqlite3_strnicmp(p->azColumn[iCol], zNot, n)
-      ){
-        p->abNotindexed[iCol] = 1;
-        sqlite3_free(zNot);
-        azNotindexed[i] = 0;
-      }
-    }
-  }
-  for(i=0; i<nNotindexed; i++){
-    if( azNotindexed[i] ){
-      sqlite3Fts3ErrMsg(pzErr, "no such column: %s", azNotindexed[i]);
-      rc = SQLITE_ERROR;
-    }
-  }
-
-  if( rc==SQLITE_OK && (zCompress==0)!=(zUncompress==0) ){
-    char const *zMiss = (zCompress==0 ? "compress" : "uncompress");
-    rc = SQLITE_ERROR;
-    sqlite3Fts3ErrMsg(pzErr, "missing %s parameter in fts4 constructor", zMiss);
-  }
-  p->zReadExprlist = 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; i<nNotindexed; i++) sqlite3_free(azNotindexed[i]);
-  sqlite3_free((void *)aCol);
-  sqlite3_free((void *)azNotindexed);
-  if( rc!=SQLITE_OK ){
-    if( p ){
-      fts3DisconnectMethod((sqlite3_vtab *)p);
-    }else if( pTokenizer ){
-      pTokenizer->pModule->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; i<pInfo->nConstraint; 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 <columns> 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 = sqlite3Fts3PrepareStmt(p, zSql, 1, 1, &pCsr->pStmt);
-      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( zCsr<zEnd && (piFirst || piLast) ){
-    int cmp;                      /* memcmp() result */
-    int nSuffix;                  /* Size of term suffix */
-    int nPrefix = 0;              /* Size of term prefix */
-
-    /* Load the next term on the node into zBuffer. Use realloc() to expand
-    ** the size of zBuffer if required.  */
-    if( !isFirstTerm ){
-      zCsr += fts3GetVarint32(zCsr, &nPrefix);
-      if( nPrefix>nBuffer ){
-        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, (i1<i2) ? i1 : i2);
-        iPrev -= 2;
-        if( i1==i2 ){
-          fts3ReadNextPos(&p1, &i1);
-          fts3ReadNextPos(&p2, &i2);
-        }else if( i1<i2 ){
-          fts3ReadNextPos(&p1, &i1);
-        }else{
-          fts3ReadNextPos(&p2, &i2);
-        }
-      }while( i1!=POSITION_LIST_END || i2!=POSITION_LIST_END );
-    }else if( iCol1<iCol2 ){
-      p1 += fts3PutColNumber(&p, iCol1);
-      fts3ColumnlistCopy(&p, &p1);
-    }else{
-      p2 += fts3PutColNumber(&p, iCol2);
-      fts3ColumnlistCopy(&p, &p2);
-    }
-  }
-
-  *p++ = POS_END;
-  *pp = p;
-  *pp1 = p1 + 1;
-  *pp2 = p2 + 1;
-  return SQLITE_OK;
-}
-
-/*
-** This function is used to merge two position lists into one. When it is
-** called, *pp1 and *pp2 must both point to position lists. A position-list is
-** the part of a doclist that follows each document id. For example, if a row
-** contains:
-**
-**     'a b c'|'x y z'|'a b b a'
-**
-** Then the position list for this row for token 'b' would consist of:
-**
-**     0x02 0x01 0x02 0x03 0x03 0x00
-**
-** When this function returns, both *pp1 and *pp2 are left pointing to the
-** byte following the 0x00 terminator of their respective position lists.
-**
-** If isSaveLeft is 0, an entry is added to the output position list for
-** each position in *pp2 for which there exists one or more positions in
-** *pp1 so that (pos(*pp2)>pos(*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);
-    /* iCol1==0 indicates corruption. Column 0 does not have a POS_COLUMN
-    ** entry, so this is actually end-of-doclist. */
-    if( iCol1==0 ) return 0;
-  }
-  if( *p2==POS_COLUMN ){
-    p2++;
-    p2 += fts3GetVarint32(p2, &iCol2);
-    /* As above, iCol2==0 indicates corruption. */
-    if( iCol2==0 ) return 0;
-  }
-
-  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<iCol2 ){
-      fts3ColumnlistCopy(0, &p1);
-      if( 0==*p1 ) break;
-      p1++;
-      p1 += fts3GetVarint32(p1, &iCol1);
-    }else{
-      fts3ColumnlistCopy(0, &p2);
-      if( 0==*p2 ) break;
-      p2++;
-      p2 += fts3GetVarint32(p2, &iCol2);
-    }
-  }
-
-  fts3PoslistCopy(0, &p2);
-  fts3PoslistCopy(0, &p1);
-  *pp1 = p1;
-  *pp2 = p2;
-  if( *pp==p ){
-    return 0;
-  }
-  *p++ = 0x00;
-  *pp = p;
-  return 1;
-}
-
-/*
-** Merge two position-lists as required by the NEAR operator. The argument
-** position lists correspond to the left and right phrases of an expression
-** like:
-**
-**     "phrase 1" NEAR "phrase number 2"
-**
-** Position list *pp1 corresponds to the left-hand side of the NEAR
-** expression and *pp2 to the right. As usual, the indexes in the position
-** lists are the offsets of the last token in each phrase (tokens "1" and "2"
-** in the example above).
-**
-** The output position list - written to *pp - is a copy of *pp2 with those
-** entries that are not sufficiently NEAR entries in *pp1 removed.
-*/
-static int fts3PoslistNearMerge(
-  char **pp,                      /* Output buffer */
-  char *aTmp,                     /* Temporary buffer space */
-  int nRight,                     /* Maximum difference in token positions */
-  int nLeft,                      /* Maximum difference in token positions */
-  char **pp1,                     /* IN/OUT: Left input list */
-  char **pp2                      /* IN/OUT: Right input list */
-){
-  char *p1 = *pp1;
-  char *p2 = *pp2;
-
-  char *pTmp1 = aTmp;
-  char *pTmp2;
-  char *aTmp2;
-  int res = 1;
-
-  fts3PoslistPhraseMerge(&pTmp1, nRight, 0, 0, pp1, pp2);
-  aTmp2 = pTmp2 = pTmp1;
-  *pp1 = p1;
-  *pp2 = p2;
-  fts3PoslistPhraseMerge(&pTmp2, nLeft, 1, 0, pp2, pp1);
-  if( pTmp1!=aTmp && pTmp2!=aTmp2 ){
-    fts3PoslistMerge(pp, &aTmp, &aTmp2);
-  }else if( pTmp1!=aTmp ){
-    fts3PoslistCopy(pp, &aTmp);
-  }else if( pTmp2!=aTmp2 ){
-    fts3PoslistCopy(pp, &aTmp2);
-  }else{
-    res = 0;
-  }
-
-  return res;
-}
-
-/*
-** An instance of this function is used to merge together the (potentially
-** large number of) doclists for each term that matches a prefix query.
-** See function fts3TermSelectMerge() for details.
-*/
-typedef struct TermSelect TermSelect;
-struct TermSelect {
-  char *aaOutput[16];             /* Malloc'd output buffers */
-  int anOutput[16];               /* Size each output buffer in bytes */
-};
-
-/*
-** This function is used to read a single varint from a buffer. Parameter
-** pEnd points 1 byte past the end of the buffer. When this function is
-** called, if *pp points to pEnd or greater, then the end of the buffer
-** has been reached. In this case *pp is set to 0 and the function returns.
-**
-** If *pp does not point to or past pEnd, then a single varint is read
-** from *pp. *pp is then set to point 1 byte past the end of the read varint.
-**
-** If bDescIdx is false, the value read is added to *pVal before returning.
-** If it is true, the value read is subtracted from *pVal before this
-** function returns.
-*/
-static void fts3GetDeltaVarint3(
-  char **pp,                      /* IN/OUT: Point to read varint from */
-  char *pEnd,                     /* End of buffer */
-  int bDescIdx,                   /* True if docids are descending */
-  sqlite3_int64 *pVal             /* IN/OUT: Integer value */
-){
-  if( *pp>=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 symmetric 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( p<pEnd ){
-    sqlite3_int64 iCol;
-    p++;
-    p += sqlite3Fts3GetVarint(p, &iCol);
-    if( *p==0x02 ){
-      if( bWritten==0 ){
-        nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta);
-        bWritten = 1;
-      }
-      pOut[nOut++] = 0x01;
-      nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
-      pOut[nOut++] = 0x02;
-    }
-    fts3ColumnlistCopy(0, &p);
-  }
-  if( bWritten ){
-    pOut[nOut++] = 0x00;
-  }
-
-  return nOut;
-}
-
-
-/*
-** Merge all doclists in the TermSelect.aaOutput[] array into a single
-** doclist stored in TermSelect.aaOutput[0]. If successful, delete all
-** other doclists (except the aaOutput[0] one) and return SQLITE_OK.
-**
-** If an OOM error occurs, return SQLITE_NOMEM. In this case it is
-** the responsibility of the caller to free any doclists left in the
-** TermSelect.aaOutput[] array.
-*/
-static int fts3TermSelectFinishMerge(Fts3Table *p, TermSelect *pTS){
-  char *aOut = 0;
-  int nOut = 0;
-  int i;
-
-  /* Loop through the doclists in the aaOutput[] array. Merge them all
-  ** into a single doclist.
-  */
-  for(i=0; i<SizeofArray(pTS->aaOutput); 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; iOut<SizeofArray(pTS->aaOutput); 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 && iIndex<p->nIndex );
-  assert( iLevel==FTS3_SEGCURSOR_ALL
-      ||  iLevel==FTS3_SEGCURSOR_PENDING
-      ||  iLevel>=0
-  );
-  assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
-  assert( FTS3_SEGCURSOR_ALL<0 && FTS3_SEGCURSOR_PENDING<0 );
-  assert( isPrefix==0 || isScan==0 );
-
-  memset(pCsr, 0, sizeof(Fts3MultiSegReader));
-  return fts3SegReaderCursor(
-      p, iLangid, iIndex, iLevel, zTerm, nTerm, isPrefix, isScan, pCsr
-  );
-}
-
-/*
-** In addition to its current configuration, have the Fts3MultiSegReader
-** passed as the 4th argument also scan the doclist for term zTerm/nTerm.
-**
-** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
-*/
-static int fts3SegReaderCursorAddZero(
-  Fts3Table *p,                   /* FTS virtual table handle */
-  int iLangid,
-  const char *zTerm,              /* Term to scan doclist of */
-  int nTerm,                      /* Number of bytes in zTerm */
-  Fts3MultiSegReader *pCsr        /* Fts3MultiSegReader to modify */
-){
-  return fts3SegReaderCursor(p,
-      iLangid, 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0,pCsr
-  );
-}
-
-/*
-** Open an Fts3MultiSegReader to scan the doclist for term zTerm/nTerm. Or,
-** if isPrefix is true, to scan the doclist for all terms for which
-** zTerm/nTerm is a prefix. If successful, return SQLITE_OK and write
-** a pointer to the new Fts3MultiSegReader to *ppSegcsr. Otherwise, return
-** an SQLite error code.
-**
-** It is the responsibility of the caller to free this object by eventually
-** passing it to fts3SegReaderCursorFree()
-**
-** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
-** Output parameter *ppSegcsr is set to 0 if an error occurs.
-*/
-static int fts3TermSegReaderCursor(
-  Fts3Cursor *pCsr,               /* Virtual table cursor handle */
-  const char *zTerm,              /* Term to query for */
-  int nTerm,                      /* Size of zTerm in bytes */
-  int isPrefix,                   /* True for a prefix search */
-  Fts3MultiSegReader **ppSegcsr   /* OUT: Allocated seg-reader cursor */
-){
-  Fts3MultiSegReader *pSegcsr;    /* Object to allocate and return */
-  int rc = SQLITE_NOMEM;          /* Return code */
-
-  pSegcsr = sqlite3_malloc(sizeof(Fts3MultiSegReader));
-  if( pSegcsr ){
-    int i;
-    int bFound = 0;               /* True once an index has been found */
-    Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
-
-    if( isPrefix ){
-      for(i=1; bFound==0 && i<p->nIndex; 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 && i<p->nIndex; 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)
-        | (iColumn<p->nColumn ? 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; i<SizeofArray(tsc.aaOutput); i++){
-      sqlite3_free(tsc.aaOutput[i]);
-    }
-  }
-
-  fts3SegReaderCursorFree(pSegcsr);
-  pTok->pSegcsr = 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( p<aEnd ){
-      nDoc++;
-      while( (*p++)&0x80 );     /* Skip docid varint */
-      fts3PoslistCopy(0, &p);   /* Skip over position list */
-    }
-  }
-
-  return nDoc;
-}
-
-/*
-** Advance the cursor to the next row in the %_content table that
-** matches the search criteria.  For a MATCH search, this will be
-** the next row that matches. For a full-table scan, this will be
-** simply the next row in the %_content table.  For a docid lookup,
-** this routine simply sets the EOF flag.
-**
-** Return SQLITE_OK if nothing goes wrong.  SQLITE_OK is returned
-** even if we reach end-of-file.  The fts3EofMethod() will be called
-** subsequently to determine whether or not an EOF was hit.
-*/
-static int fts3NextMethod(sqlite3_vtab_cursor *pCursor){
-  int rc;
-  Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
-  if( pCsr->eSearch==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 = sqlite3Fts3PrepareStmt(p, zSql, 1, 1, &pCsr->pStmt);
-      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 <next docid delta varint>
-  */
-  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 = "<b>";
-  const char *zEnd = "</b>";
-  const char *zEllipsis = "<b>...</b>";
-  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; i<SizeofArray(aOverload); i++){
-    if( strcmp(zName, aOverload[i].zName)==0 ){
-      *pxFunc = aOverload[i].xFunc;
-      return 1;
-    }
-  }
-
-  /* No function of the specified name was found. Return 0. */
-  return 0;
-}
-
-/*
-** Implementation of FTS3 xRename method. Rename an fts3 table.
-*/
-static int fts3RenameMethod(
-  sqlite3_vtab *pVtab,            /* Virtual table handle */
-  const char *zName               /* New name of table */
-){
-  Fts3Table *p = (Fts3Table *)pVtab;
-  sqlite3 *db = p->db;            /* 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);
-  }
-
-  p->bIgnoreSavepoint = 1;
-
-  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
-  );
-
-  p->bIgnoreSavepoint = 0;
-  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;
-  Fts3Table *pTab = (Fts3Table*)pVtab;
-  assert( pTab->inTransaction );
-  assert( pTab->mxSavepoint<=iSavepoint );
-  TESTONLY( pTab->mxSavepoint = iSavepoint );
-
-  if( pTab->bIgnoreSavepoint==0 ){
-    if( fts3HashCount(&pTab->aIndex[0].hPending)>0 ){
-      char *zSql = sqlite3_mprintf("INSERT INTO %Q.%Q(%Q) VALUES('flush')",
-          pTab->zDb, pTab->zName, pTab->zName
-          );
-      if( zSql ){
-        pTab->bIgnoreSavepoint = 1;
-        rc = sqlite3_exec(pTab->db, zSql, 0, 0, 0);
-        pTab->bIgnoreSavepoint = 0;
-        sqlite3_free(zSql);
-      }else{
-        rc = SQLITE_NOMEM;
-      }
-    }
-    if( rc==SQLITE_OK ){
-      pTab->iSavepoint = iSavepoint+1;
-    }
-  }
-  return rc;
-}
-
-/*
-** The xRelease() method.
-**
-** This is a no-op.
-*/
-static int fts3ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){
-  Fts3Table *pTab = (Fts3Table*)pVtab;
-  assert( pTab->inTransaction );
-  assert( pTab->mxSavepoint >= iSavepoint );
-  TESTONLY( pTab->mxSavepoint = iSavepoint-1 );
-  pTab->iSavepoint = iSavepoint;
-  return SQLITE_OK;
-}
-
-/*
-** The xRollbackTo() method.
-**
-** Discard the contents of the pending terms table.
-*/
-static int fts3RollbackToMethod(sqlite3_vtab *pVtab, int iSavepoint){
-  Fts3Table *pTab = (Fts3Table*)pVtab;
-  UNUSED_PARAMETER(iSavepoint);
-  assert( pTab->inTransaction );
-  TESTONLY( pTab->mxSavepoint = iSavepoint );
-  if( (iSavepoint+1)<=pTab->iSavepoint ){
-    sqlite3Fts3PendingTermsClear(pTab);
-  }
-  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; i<sizeof(azName)/sizeof(azName[0]); i++){
-    if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
-  }
-  return 0;
-}
-
-/*
-** Implementation of the xIntegrity() method on the FTS3/FTS4 virtual
-** table.
-*/
-static int fts3IntegrityMethod(
-  sqlite3_vtab *pVtab,      /* The virtual table to be checked */
-  const char *zSchema,      /* Name of schema in which pVtab lives */
-  const char *zTabname,     /* Name of the pVTab table */
-  int isQuick,              /* True if this is a quick_check */
-  char **pzErr              /* Write error message here */
-){
-  Fts3Table *p = (Fts3Table*)pVtab;
-  int rc = SQLITE_OK;
-  int bOk = 0;
-
-  UNUSED_PARAMETER(isQuick);
-  rc = sqlite3Fts3IntegrityCheck(p, &bOk);
-  assert( pVtab->zErrMsg==0 || rc!=SQLITE_OK );
-  assert( rc!=SQLITE_CORRUPT_VTAB );
-  if( rc==SQLITE_ERROR || (rc&0xFF)==SQLITE_CORRUPT ){
-    *pzErr = sqlite3_mprintf("unable to validate the inverted index for"
-                             " FTS%d table %s.%s: %s",
-                p->bFts4 ? 4 : 3, zSchema, zTabname, sqlite3_errstr(rc));
-    if( *pzErr ) rc = SQLITE_OK;
-  }else if( rc==SQLITE_OK && bOk==0 ){
-    *pzErr = sqlite3_mprintf("malformed inverted index for FTS%d table %s.%s",
-                p->bFts4 ? 4 : 3, zSchema, zTabname);
-    if( *pzErr==0 ) rc = SQLITE_NOMEM;
-  }
-  sqlite3Fts3SegmentsClose(p);
-  return rc;
-}
-
-
-
-static const sqlite3_module fts3Module = {
-  /* iVersion      */ 4,
-  /* xCreate       */ fts3CreateMethod,
-  /* xConnect      */ fts3ConnectMethod,
-  /* xBestIndex    */ fts3BestIndexMethod,
-  /* xDisconnect   */ fts3DisconnectMethod,
-  /* xDestroy      */ fts3DestroyMethod,
-  /* xOpen         */ fts3OpenMethod,
-  /* xClose        */ fts3CloseMethod,
-  /* xFilter       */ fts3FilterMethod,
-  /* xNext         */ fts3NextMethod,
-  /* xEof          */ fts3EofMethod,
-  /* xColumn       */ fts3ColumnMethod,
-  /* xRowid        */ fts3RowidMethod,
-  /* xUpdate       */ fts3UpdateMethod,
-  /* xBegin        */ fts3BeginMethod,
-  /* xSync         */ fts3SyncMethod,
-  /* xCommit       */ fts3CommitMethod,
-  /* xRollback     */ fts3RollbackMethod,
-  /* xFindFunction */ fts3FindFunctionMethod,
-  /* xRename */       fts3RenameMethod,
-  /* xSavepoint    */ fts3SavepointMethod,
-  /* xRelease      */ fts3ReleaseMethod,
-  /* xRollbackTo   */ fts3RollbackToMethod,
-  /* xShadowName   */ fts3ShadowName,
-  /* xIntegrity    */ fts3IntegrityMethod,
-};
-
-/*
-** This function is registered as the module destructor (called when an
-** FTS3 enabled database connection is closed). It frees the memory
-** allocated for the tokenizer hash table.
-*/
-static void hashDestroy(void *p){
-  Fts3HashWrapper *pHash = (Fts3HashWrapper *)p;
-  pHash->nRef--;
-  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; i<nToken; i++){
-        Fts3PhraseToken *pToken = &pExpr->pPhrase->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->iDoclistToken<iToken ){
-      pLeft = p->doclist.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 && iToken<p->nToken; 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; iToken<pPhrase->nToken; 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(((i64)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 && i<p->nToken; 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 && i<p->nToken; 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( pDocid<pEnd ){
-      sqlite3_int64 iDelta;
-      pDocid += sqlite3Fts3GetVarint(pDocid, &iDelta);
-      iDocid += (iMul * iDelta);
-      pNext = pDocid;
-      fts3PoslistCopy(0, &pDocid);
-      while( pDocid<pEnd && *pDocid==0 ) pDocid++;
-      iMul = (bDescIdx ? -1 : 1);
-    }
-
-    *pnList = (int)(pEnd - pNext);
-    *ppIter = pNext;
-    *piDocid = iDocid;
-  }else{
-    int iMul = (bDescIdx ? -1 : 1);
-    sqlite3_int64 iDelta;
-    fts3GetReverseVarint(&p, aDoclist, &iDelta);
-    *piDocid -= (iMul * iDelta);
-
-    if( p==aDoclist ){
-      *pbEof = 1;
-    }else{
-      char *pSave = p;
-      fts3ReversePoslist(aDoclist, &p);
-      *pnList = (int)(pSave - p);
-    }
-    *ppIter = p;
-  }
-}
-
-/*
-** Iterate forwards through a doclist.
-*/
-SQLITE_PRIVATE void sqlite3Fts3DoclistNext(
-  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 */
-  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 ){
-    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( pIter<pEnd && *pIter==0 ) pIter++;
-
-    pDL->pNextDocid = 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 document 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->iDoclistToken<MAX_INCR_PHRASE_TOKENS );
-
-    while( bEof==0 ){
-      int bMaxSet = 0;
-      sqlite3_int64 iMax = 0;     /* Largest docid for all iterators */
-      int i;                      /* Used to iterate through tokens */
-
-      /* Advance the iterator for each token in the phrase once. */
-      for(i=0; rc==SQLITE_OK && i<p->nToken && 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; i<p->nToken; 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; i<nToken; i++){
-          if( pExpr->pPhrase->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 && i<pPhrase->nToken; 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( a<pEnd ){
-        a += sqlite3Fts3GetVarintBounded(a, pEnd, &nByte);
-      }
-    }
-    if( nDoc==0 || nByte==0 ){
-      sqlite3_reset(pStmt);
-      return FTS_CORRUPT_VTAB;
-    }
-
-    pCsr->nDoc = 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; ii<nTC; ii++){
-    if( aTC[ii].pRoot==pRoot ){
-      nOvfl += aTC[ii].nOvfl;
-      nToken++;
-    }
-  }
-  if( nOvfl==0 || nToken<2 ) return SQLITE_OK;
-
-  /* Obtain the average docsize (in pages). */
-  rc = fts3EvalAverageDocsize(pCsr, &nDocSize);
-  assert( rc!=SQLITE_OK || nDocSize>0 );
-
-
-  /* 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; ii<nToken && rc==SQLITE_OK; ii++){
-    int iTC;                      /* Used to iterate through aTC[] array. */
-    Fts3TokenAndCost *pTC = 0;    /* Set to cheapest remaining token. */
-
-    /* Set pTC to point to the cheapest remaining token. */
-    for(iTC=0; iTC<nTC; iTC++){
-      if( aTC[iTC].pToken && aTC[iTC].pRoot==pRoot
-       && (!pTC || aTC[iTC].nOvfl<pTC->nOvfl)
-      ){
-        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 || nCount<nMinEst ) nMinEst = nCount;
-        }
-      }
-    }
-    pTC->pToken = 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 && ii<nOr; ii++){
-          rc = fts3EvalSelectDeferred(pCsr, apOr[ii], aTC, nToken);
-        }
-      }
-
-      sqlite3_free(aTC);
-    }
-  }
-#endif
-
-  fts3EvalStartReaders(pCsr, pCsr->pExpr, &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 + FTS3_VARINT_MAX);
-    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->iPrevId<pCsr->iMinDocid)
-  )){
-    pCsr->isEof = 1;
-  }
-
-  return rc;
-}
-
-/*
-** Restart iteration 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; i<pPhrase->nToken; 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);
-  }
-}
-
-/*
-** Expression node pExpr is an MSR phrase. This function restarts pExpr
-** so that it is a regular phrase query, not an MSR. SQLITE_OK is returned
-** if successful, or an SQLite error code otherwise.
-*/
-SQLITE_PRIVATE int sqlite3Fts3MsrCancel(Fts3Cursor *pCsr, Fts3Expr *pExpr){
-  int rc = SQLITE_OK;
-  if( pExpr->bEof==0 ){
-    i64 iDocid = pExpr->iDocid;
-    fts3EvalRestart(pCsr, pExpr, &rc);
-    while( rc==SQLITE_OK && pExpr->iDocid!=iDocid ){
-      fts3EvalNextRow(pCsr, pExpr, &rc);
-      if( pExpr->bEof ) rc = FTS_CORRUPT_VTAB;
-    }
-  }
-  return rc;
-}
-
-/*
-** 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( iCol<nCol );
-    }
-
-    fts3EvalUpdateCounts(pExpr->pLeft, 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->iDocid<iDocid && rc==SQLITE_OK );
-      */
-      fts3EvalRestart(pCsr, pRoot, &rc);
-      do {
-        fts3EvalNextRow(pCsr, pRoot, &rc);
-        assert_fts3_nc( pRoot->bEof==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; iCol<pTab->nColumn; 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; iCol<pTab->nColumn; 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 && iCol<pTab->nColumn );
-  if( (pPhrase->iColumn<pTab->nColumn && 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( iThis<iCol ){
-    fts3ColumnlistCopy(0, &pIter);
-    if( *pIter==0x00 ) return SQLITE_OK;
-    pIter++;
-    pIter += fts3GetVarint32(pIter, &iThis);
-  }
-  if( *pIter==0x00 ){
-    pIter = 0;
-  }
-
-  *ppOut = ((iCol==iThis)?pIter:0);
-  return SQLITE_OK;
-}
-
-/*
-** Free all components of the Fts3Phrase structure that were allocated by
-** the eval module. Specifically, this means to free:
-**
-**   * the contents of pPhrase->doclist, 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; i<pPhrase->nToken; 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 !defined(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 <string.h> */
-/* #include <assert.h> */
-
-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; i<SizeofArray(pFts3->aStmt); 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; i<pInfo->nConstraint; 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->iCol<pCsr->nStat; 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->nStop<pCsr->csr.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( i<nDoclist ){
-      sqlite3_int64 v = 0;
-
-      i += sqlite3Fts3GetVarint(&aDoclist[i], &v);
-      switch( eState ){
-        /* State 0. In this state the integer just read was a docid. */
-        case 0:
-          pCsr->aStat[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;
-          /* no break */ deliberate_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( iNext<nVal ){
-    iLangid = iNext++;
-  }
-
-  /* In case this cursor is being reused, close and zero it. */
-  testcase(pCsr->filter.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   */
-     0                            /* xIntegrity    */
-  };
-  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 <string.h> */
-/* #include <assert.h> */
-
-/*
-** 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 *);
-
-/*
-** Search buffer z[], size n, for a '"' character. Or, if enable_parenthesis
-** is defined, search for '(' and ')' as well. Return the index of the first
-** such character in the buffer. If there is no such character, return -1.
-*/
-static int findBarredChar(const char *z, int n){
-  int ii;
-  for(ii=0; ii<n; ii++){
-    if( (z[ii]=='"')
-     || (sqlite3_fts3_enable_parentheses && (z[ii]=='(' || z[ii]==')'))
-    ){
-      return ii;
-    }
-  }
-  return -1;
-}
-
-/*
-** 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;
-
-  *pnConsumed = n;
-  rc = sqlite3Fts3OpenTokenizer(pTokenizer, pParse->iLangid, z, n, &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 ){
-      /* Check that this tokenization did not gobble up any " characters. Or,
-      ** if enable_parenthesis is true, that it did not gobble up any
-      ** open or close parenthesis characters either. If it did, call
-      ** getNextToken() again, but pass only that part of the input buffer
-      ** up to the first such character.  */
-      int iBarred = findBarredChar(z, iEnd);
-      if( iBarred>=0 ){
-        pModule->xClose(pCursor);
-        return getNextToken(pParse, iCol, z, iBarred, ppExpr, pnConsumed);
-      }
-
-      nByte = sizeof(Fts3Expr) + SZ_FTS3PHRASE(1) + 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->aToken[1];
-        memcpy(pRet->pPhrase->aToken[0].z, zToken, nToken);
-
-        if( iEnd<n && z[iEnd]=='*' ){
-          pRet->pPhrase->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( n && rc==SQLITE_DONE ){
-      int iBarred = findBarredChar(z, n);
-      if( iBarred>=0 ){
-        *pnConsumed = iBarred;
-      }
-      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;
-  i64 nTemp = 0;
-
-  const int nSpace = sizeof(Fts3Expr) + SZ_FTS3PHRASE(1);
-  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));
-        zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte);
-        if( !zTemp || !p ){
-          rc = SQLITE_NOMEM;
-          goto getnextstring_out;
-        }
-
-        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 = (iEnd<nInput && zInput[iEnd]=='*');
-        pToken->bFirst = (iBegin>0 && zInput[iBegin-1]=='^');
-        nToken = ii+1;
-      }
-    }
-  }
-
-  if( rc==SQLITE_DONE ){
-    int jj;
-    char *zBuf = 0;
-
-    p = fts3ReallocOrFree(p, nSpace + nToken*sizeof(Fts3PhraseToken) + nTemp);
-    if( !p ){
-      rc = SQLITE_NOMEM;
-      goto getnextstring_out;
-    }
-    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];
-    assert( nTemp==0 || zTemp );
-    if( zTemp ){
-      memcpy(zBuf, zTemp, nTemp);
-    }
-
-    for(jj=0; jj<p->pPhrase->nToken; jj++){
-      p->pPhrase->aToken[jj].z = zBuf;
-      zBuf += p->pPhrase->aToken[jj].n;
-    }
-    rc = SQLITE_OK;
-  }
-
- getnextstring_out:
-  if( pCursor ){
-    pModule->xClose(pCursor);
-  }
-  sqlite3_free(zTemp);
-  if( rc!=SQLITE_OK ){
-    sqlite3_free(p);
-    p = 0;
-  }
-  *ppExpr = p;
-  return rc;
-}
-
-/*
-** 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; ii<nInput && zInput[ii]!='"'; ii++);
-    *pnConsumed = (int)((zInput - z) + ii + 1);
-    if( ii==nInput ){
-      return SQLITE_ERROR;
-    }
-    return getNextString(pParse, &zInput[1], ii-1, ppExpr);
-  }
-
-  if( sqlite3_fts3_enable_parentheses ){
-    if( *zInput=='(' ){
-      int nConsumed = 0;
-      pParse->nNest++;
-#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; ii<pParse->nCol; 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 encountered 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 && iLvl<nMaxDepth; iLvl++){
-            if( apLeaf[iLvl]==0 ){
-              apLeaf[iLvl] = p;
-              p = 0;
-            }else{
-              assert( pFree );
-              pFree->pLeft = 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; i<nMaxDepth; i++){
-            if( apLeaf[i] ){
-              if( p==0 ){
-                p = apLeaf[i];
-                p->pParent = 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; i<nMaxDepth; i++){
-            sqlite3Fts3ExprFree(apLeaf[i]);
-          }
-          while( (pDel=pFree)!=0 ){
-            pFree = pDel->pParent;
-            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 <stdio.h> */
-
-/*
-** 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 && i<pPhrase->nToken; 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(<tokenizer>, <expr>, <column 1>, ...);
-**
-** The first argument, <tokenizer>, 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; ii<nCol; ii++){
-    azCol[ii] = (char *)sqlite3_value_text(argv[ii+2]);
-  }
-
-  if( bRebalance ){
-    char *zDummy = 0;
-    rc = sqlite3Fts3ExprParse(
-        pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
-    );
-    assert( rc==SQLITE_OK || pExpr==0 );
-    sqlite3_free(zDummy);
-  }else{
-    rc = fts3ExprParseUnbalanced(
-        pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
-    );
-  }
-
-  if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){
-    sqlite3_result_error(context, "Error parsing expression", -1);
-  }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
-    sqlite3_result_error_nomem(context);
-  }else{
-    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
-    sqlite3_free(zBuf);
-  }
-
-  sqlite3Fts3ExprFree(pExpr);
-
-exprtest_out:
-  if( pTokenizer ){
-    rc = pTokenizer->pModule->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 <assert.h> */
-/* #include <stdlib.h> */
-/* #include <string.h> */
-
-/* #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 contains "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 <assert.h> */
-/* #include <stdlib.h> */
-/* #include <stdio.h> */
-/* #include <string.h> */
-
-/* #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 precedes 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<nIn; i++){
-    char c = zIn[i];
-    if( c>='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<nIn; i++, j++){
-      zOut[j] = zOut[i];
-    }
-    i = j;
-  }
-  zOut[i] = 0;
-  *pnOut = i;
-}
-
-
-/*
-** Stem the input word zIn[0..nIn-1].  Store the output in zOut.
-** zOut is at least big enough to hold nIn bytes.  Write the actual
-** size of the output word (exclusive of the '\0' terminator) into *pnOut.
-**
-** Any upper-case characters in the US-ASCII character set ([A-Z])
-** are converted to lower case.  Upper-case UTF characters are
-** unchanged.
-**
-** Words that are longer than about 20 bytes are stemmed by retaining
-** a few bytes from the beginning and the end of the word.  If the
-** word contains digits, 3 bytes are taken from the beginning and
-** 3 bytes from the end.  For long words without digits, 10 bytes
-** are taken from each end.  US-ASCII case folding still applies.
-**
-** If the input word contains not digits but does characters not
-** in [a-zA-Z] then no stemming is attempted and this routine just
-** copies the input into the input into the output with US-ASCII
-** case folding.
-**
-** Stemming never increases the length of the word.  So there is
-** no chance of overflowing the zOut buffer.
-*/
-static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
-  int i, j;
-  char zReverse[28];
-  char *z, *z2;
-  if( nIn<3 || nIn>=(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<nIn; i++, j--){
-    char c = zIn[i];
-    if( c>='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->iOffset<c->nInput ){
-    int iStartOffset, ch;
-
-    /* Scan past delimiter characters */
-    while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
-      c->iOffset++;
-    }
-
-    /* Count non-delimiter characters. */
-    iStartOffset = c->iOffset;
-    while( c->iOffset<c->nInput && !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 <assert.h> */
-/* #include <string.h> */
-
-/*
-** 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 <function-name>(<key-name>);
-**   SELECT <function-name>(<key-name>, <pointer>);
-**
-** where <function-name> is the name passed as the second argument
-** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer').
-**
-** If the <pointer> argument is specified, it must be a blob value
-** containing a pointer to be stored as the hash data corresponding
-** to the string <key-name>. If <pointer> is not specified, then
-** the string <key-name> must already exist in the has table. Otherwise,
-** an error is returned.
-**
-** Whether or not the <pointer> argument is specified, the value returned
-** is a blob containing the pointer stored as the hash data corresponding
-** to string <key-name> (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( z<zEnd && (NULL!=(z = (char *)sqlite3Fts3NextToken(z, &n))) ){
-      sqlite3_int64 nNew = sizeof(char *)*(iArg+1);
-      char const **aNew = (const char **)sqlite3_realloc64((void *)aArg, nNew);
-      if( !aNew ){
-        sqlite3_free(zCopy);
-        sqlite3_free((void *)aArg);
-        return SQLITE_NOMEM;
-      }
-      aArg = aNew;
-      aArg[iArg++] = z;
-      z[n] = '\0';
-      sqlite3Fts3Dequote(z);
-      z = &z[n+1];
-    }
-    rc = m->xCreate(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
-
-#include "tclsqlite.h"
-/* #include <string.h> */
-
-/*
-** 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 <function-name>(<key-name>, ..., <input-string>);
-**
-** where <function-name> 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 <input-string>, 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 <input-string> 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; i<argc-1; i++){
-    azArg[i-1] = (const char *)sqlite3_value_text(argv[i]);
-  }
-
-  if( SQLITE_OK!=p->xCreate(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 <assert.h> */
-/* #include <stdlib.h> */
-/* #include <stdio.h> */
-/* #include <string.h> */
-
-/* #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<n; i++){
-      unsigned char ch = argv[1][i];
-      /* We explicitly don't support UTF-8 delimiters for now. */
-      if( ch>=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->iOffset<c->nBytes ){
-    int iStartOffset;
-
-    /* Scan past delimiter characters */
-    while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
-      c->iOffset++;
-    }
-
-    /* Count non-delimiter characters. */
-    iStartOffset = c->iOffset;
-    while( c->iOffset<c->nBytes && !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; i<n; i++){
-        /* TODO(shess) This needs expansion to handle UTF-8
-        ** case-insensitivity.
-        */
-        unsigned char ch = p[iStartOffset+i];
-        c->pToken[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 <tbl> USING fts3tokenize(
-**       <tokenizer-name>, <arg-1>, ...
-**   );
-**
-** The table created has the following schema:
-**
-**   CREATE TABLE <tbl>(input, token, start, end, position)
-**
-** When queried, the query must include a WHERE clause of type:
-**
-**   input = <string>
-**
-** The virtual table module tokenizes this <string>, 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 <string>
-**   token:   A token from the input.
-**   start:   Byte offset of the token within the input <string>.
-**   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 <string.h> */
-/* #include <assert.h> */
-
-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; i<argc; i++){
-      nByte += (int)(strlen(argv[i]) + 1);
-    }
-
-    *pazDequote = azDequote = sqlite3_malloc64(sizeof(char *)*argc + nByte);
-    if( azDequote==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      char *pSpace = (char *)&azDequote[argc];
-      for(i=0; i<argc; i++){
-        int n = (int)strlen(argv[i]);
-        azDequote[i] = pSpace;
-        memcpy(pSpace, argv[i], n+1);
-        sqlite3Fts3Dequote(pSpace);
-        pSpace += (n+1);
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Schema of the tokenizer table.
-*/
-#define FTS3_TOK_SCHEMA "CREATE TABLE x(input, token, start, end, position)"
-
-/*
-** 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.
-**
-**   argv[0]: module name
-**   argv[1]: database name
-**   argv[2]: table name
-**   argv[3]: first argument (tokenizer name)
-*/
-static int fts3tokConnectMethod(
-  sqlite3 *db,                    /* Database connection */
-  void *pHash,                    /* Hash table of tokenizers */
-  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 */
-){
-  Fts3tokTable *pTab = 0;
-  const sqlite3_tokenizer_module *pMod = 0;
-  sqlite3_tokenizer *pTok = 0;
-  int rc;
-  char **azDequote = 0;
-  int nDequote;
-
-  rc = sqlite3_declare_vtab(db, FTS3_TOK_SCHEMA);
-  if( rc!=SQLITE_OK ) return rc;
-
-  nDequote = argc-3;
-  rc = fts3tokDequoteArray(nDequote, &argv[3], &azDequote);
-
-  if( rc==SQLITE_OK ){
-    const char *zModule;
-    if( nDequote<1 ){
-      zModule = "simple";
-    }else{
-      zModule = azDequote[0];
-    }
-    rc = fts3tokQueryTokenizer((Fts3Hash*)pHash, zModule, &pMod, pzErr);
-  }
-
-  assert( (rc==SQLITE_OK)==(pMod!=0) );
-  if( rc==SQLITE_OK ){
-    const char * const *azArg = 0;
-    if( nDequote>1 ) 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; i<pInfo->nConstraint; 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]);
-    sqlite3_int64 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   */
-     0                            /* xIntegrity    */
-  };
-  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 <string.h> */
-/* #include <assert.h> */
-/* #include <stdlib.h> */
-/* #include <stdio.h> */
-
-#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 {
-  sqlite3_int64 nData;
-  char *aData;
-  sqlite3_int64 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
-
-/*
-** Wrapper around sqlite3_prepare_v3() to ensure that SQLITE_PREPARE_FROM_DDL
-** is always set.
-*/
-SQLITE_PRIVATE int sqlite3Fts3PrepareStmt(
-  Fts3Table *p,                   /* Prepare for this connection */
-  const char *zSql,               /* SQL to prepare */
-  int bPersist,                   /* True to set SQLITE_PREPARE_PERSISTENT */
-  int bAllowVtab,                 /* True to omit SQLITE_PREPARE_NO_VTAB */
-  sqlite3_stmt **pp               /* OUT: Prepared statement */
-){
-  int f = SQLITE_PREPARE_FROM_DDL
-         |((bAllowVtab==0) ? SQLITE_PREPARE_NO_VTAB : 0)
-         |(bPersist ? SQLITE_PREPARE_PERSISTENT : 0);
-
-  return sqlite3_prepare_v3(p->db, zSql, -1, f, pp, NULL);
-}
-
-/*
-** 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<SizeofArray(azSql) && eStmt>=0 );
-
-  pStmt = p->aStmt[eStmt];
-  if( !pStmt ){
-    int bAllowVtab = 0;
-    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 ){
-      bAllowVtab = 1;
-      zSql = sqlite3_mprintf(azSql[eStmt], p->zReadExprlist);
-    }else{
-      zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
-    }
-    if( !zSql ){
-      rc = SQLITE_NOMEM;
-    }else{
-      rc = sqlite3Fts3PrepareStmt(p, zSql, 1, bAllowVtab, &pStmt);
-      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 && i<nParam; i++){
-      rc = sqlite3_bind_value(pStmt, i+1, apVal[i]);
-    }
-  }
-  *pp = pStmt;
-  return rc;
-}
-
-
-static int fts3SelectDocsize(
-  Fts3Table *pTab,                /* FTS3 table handle */
-  sqlite3_int64 iDocid,           /* Docid to bind for SQL_SELECT_DOCSIZE */
-  sqlite3_stmt **ppStmt           /* OUT: Statement handle */
-){
-  sqlite3_stmt *pStmt = 0;        /* Statement requested from fts3SqlStmt() */
-  int rc;                         /* Return code */
-
-  rc = fts3SqlStmt(pTab, SQL_SELECT_DOCSIZE, &pStmt, 0);
-  if( rc==SQLITE_OK ){
-    sqlite3_bind_int64(pStmt, 1, iDocid);
-    rc = sqlite3_step(pStmt);
-    if( rc!=SQLITE_ROW || sqlite3_column_type(pStmt, 0)!=SQLITE_BLOB ){
-      rc = sqlite3_reset(pStmt);
-      if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
-      pStmt = 0;
-    }else{
-      rc = SQLITE_OK;
-    }
-  }
-
-  *ppStmt = pStmt;
-  return rc;
-}
-
-SQLITE_PRIVATE int sqlite3Fts3SelectDoctotal(
-  Fts3Table *pTab,                /* Fts3 table handle */
-  sqlite3_stmt **ppStmt           /* OUT: Statement handle */
-){
-  sqlite3_stmt *pStmt = 0;
-  int rc;
-  rc = fts3SqlStmt(pTab, SQL_SELECT_STAT, &pStmt, 0);
-  if( rc==SQLITE_OK ){
-    sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL);
-    if( sqlite3_step(pStmt)!=SQLITE_ROW
-     || sqlite3_column_type(pStmt, 0)!=SQLITE_BLOB
-    ){
-      rc = sqlite3_reset(pStmt);
-      if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
-      pStmt = 0;
-    }
-  }
-  *ppStmt = pStmt;
-  return rc;
-}
-
-SQLITE_PRIVATE int sqlite3Fts3SelectDocsize(
-  Fts3Table *pTab,                /* Fts3 table handle */
-  sqlite3_int64 iDocid,           /* Docid to read size data for */
-  sqlite3_stmt **ppStmt           /* OUT: Statement handle */
-){
-  return fts3SelectDocsize(pTab, iDocid, ppStmt);
-}
-
-/*
-** Similar to fts3SqlStmt(). Except, after binding the parameters in
-** array apVal[] to the SQL statement identified by eStmt, the statement
-** is executed.
-**
-** Returns SQLITE_OK if the statement is successfully executed, or an
-** SQLite error code otherwise.
-*/
-static void fts3SqlExec(
-  int *pRC,                /* Result code */
-  Fts3Table *p,            /* The FTS3 table */
-  int eStmt,               /* Index of statement to evaluate */
-  sqlite3_value **apVal    /* Parameters to bind */
-){
-  sqlite3_stmt *pStmt;
-  int rc;
-  if( *pRC ) return;
-  rc = fts3SqlStmt(p, eStmt, &pStmt, apVal);
-  if( rc==SQLITE_OK ){
-    sqlite3_step(pStmt);
-    rc = sqlite3_reset(pStmt);
-  }
-  *pRC = rc;
-}
-
-
-/*
-** This function ensures that the caller has obtained an exclusive
-** shared-cache table-lock on the %_segdir table. This is required before
-** writing data to the fts3 table. If this lock is not acquired first, then
-** the caller may end up attempting to take this lock as part of committing
-** a transaction, causing SQLite to return SQLITE_LOCKED or
-** LOCKED_SHAREDCACHEto a COMMIT command.
-**
-** It is best to avoid this because if FTS3 returns any error when
-** committing a transaction, the whole transaction will be rolled back.
-** And this is not what users expect when they get SQLITE_LOCKED_SHAREDCACHE.
-** It can still happen if the user locks the underlying tables directly
-** instead of accessing them via FTS.
-*/
-static int fts3Writelock(Fts3Table *p){
-  int rc = SQLITE_OK;
-
-  if( p->nPendingData==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 && iIndex<p->nIndex );
-
-  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<FTS3_SEGDIR_MAXLEVEL );
-  assert( iIndex>=0 && iIndex<p->nIndex );
-
-  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->nData<p->nSpace );
-      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 ){
-    assert( (i64)pList->nData+(i64)nToken+(i64)sizeof(Fts3HashElem)
-             <= (i64)p->nPendingData );
-    p->nPendingData -= (int)(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 ){
-    assert( (i64)p->nPendingData + pList->nData + nToken
-             + sizeof(Fts3HashElem) <= 0x3fffffff );
-    p->nPendingData += (int)(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 && i<p->nIndex; i++){
-      struct Fts3Index *pIndex = &p->aIndex[i];
-      if( nToken<pIndex->nPrefix ) 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( iDocid<p->iPrevDocid
-   || (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; i<p->nIndex; 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; i<p->nColumn+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->nPopulate<pReader->nNode ){
-      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)<nSuffix
-   || nPrefix>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 && *p==0 ) p++;
-
-    /* If there are no more entries in the doclist, set pOffsetList to
-    ** NULL. Otherwise, set Fts3SegReader.iDocid to the next docid and
-    ** Fts3SegReader.pOffsetList to point to the next offset list before
-    ** returning.
-    */
-    if( 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 && ii<pMsr->nSegment; 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 = (n1<n2 ? n1 : n2);
-  int c = memcmp(z1, z2, n);
-  if( c==0 ){
-    c = n1 - n2;
-  }
-  return c;
-}
-
-/*
-** This function is used to allocate an Fts3SegReader that iterates through
-** a subset of the terms stored in the Fts3Table.pendingTerms array.
-**
-** If the isPrefixIter parameter is zero, then the returned SegReader iterates
-** through each term in the pending-terms table. Or, if isPrefixIter is
-** non-zero, it iterates through each term and its prefixes. For example, if
-** the pending terms hash table contains the terms "sqlite", "mysql" and
-** "firebird", then the iterator visits the following 'terms' (in the order
-** shown):
-**
-**   f fi fir fire fireb firebi firebir firebird
-**   m my mys mysq mysql
-**   s sq sql sqli sqlit sqlite
-**
-** Whereas if isPrefixIter is zero, the terms visited are:
-**
-**   firebird mysql sqlite
-*/
-SQLITE_PRIVATE int sqlite3Fts3SegReaderPending(
-  Fts3Table *p,                   /* Virtual table handle */
-  int iIndex,                     /* Index for p->aIndex */
-  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; n<nPrev && n<nNext && zPrev[n]==zNext[n]; n++);
-  assert_fts3_nc( n<nNext );
-  return n;
-}
-
-/*
-** Add term zTerm to the SegmentNode. It is guaranteed that zTerm is larger
-** (according to memcmp) than the previous term.
-*/
-static int fts3NodeAddTerm(
-  Fts3Table *p,                   /* Virtual table handle */
-  SegmentNode **ppTree,           /* IN/OUT: SegmentNode handle */
-  int isCopyTerm,                 /* True if zTerm/nTerm is transient */
-  const char *zTerm,              /* Pointer to buffer containing term */
-  int nTerm                       /* Size of term in bytes */
-){
-  SegmentNode *pTree = *ppTree;
-  int rc;
-  SegmentNode *pNew;
-
-  /* First try to append the term to the current node. Return early if
-  ** this is possible.
-  */
-  if( pTree ){
-    int nData = pTree->nData;     /* 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->nMalloc<nTerm ){
-          char *zNew = sqlite3_realloc64(pTree->zMalloc, (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( nPrefix<nTerm );
-    rc = fts3NodeAddTerm(p, &pWriter->pTree, 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 && iIndex<p->nIndex );
-
-  /* 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<nReader; i++){
-    rc = fts3DeleteSegment(p, apSegment[i]);
-  }
-  if( rc!=SQLITE_OK ){
-    return rc;
-  }
-
-  assert( iLevel>=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( p<pEnd && (c | *p)&0xFE ) c = *p++ & 0x80;
-
-    if( iCol==iCurrent ){
-      nList = (int)(p - pList);
-      break;
-    }
-
-    nList -= (int)(p - pList);
-    pList = p;
-    if( nList<=0 ){
-      break;
-    }
-    p = &pList[1];
-    p += fts3GetVarint32(p, &iCurrent);
-  }
-
-  if( bZero && (pEnd - &pList[nList])>0){
-    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
-        && j<nMerge
-        && apSegment[j]->pOffsetList
-        && 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 && i<pCsr->nSegment; 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; i<nSegment; i++){
-    Fts3SegReader *pSeg = pCsr->apSegment[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; i<pCsr->nAdvance; i++){
-    rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]);
-    if( rc!=SQLITE_OK ) return rc;
-  }
-  fts3SegReaderSort(pCsr->apSegment, i, i, xCmp);
-
-  assert( iCol<0 || iCol<p->nColumn );
-  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; i<pCsr->nSegment; 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; i<pCsr->nAdvance; 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->nTerm<pFilter->nTerm
-       || (!isPrefix && pCsr->nTerm>pFilter->nTerm)
-       || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm)
-      ){
-        break;
-      }
-    }
-
-    nMerge = 1;
-    while( nMerge<nSegment
-        && apSegment[nMerge]->aNode
-        && 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; i<nMerge; i++){
-        fts3SegReaderFirstDocid(p, apSegment[i]);
-      }
-      fts3SegReaderSort(apSegment, nMerge, nMerge, xCmp);
-      while( apSegment[0]->pOffsetList ){
-        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( j<nMerge
-            && apSegment[j]->pOffsetList
-            && 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; i<pCsr->nSegment; 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<FTS3_SEGDIR_MAXLEVEL );
-  assert( iIndex>=0 && iIndex<p->nIndex );
-
-  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(
-    iNewLevel<getAbsoluteLevel(p, iLangid, iIndex,FTS3_SEGDIR_MAXLEVEL)
-  );
-
-  memset(&filter, 0, sizeof(Fts3SegFilter));
-  filter.flags = FTS3_SEGMENT_REQUIRE_POS;
-  filter.flags |= (bIgnoreEmpty ? FTS3_SEGMENT_IGNORE_EMPTY : 0);
-
-  rc = sqlite3Fts3SegReaderStart(p, &csr, &filter);
-  while( SQLITE_OK==rc ){
-    rc = sqlite3Fts3SegReaderStep(p, &csr);
-    if( rc!=SQLITE_ROW ) break;
-    rc = fts3SegWriterAdd(p, &pWriter, 1,
-        csr.zTerm, csr.nTerm, csr.aDoclist, csr.nDoclist);
-  }
-  if( rc!=SQLITE_OK ) goto finished;
-  assert_fts3_nc( pWriter || bIgnoreEmpty );
-
-  if( iLevel!=FTS3_SEGCURSOR_PENDING ){
-    rc = fts3DeleteSegdir(
-        p, iLangid, iIndex, iLevel, csr.apSegment, csr.nSegment
-    );
-    if( rc!=SQLITE_OK ) goto finished;
-  }
-  if( pWriter ){
-    rc = fts3SegWriterFlush(p, pWriter, iNewLevel, iIdx);
-    if( rc==SQLITE_OK ){
-      if( iLevel==FTS3_SEGCURSOR_PENDING || iNewLevel<iMaxLevel ){
-        rc = fts3PromoteSegments(p, iNewLevel, pWriter->nLeafData);
-      }
-    }
-  }
-
- 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 && i<p->nIndex; i++){
-    rc = fts3SegmentMerge(p, p->iPrevLangid, i, FTS3_SEGCURSOR_PENDING);
-    if( rc==SQLITE_DONE ) rc = SQLITE_OK;
-  }
-
-  /* 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);
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    sqlite3Fts3PendingTermsClear(p);
-  }
-  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; i<N; i++){
-    j += sqlite3Fts3PutVarint(&zBuf[j], (sqlite3_int64)a[i]);
-  }
-  *pNBuf = j;
-}
-
-/*
-** Decode a blob of varints into N integers
-*/
-static void fts3DecodeIntArray(
-  int N,             /* The number of integers to decode */
-  u32 *a,            /* Write the integer values */
-  const char *zBuf,  /* The BLOB containing the varints */
-  int nBuf           /* size of the BLOB */
-){
-  int i = 0;
-  if( nBuf && (zBuf[nBuf-1]&0x80)==0 ){
-    int j;
-    for(i=j=0; i<N && j<nBuf; i++){
-      sqlite3_int64 x;
-      j += sqlite3Fts3GetVarint(&zBuf[j], &x);
-      a[i] = (u32)(x & 0xffffffff);
-    }
-  }
-  while( i<N ) a[i++] = 0;
-}
-
-/*
-** Insert the sizes (in tokens) for each column of the document
-** with docid equal to p->iPrevDocid.  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; i<p->nColumn+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 && i<p->nIndex; 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 <tbl>(<tbl>) 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 = sqlite3Fts3PrepareStmt(p, zSql, 0, 1, &pStmt);
-      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 && iCol<p->nColumn; 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 && i<nSeg; i++){
-      rc = sqlite3Fts3SegReaderNew(i, 0,
-          sqlite3_column_int64(pStmt, 1),        /* segdir.start_block */
-          sqlite3_column_int64(pStmt, 2),        /* segdir.leaves_end_block */
-          sqlite3_column_int64(pStmt, 3),        /* segdir.end_block */
-          sqlite3_column_blob(pStmt, 4),         /* segdir.root */
-          sqlite3_column_bytes(pStmt, 4),        /* segdir.root */
-          &pCsr->apSegment[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 {
-  i64 nLeafEst;                   /* Space allocated for leaf blocks */
-  i64 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)<p->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(iLayer<FTS_MAX_APPENDABLE_HEIGHT); iLayer++){
-    sqlite3_int64 iNextPtr = 0;
-    NodeWriter *pNode = &pWriter->aNodeWriter[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 required.
-**
-** 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;
-  assert( pPrev!=0 );
-  assert( pPrev->a!=0 );
-
-  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,
-  ** and if there is still room for another leaf page, write this block out to
-  ** the database. */
-  if( pLeaf->block.n>0
-   && (pLeaf->block.n + nSpace)>p->nNodeSize
-   && pLeaf->iBlock < (pWriter->iStart + pWriter->nLeafEst)
-  ){
-    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; i<iRoot; i++){
-    NodeWriter *pNode = &pWriter->aNodeWriter[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; i<FTS_MAX_APPENDABLE_HEIGHT; i++){
-        pWriter->aNodeWriter[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;
-        memset(&reader, 0, sizeof(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 */
-  i64 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_int64(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; i<FTS_MAX_APPENDABLE_HEIGHT; i++){
-    pWriter->aNodeWriter[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 && i<nIdx; i++){
-    if( aIdx[i]!=i ){
-      sqlite3_bind_int(pUpdate, 3, aIdx[i]);
-      sqlite3_bind_int(pUpdate, 1, i);
-      sqlite3_step(pUpdate);
-      rc = sqlite3_reset(pUpdate);
-    }
-  }
-  p->bIgnoreSavepoint = 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(j<pCsr->nSegment); j++){
-      pSeg = pCsr->apSegment[j];
-      if( pSeg->iIdx==i ) break;
-    }
-    assert( j<pCsr->nSegment && 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; i<nTerm; i++) ret += (ret<<3) + zTerm[i];
-
-  return ret;
-}
-
-/*
-** Return a checksum of all entries in the FTS index that correspond to
-** language id iLangid. The checksum is calculated by XORing the checksums
-** of each individual entry (see fts3ChecksumEntry()) together.
-**
-** If successful, the checksum value is returned and *pRc set to SQLITE_OK.
-** Otherwise, if an error occurs, *pRc is set to an SQLite error code. The
-** return value is undefined in this case.
-*/
-static u64 fts3ChecksumIndex(
-  Fts3Table *p,                   /* FTS3 table handle */
-  int iLangid,                    /* Language id to return cksum for */
-  int iIndex,                     /* Index to cksum (0..p->nIndex-1) */
-  int *pRc                        /* OUT: Return code */
-){
-  Fts3SegFilter filter;
-  Fts3MultiSegReader csr;
-  int rc;
-  u64 cksum = 0;
-
-  if( *pRc ) return 0;
-
-  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( pCsr<pEnd ){
-        u64 iVal = 0;
-        pCsr += sqlite3Fts3GetVarintU(pCsr, &iVal);
-        if( pCsr<pEnd ){
-          if( iVal==0 || iVal==1 ){
-            iCol = 0;
-            iPos = 0;
-            if( iVal ){
-              pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
-            }else{
-              pCsr += sqlite3Fts3GetVarintU(pCsr, &iVal);
-              if( p->bDescIdx ){
-                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.
-*/
-SQLITE_PRIVATE int sqlite3Fts3IntegrityCheck(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; i<p->nIndex; 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 = sqlite3Fts3PrepareStmt(p, zSql, 0, 1, &pStmt);
-      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 && iCol<p->nColumn; 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; i<p->nIndex; 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);
-  }
-
-  if( rc==SQLITE_CORRUPT_VTAB ){
-    rc = SQLITE_OK;
-    *pbOk = 0;
-  }else{
-    *pbOk = (rc==SQLITE_OK && 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 = sqlite3Fts3IntegrityCheck(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(<expr>)"
-**
-** Argument pVal contains the result of <expr>. 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]);
-  }else if( nVal==5 && 0==sqlite3_strnicmp(zVal, "flush", 5) ){
-    rc = sqlite3Fts3PendingTermsFlush(p);
-  }
-#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=", 11) ){
-      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; i<p->nColumn && 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->n<nToken))
-                && (0==memcmp(zToken, pPT->z, 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 subsidiary 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 <table name>(
-**       <user columns>,
-**       <table name> HIDDEN,
-**       docid HIDDEN,
-**       <langid> 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 <string.h> */
-/* #include <assert.h> */
-
-/*
-** 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 aMI[FLEXARRAY];
-};
-
-/* Size (in bytes) of a MatchinfoBuffer sufficient for N elements */
-#define SZ_MATCHINFOBUFFER(N) \
-            (offsetof(MatchinfoBuffer,aMI)+(((N)+1)/2)*sizeof(u64))
-
-
-/*
-** 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)
-                           + SZ_MATCHINFOBUFFER(1);
-  sqlite3_int64 nStr = strlen(zMatchinfo);
-
-  pRet = sqlite3Fts3MallocZero(nByte + nStr+1);
-  if( pRet ){
-    pRet->aMI[0] = (u8*)(&pRet->aMI[1]) - (u8*)pRet;
-    pRet->aMI[1+nElem] = pRet->aMI[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->aMI[1]
-       || (u32*)p==&pBuf->aMI[pBuf->nElem+2]
-  );
-  if( (u32*)p==&pBuf->aMI[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->aMI[1];
-    xRet = fts3MIBufferFree;
-  }
-  else if( p->aRef[2]==0 ){
-    p->aRef[2] = 1;
-    aOut = &p->aMI[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->aMI[1], p->nElem*sizeof(u32));
-    }
-  }
-
-  *paOut = aOut;
-  return xRet;
-}
-
-static void fts3MIBufferSetGlobal(MatchinfoBuffer *p){
-  p->bGlobal = 1;
-  memcpy(&p->aMI[2+p->nElem], &p->aMI[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( iIter<iNext ){
-      if( 0==(*pIter & 0xFE) ){
-        iIter = -1;
-        pIter = 0;
-        break;
-      }
-      fts3GetDeltaPosition(&pIter, &iIter);
-    }
-
-    *piIter = iIter;
-    *ppIter = pIter;
-  }
-}
-
-/*
-** Advance the snippet iterator to the next candidate snippet.
-*/
-static int fts3SnippetNextCandidate(SnippetIter *pIter){
-  int i;                          /* Loop counter */
-
-  if( pIter->iCurrent<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; i<pIter->nPhrase; i++){
-      SnippetPhrase *pPhrase = &pIter->aPhrase[i];
-      fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet);
-    }
-  }else{
-    int iStart;
-    int iEnd = 0x7FFFFFFF;
-
-    for(i=0; i<pIter->nPhrase; i++){
-      SnippetPhrase *pPhrase = &pIter->aPhrase[i];
-      if( pPhrase->pHead && pPhrase->iHead<iEnd ){
-        iEnd = pPhrase->iHead;
-      }
-    }
-    if( iEnd==0x7FFFFFFF ){
-      return 1;
-    }
-
-    assert( pIter->nSnippet>=0 );
-    pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
-    for(i=0; i<pIter->nPhrase; 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; i<pIter->nPhrase; 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; j<pPhrase->nToken && j<pIter->nSnippet; 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; i<nList; i++){
-      if( sIter.aPhrase[i].pHead ){
-        *pmSeen |= (u64)1 << (i%64);
-      }
-    }
-
-    /* Loop through all candidate snippets. Store the best snippet in
-     ** *pFragment. Store its associated 'score' in iBestScore.
-     */
-    pFragment->iCol = 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 accommodate 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( iCurrent<iPos ){ continue; }
-
-    if( !isShiftDone ){
-      int n = nDoc - iBegin;
-      rc = fts3SnippetShift(
-          pTab, pCsr->iLangid, 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 ) continue;
-    }
-
-    if( 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; iCol<nCol; iCol++){
-**     aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
-**     aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
-**   }
-**
-** where X is the number of matches for phrase iPhrase is column iCol of all
-** rows of the table. Y is the number of rows for which column iCol contains
-** at least one instance of phrase iPhrase.
-**
-** If the phrase pExpr consists entirely of deferred tokens, then all X and
-** Y values are set to nDoc, where nDoc is the number of documents in the
-** file system. This is done because the full-text index doclist is required
-** to calculate these values properly, and the full-text index doclist is
-** not available for deferred tokens.
-*/
-static int fts3ExprGlobalHitsCb(
-  Fts3Expr *pExpr,                /* Phrase expression node */
-  int iPhrase,                    /* Phrase number (numbered from zero) */
-  void *pCtx                      /* Pointer to MatchInfo structure */
-){
-  MatchInfo *p = (MatchInfo *)pCtx;
-  return sqlite3Fts3EvalPhraseStats(
-      p->pCursor, 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; i<p->nCol && 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 = (size_t)pInfo->nCol * pInfo->nPhrase;
-      break;
-
-    case FTS3_MATCHINFO_LHITS_BM:
-      nVal = (size_t)pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
-      break;
-
-    default:
-      assert( cArg==FTS3_MATCHINFO_HITS );
-      nVal = (size_t)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; i<pInfo->nPhrase; i++){
-    LcsIterator *pIter = &aIter[i];
-    nToken -= pIter->pExpr->pPhrase->nToken;
-    pIter->iPosOffset = nToken;
-  }
-
-  for(iCol=0; iCol<pInfo->nCol; iCol++){
-    int nLcs = 0;                 /* LCS value for this column */
-    int nLive = 0;                /* Number of iterators in aIter not at EOF */
-
-    for(i=0; i<pInfo->nPhrase; 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; i<pInfo->nPhrase; 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->iPos<pAdv->iPos ){
-            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; iCol<pInfo->nCol; 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; iCol<pInfo->nCol; 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 - "<b>" */
-  const char *zEnd,               /* Snippet end text - "</b>" */
-  const char *zEllipsis,          /* Snippet ellipsis text - "<b>...</b>" */
-  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; iSnip<nSnippet; iSnip++){
-      int iBestScore = -1;        /* Best score of columns checked so far */
-      int iRead;                  /* Used to iterate through columns */
-      SnippetFragment *pFragment = &aSnippet[iSnip];
-
-      memset(pFragment, 0, sizeof(*pFragment));
-
-      /* Loop through all columns of the table being considered for snippets.
-      ** If the iCol argument to this function was negative, this means all
-      ** columns of the FTS3 table. Otherwise, only column iCol is considered.
-      */
-      for(iRead=0; iRead<pTab->nColumn; 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; i<nSnippet && rc==SQLITE_OK; i++){
-    rc = fts3SnippetText(pCsr, &aSnippet[i],
-        i, (i==nSnippet-1), nFToken, zStart, zEnd, zEllipsis, &res
-    );
-  }
-
- snippet_out:
-  sqlite3Fts3SegmentsClose(pTab);
-  if( rc!=SQLITE_OK ){
-    sqlite3_result_error_code(pCtx, rc);
-    sqlite3_free(res.z);
-  }else{
-    sqlite3_result_text(pCtx, res.z, -1, sqlite3_free);
-  }
-}
-
-
-typedef struct TermOffset TermOffset;
-typedef struct TermOffsetCtx TermOffsetCtx;
-
-struct TermOffset {
-  char *pList;                    /* Position-list */
-  i64 iPos;                       /* Position just read from pList */
-  i64 iOff;                       /* Offset of this term from read positions */
-};
-
-struct TermOffsetCtx {
-  Fts3Cursor *pCsr;
-  int iCol;                       /* Column of table to populate aTerm for */
-  int iTerm;
-  sqlite3_int64 iDocid;
-  TermOffset *aTerm;
-};
-
-/*
-** This function is an sqlite3Fts3ExprIterate() callback used by sqlite3Fts3Offsets().
-*/
-static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
-  TermOffsetCtx *p = (TermOffsetCtx *)ctx;
-  int nTerm;                      /* Number of tokens in phrase */
-  int iTerm;                      /* For looping through nTerm phrase terms */
-  char *pList;                    /* Pointer to position list for phrase */
-  i64 iPos = 0;                   /* First position in position-list */
-  int rc;
-
-  UNUSED_PARAMETER(iPhrase);
-  rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
-  nTerm = pExpr->pPhrase->nToken;
-  if( pList ){
-    fts3GetDeltaPosition(&pList, &iPos);
-    assert_fts3_nc( iPos>=0 );
-  }
-
-  for(iTerm=0; iTerm<nTerm; iTerm++){
-    TermOffset *pT = &p->aTerm[p->iTerm++];
-    pT->iOff = nTerm-iTerm-1;
-    pT->pList = pList;
-    pT->iPos = iPos;
-  }
-
-  return rc;
-}
-
-/*
-** If expression pExpr is a phrase expression that uses an MSR query,
-** restart it as a regular, non-incremental query. Return SQLITE_OK
-** if successful, or an SQLite error code otherwise.
-*/
-static int fts3ExprRestartIfCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
-  TermOffsetCtx *p = (TermOffsetCtx*)ctx;
-  int rc = SQLITE_OK;
-  UNUSED_PARAMETER(iPhrase);
-  if( pExpr->pPhrase && pExpr->pPhrase->bIncr ){
-    rc = sqlite3Fts3MsrCancel(p->pCsr, pExpr);
-    pExpr->pPhrase->bIncr = 0;
-  }
-  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;
-
-  /* If a query restart will be required, do it here, rather than later of
-  ** after pointers to poslist buffers that may be invalidated by a restart
-  ** have been saved.  */
-  rc = sqlite3Fts3ExprIterate(pCsr->pExpr, fts3ExprRestartIfCb, (void*)&sCtx);
-  if( rc!=SQLITE_OK ) goto offsets_out;
-
-  /* Loop through the table columns, appending offset information to
-  ** string-buffer res for each column.
-  */
-  for(iCol=0; iCol<pTab->nColumn; 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; i<nToken; i++){
-        TermOffset *pT = &sCtx.aTerm[i];
-        if( pT->pList && (pT->iPos-pT->iOff)<iMinPos ){
-          iMinPos = pT->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 && iCurrent<iMinPos ){
-          rc = pMod->xNext(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 <assert.h> */
-/* #include <stdlib.h> */
-/* #include <stdio.h> */
-/* #include <string.h> */
-
-/* #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( z<zTerm ){
-    READ_UTF8(z, zTerm, iCode);
-    assert( (sqlite3FtsUnicodeIsalnum((int)iCode) & 0xFFFFFFFE)==0 );
-    if( sqlite3FtsUnicodeIsalnum((int)iCode)!=bAlnum
-     && sqlite3FtsUnicodeIsdiacritic((int)iCode)==0
-    ){
-      nEntry++;
-    }
-  }
-
-  if( nEntry ){
-    int *aNew;                    /* New aiException[] array */
-    int nNew;                     /* Number of valid entries in array aNew[] */
-
-    aNew = sqlite3_realloc64(p->aiException,(p->nException+nEntry)*sizeof(int));
-    if( aNew==0 ) return SQLITE_NOMEM;
-    nNew = p->nException;
-
-    z = (const unsigned char *)zIn;
-    while( z<zTerm ){
-      READ_UTF8(z, zTerm, iCode);
-      if( sqlite3FtsUnicodeIsalnum((int)iCode)!=bAlnum
-       && sqlite3FtsUnicodeIsdiacritic((int)iCode)==0
-      ){
-        int i, j;
-        for(i=0; i<nNew && aNew[i]<(int)iCode; i++);
-        for(j=nNew; j>i; 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 && i<nArg; i++){
-    const char *z = azArg[i];
-    int n = (int)strlen(z);
-
-    if( n==19 && memcmp("remove_diacritics=1", z, 19)==0 ){
-      pNew->eRemoveDiacritic = 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 ){
-    READ_UTF8(z, zTerm, iCode);
-    if( unicodeIsAlnum(p, (int)iCode) ) break;
-    zStart = z;
-  }
-  if( zStart>=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 <assert.h> */
-
-/*
-** 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]<key );
-    assert( key>=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.
-**
-******************************************************************************
-**
-** 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.
-**
-** The original design stored all JSON as pure text, canonical RFC-8259.
-** Support for JSON-5 extensions was added with version 3.42.0 (2023-05-16).
-** All generated JSON text still conforms strictly to RFC-8259, but text
-** with JSON-5 extensions is accepted as input.
-**
-** Beginning with version 3.45.0 (circa 2024-01-01), these routines also
-** accept BLOB values that have JSON encoded using a binary representation
-** called "JSONB".  The name JSONB comes from PostgreSQL, however the on-disk
-** format for SQLite-JSONB is completely different and incompatible with
-** PostgreSQL-JSONB.
-**
-** Decoding and interpreting JSONB is still O(N) where N is the size of
-** the input, the same as text JSON.  However, the constant of proportionality
-** for JSONB is much smaller due to faster parsing.  The size of each
-** element in JSONB is encoded in its header, so there is no need to search
-** for delimiters using persnickety syntax rules.  JSONB seems to be about
-** 3x faster than text JSON as a result.  JSONB is also tends to be slightly
-** smaller than text JSON, by 5% or 10%, but there are corner cases where
-** JSONB can be slightly larger.  So you are not far mistaken to say that
-** a JSONB blob is the same size as the equivalent RFC-8259 text.
-**
-**
-** THE JSONB ENCODING:
-**
-** Every JSON element is encoded in JSONB as a header and a payload.
-** The header is between 1 and 9 bytes in size.  The payload is zero
-** or more bytes.
-**
-** The lower 4 bits of the first byte of the header determines the
-** element type:
-**
-**    0:   NULL
-**    1:   TRUE
-**    2:   FALSE
-**    3:   INT        -- RFC-8259 integer literal
-**    4:   INT5       -- JSON5 integer literal
-**    5:   FLOAT      -- RFC-8259 floating point literal
-**    6:   FLOAT5     -- JSON5 floating point literal
-**    7:   TEXT       -- Text literal acceptable to both SQL and JSON
-**    8:   TEXTJ      -- Text containing RFC-8259 escapes
-**    9:   TEXT5      -- Text containing JSON5 and/or RFC-8259 escapes
-**   10:   TEXTRAW    -- Text containing unescaped syntax characters
-**   11:   ARRAY
-**   12:   OBJECT
-**
-** The other three possible values (13-15) are reserved for future
-** enhancements.
-**
-** The upper 4 bits of the first byte determine the size of the header
-** and sometimes also the size of the payload.  If X is the first byte
-** of the element and if X>>4 is between 0 and 11, then the payload
-** will be that many bytes in size and the header is exactly one byte
-** in size.  Other four values for X>>4 (12-15) indicate that the header
-** is more than one byte in size and that the payload size is determined
-** by the remainder of the header, interpreted as a unsigned big-endian
-** integer.
-**
-**   Value of X>>4         Size integer        Total header size
-**   -------------     --------------------    -----------------
-**        12           1 byte (0-255)                2
-**        13           2 byte (0-65535)              3
-**        14           4 byte (0-4294967295)         5
-**        15           8 byte (0-1.8e19)             9
-**
-** The payload size need not be expressed in its minimal form.  For example,
-** if the payload size is 10, the size can be expressed in any of 5 different
-** ways: (1) (X>>4)==10, (2) (X>>4)==12 following by one 0x0a byte,
-** (3) (X>>4)==13 followed by 0x00 and 0x0a, (4) (X>>4)==14 followed by
-** 0x00 0x00 0x00 0x0a, or (5) (X>>4)==15 followed by 7 bytes of 0x00 and
-** a single byte of 0x0a.  The shorter forms are preferred, of course, but
-** sometimes when generating JSONB, the payload size is not known in advance
-** and it is convenient to reserve sufficient header space to cover the
-** largest possible payload size and then come back later and patch up
-** the size when it becomes known, resulting in a non-minimal encoding.
-**
-** The value (X>>4)==15 is not actually used in the current implementation
-** (as SQLite is currently unable to handle BLOBs larger than about 2GB)
-** but is included in the design to allow for future enhancements.
-**
-** The payload follows the header.  NULL, TRUE, and FALSE have no payload and
-** their payload size must always be zero.  The payload for INT, INT5,
-** FLOAT, FLOAT5, TEXT, TEXTJ, TEXT5, and TEXTROW is text.  Note that the
-** "..." or '...' delimiters are omitted from the various text encodings.
-** The payload for ARRAY and OBJECT is a list of additional elements that
-** are the content for the array or object.  The payload for an OBJECT
-** must be an even number of elements.  The first element of each pair is
-** the label and must be of type TEXT, TEXTJ, TEXT5, or TEXTRAW.
-**
-** A valid JSONB blob consists of a single element, as described above.
-** Usually this will be an ARRAY or OBJECT element which has many more
-** elements as its content.  But the overall blob is just a single element.
-**
-** Input validation for JSONB blobs simply checks that the element type
-** code is between 0 and 12 and that the total size of the element
-** (header plus payload) is the same as the size of the BLOB.  If those
-** checks are true, the BLOB is assumed to be JSONB and processing continues.
-** Errors are only raised if some other miscoding is discovered during
-** processing.
-**
-** Additional information can be found in the doc/jsonb.md file of the
-** canonical SQLite source tree.
-*/
-#ifndef SQLITE_OMIT_JSON
-/* #include "sqliteInt.h" */
-
-/* JSONB element types
-*/
-#define JSONB_NULL     0   /* "null" */
-#define JSONB_TRUE     1   /* "true" */
-#define JSONB_FALSE    2   /* "false" */
-#define JSONB_INT      3   /* integer acceptable to JSON and SQL */
-#define JSONB_INT5     4   /* integer in 0x000 notation */
-#define JSONB_FLOAT    5   /* float acceptable to JSON and SQL */
-#define JSONB_FLOAT5   6   /* float with JSON5 extensions */
-#define JSONB_TEXT     7   /* Text compatible with both JSON and SQL */
-#define JSONB_TEXTJ    8   /* Text with JSON escapes */
-#define JSONB_TEXT5    9   /* Text with JSON-5 escape */
-#define JSONB_TEXTRAW 10   /* SQL text that needs escaping for JSON */
-#define JSONB_ARRAY   11   /* An array */
-#define JSONB_OBJECT  12   /* An object */
-
-/* Human-readable names for the JSONB values.  The index for each
-** string must correspond to the JSONB_* integer above.
-*/
-static const char * const jsonbType[] = {
-  "null", "true", "false", "integer", "integer",
-  "real", "real", "text",  "text",    "text",
-  "text", "array", "object", "", "", "", ""
-};
-
-/*
-** 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 text-JSON parser.  (Ubuntu14.10 gcc 4.8.4 x64 with -Os).
-*/
-static const char jsonIsSpace[] = {
-#ifdef SQLITE_ASCII
-/*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, 1, 1, 0, 0, 1, 0, 0,  /* 0 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 1 */
-  1, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 2 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 3 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 4 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 5 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 6 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 7 */
-
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 8 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 9 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* a */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* b */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* c */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* d */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* e */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* f */
-#endif
-#ifdef SQLITE_EBCDIC
-/*0  1  2  3  4  5  6  7   8  9  a  b  c  d  e  f  */
-  0, 0, 0, 0, 0, 1, 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,  /* 1 */
-  0, 0, 0, 0, 0, 1, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 2 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 3 */
-  1, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 4 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 5 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 6 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 7 */
-
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 8 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 9 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* a */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* b */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* c */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* d */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* e */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* f */
-#endif
-
-};
-#define jsonIsspace(x) (jsonIsSpace[(unsigned char)x])
-
-/*
-** The set of all space characters recognized by jsonIsspace().
-** Useful as the second argument to strspn().
-*/
-#ifdef SQLITE_ASCII
-static const char jsonSpaces[] = "\011\012\015\040";
-#endif
-#ifdef SQLITE_EBCDIC
-static const char jsonSpaces[] = "\005\045\015\100";
-#endif
-
-
-/*
-** Characters that are special to JSON.  Control characters,
-** '"' and '\\' and '\''.  Actually, '\'' is not special to
-** canonical JSON, but it is special in JSON-5, so we include
-** it in the set of special characters.
-*/
-static const char jsonIsOk[256] = {
-#ifdef SQLITE_ASCII
-/*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,  /* 0 */
-  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  /* 1 */
-  1, 1, 0, 1, 1, 1, 1, 0,  1, 1, 1, 1, 1, 1, 1, 1,  /* 2 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 3 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 4 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 0, 1, 1, 1,  /* 5 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 6 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 7 */
-
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 8 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 9 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* a */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* b */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* c */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* d */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* e */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1   /* f */
-#endif
-#ifdef SQLITE_EBCDIC
-/*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,  /* 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,  /* 2 */
-  1, 1, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 1, 0,  /* 3 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 4 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 5 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 6 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 0, 1, 0,  /* 7 */
-
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 8 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* 9 */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* a */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* b */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* c */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* d */
-  0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,  /* e */
-  1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1   /* f */
-#endif
-};
-
-/* Objects */
-typedef struct JsonCache JsonCache;
-typedef struct JsonString JsonString;
-typedef struct JsonParse JsonParse;
-
-/*
-** Magic number used for the JSON parse cache in sqlite3_get_auxdata()
-*/
-#define JSON_CACHE_ID    (-429938)  /* Cache entry */
-#define JSON_CACHE_SIZE  4          /* Max number of cache entries */
-
-/*
-** jsonUnescapeOneChar() returns this invalid code point if it encounters
-** a syntax error.
-*/
-#define JSON_INVALID_CHAR 0x99999
-
-/* A cache mapping JSON text into JSONB blobs.
-**
-** Each cache entry is a JsonParse object with the following restrictions:
-**
-**    *   The bReadOnly flag must be set
-**
-**    *   The aBlob[] array must be owned by the JsonParse object.  In other
-**        words, nBlobAlloc must be non-zero.
-**
-**    *   eEdit and delta must be zero.
-**
-**    *   zJson must be an RCStr.  In other words bJsonIsRCStr must be true.
-*/
-struct JsonCache {
-  sqlite3 *db;                    /* Database connection */
-  int nUsed;                      /* Number of active entries in the cache */
-  JsonParse *a[JSON_CACHE_SIZE];  /* One line for each cache entry */
-};
-
-/* 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.
-**
-** If the generated string is longer than will fit into the zSpace[] buffer,
-** then it will be an RCStr string.  This aids with caching of large
-** JSON strings.
-*/
-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 eErr;                 /* True if an error has been encountered */
-  char zSpace[100];        /* Initial static space */
-};
-
-/* Allowed values for JsonString.eErr */
-#define JSTRING_OOM         0x01   /* Out of memory */
-#define JSTRING_MALFORMED   0x02   /* Malformed JSONB */
-#define JSTRING_TOODEEP     0x04   /* JSON nested too deep */
-#define JSTRING_ERR         0x08   /* Error already sent to sqlite3_result */
-
-/* The "subtype" set for text JSON values passed through using
-** sqlite3_result_subtype() and sqlite3_value_subtype().
-*/
-#define JSON_SUBTYPE  74    /* Ascii for "J" */
-
-/*
-** Bit values for the flags passed into various SQL function implementations
-** via the sqlite3_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() */
-#define JSON_AINS      0x08        /* json_array_insert(), not json_insert() */
-#define JSON_BLOB      0x10        /* Use the BLOB output format */
-
-#define JSON_INSERT_TYPE(X)  (((X)&0xC)>>2)
-
-
-/* A parsed JSON value.  Lifecycle:
-**
-**   1.  JSON comes in and is parsed into a JSONB value in aBlob.  The
-**       original text is stored in zJson.  This step is skipped if the
-**       input is JSONB instead of text JSON.
-**
-**   2.  The aBlob[] array is searched using the JSON path notation, if needed.
-**
-**   3.  Zero or more changes are made to aBlob[] (via json_remove() or
-**       json_replace() or json_patch() or similar).
-**
-**   4.  New JSON text is generated from the aBlob[] for output.  This step
-**       is skipped if the function is one of the jsonb_* functions that
-**       returns JSONB instead of text JSON.
-*/
-struct JsonParse {
-  u8 *aBlob;         /* JSONB representation of JSON value */
-  u32 nBlob;         /* Bytes of aBlob[] actually used */
-  u32 nBlobAlloc;    /* Bytes allocated to aBlob[].  0 if aBlob is external */
-  char *zJson;       /* Json text used for parsing */
-  sqlite3 *db;       /* The database connection to which this object belongs */
-  int nJson;         /* Length of the zJson string in bytes */
-  u32 nJPRef;        /* Number of references to this object */
-  u32 iErr;          /* Error location in zJson[] */
-  u16 iDepth;        /* Nesting depth */
-  u8 nErr;           /* Number of errors seen */
-  u8 oom;            /* Set to true if out of memory */
-  u8 bJsonIsRCStr;   /* True if zJson is an RCStr */
-  u8 hasNonstd;      /* True if input uses non-standard features like JSON5 */
-  u8 bReadOnly;      /* Do not modify. */
-  /* Search and edit information.  See jsonLookupStep() */
-  u8 eEdit;          /* Edit operation to apply */
-  int delta;         /* Size change due to the edit */
-  u32 nIns;          /* Number of bytes to insert */
-  u32 iLabel;        /* Location of label if search landed on an object value */
-  u8 *aIns;          /* Content to be inserted */
-};
-
-/* Allowed values for JsonParse.eEdit */
-#define JEDIT_DEL   1   /* Delete if exists */
-#define JEDIT_REPL  2   /* Overwrite if exists */
-#define JEDIT_INS   3   /* Insert if not exists */
-#define JEDIT_SET   4   /* Insert or overwrite */
-#define JEDIT_AINS  5   /* array_insert() */
-
-/*
-** 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
-*/
-#ifndef SQLITE_JSON_MAX_DEPTH
-# define JSON_MAX_DEPTH  1000
-#else
-# define JSON_MAX_DEPTH SQLITE_JSON_MAX_DEPTH
-#endif
-
-/*
-** Allowed values for the flgs argument to jsonParseFuncArg();
-*/
-#define JSON_EDITABLE  0x01   /* Generate a writable JsonParse object */
-#define JSON_KEEPERROR 0x02   /* Return non-NULL even if there is an error */
-
-/**************************************************************************
-** Forward references
-**************************************************************************/
-static void jsonReturnStringAsBlob(JsonString*);
-static int jsonArgIsJsonb(sqlite3_value *pJson, JsonParse *p);
-static u32 jsonTranslateBlobToText(JsonParse*,u32,JsonString*);
-static void jsonReturnParse(sqlite3_context*,JsonParse*);
-static JsonParse *jsonParseFuncArg(sqlite3_context*,sqlite3_value*,u32);
-static void jsonParseFree(JsonParse*);
-static u32 jsonbPayloadSize(const JsonParse*, u32, u32*);
-static u32 jsonUnescapeOneChar(const char*, u32, u32*);
-
-/**************************************************************************
-** Utility routines for dealing with JsonCache objects
-**************************************************************************/
-
-/*
-** Free a JsonCache object.
-*/
-static void jsonCacheDelete(JsonCache *p){
-  int i;
-  for(i=0; i<p->nUsed; i++){
-    jsonParseFree(p->a[i]);
-  }
-  sqlite3DbFree(p->db, p);
-}
-static void jsonCacheDeleteGeneric(void *p){
-  jsonCacheDelete((JsonCache*)p);
-}
-
-/*
-** Insert a new entry into the cache.  If the cache is full, expel
-** the least recently used entry.  Return SQLITE_OK on success or a
-** result code otherwise.
-**
-** Cache entries are stored in age order, oldest first.
-*/
-static int jsonCacheInsert(
-  sqlite3_context *ctx,   /* The SQL statement context holding the cache */
-  JsonParse *pParse       /* The parse object to be added to the cache */
-){
-  JsonCache *p;
-
-  assert( pParse->zJson!=0 );
-  assert( pParse->bJsonIsRCStr );
-  assert( pParse->delta==0 );
-  p = sqlite3_get_auxdata(ctx, JSON_CACHE_ID);
-  if( p==0 ){
-    sqlite3 *db = sqlite3_context_db_handle(ctx);
-    p = sqlite3DbMallocZero(db, sizeof(*p));
-    if( p==0 ) return SQLITE_NOMEM;
-    p->db = db;
-    sqlite3_set_auxdata(ctx, JSON_CACHE_ID, p, jsonCacheDeleteGeneric);
-    p = sqlite3_get_auxdata(ctx, JSON_CACHE_ID);
-    if( p==0 ) return SQLITE_NOMEM;
-  }
-  if( p->nUsed >= JSON_CACHE_SIZE ){
-    jsonParseFree(p->a[0]);
-    memmove(p->a, &p->a[1], (JSON_CACHE_SIZE-1)*sizeof(p->a[0]));
-    p->nUsed = JSON_CACHE_SIZE-1;
-  }
-  assert( pParse->nBlobAlloc>0 );
-  pParse->eEdit = 0;
-  pParse->nJPRef++;
-  pParse->bReadOnly = 1;
-  p->a[p->nUsed] = pParse;
-  p->nUsed++;
-  return SQLITE_OK;
-}
-
-/*
-** Search for a cached translation the json text supplied by pArg.  Return
-** the JsonParse object if found.  Return NULL if not found.
-**
-** When a match if found, the matching entry is moved to become the
-** most-recently used entry if it isn't so already.
-**
-** The JsonParse object returned still belongs to the Cache and might
-** be deleted at any moment.  If the caller wants the JsonParse to
-** linger, it needs to increment the nPJRef reference counter.
-*/
-static JsonParse *jsonCacheSearch(
-  sqlite3_context *ctx,    /* The SQL statement context holding the cache */
-  sqlite3_value *pArg      /* Function argument containing SQL text */
-){
-  JsonCache *p;
-  int i;
-  const char *zJson;
-  int nJson;
-
-  if( sqlite3_value_type(pArg)!=SQLITE_TEXT ){
-    return 0;
-  }
-  zJson = (const char*)sqlite3_value_text(pArg);
-  if( zJson==0 ) return 0;
-  nJson = sqlite3_value_bytes(pArg);
-
-  p = sqlite3_get_auxdata(ctx, JSON_CACHE_ID);
-  if( p==0 ){
-    return 0;
-  }
-  for(i=0; i<p->nUsed; i++){
-    if( p->a[i]->zJson==zJson ) break;
-  }
-  if( i>=p->nUsed ){
-    for(i=0; i<p->nUsed; i++){
-      if( p->a[i]->nJson!=nJson ) continue;
-      if( memcmp(p->a[i]->zJson, zJson, nJson)==0 ) break;
-    }
-  }
-  if( i<p->nUsed ){
-    if( i<p->nUsed-1 ){
-      /* Make the matching entry the most recently used entry */
-      JsonParse *tmp = p->a[i];
-      memmove(&p->a[i], &p->a[i+1], (p->nUsed-i-1)*sizeof(tmp));
-      p->a[p->nUsed-1] = tmp;
-      i = p->nUsed - 1;
-    }
-    assert( p->a[i]->delta==0 );
-    return p->a[i];
-  }else{
-    return 0;
-  }
-}
-
-/**************************************************************************
-** Utility routines for dealing with JsonString objects
-**************************************************************************/
-
-/* Turn uninitialized bulk memory into a valid JsonString object
-** holding a zero-length string.
-*/
-static void jsonStringZero(JsonString *p){
-  p->zBuf = p->zSpace;
-  p->nAlloc = sizeof(p->zSpace);
-  p->nUsed = 0;
-  p->bStatic = 1;
-}
-
-/* Initialize the JsonString object
-*/
-static void jsonStringInit(JsonString *p, sqlite3_context *pCtx){
-  p->pCtx = pCtx;
-  p->eErr = 0;
-  jsonStringZero(p);
-}
-
-/* Free all allocated memory and reset the JsonString object back to its
-** initial state.
-*/
-static void jsonStringReset(JsonString *p){
-  if( !p->bStatic ) sqlite3RCStrUnref(p->zBuf);
-  jsonStringZero(p);
-}
-
-/* Report an out-of-memory (OOM) condition
-*/
-static void jsonStringOom(JsonString *p){
-  p->eErr |= JSTRING_OOM;
-  if( p->pCtx ) sqlite3_result_error_nomem(p->pCtx);
-  jsonStringReset(p);
-}
-
-/* Report JSON nested too deep
-*/
-static void jsonStringTooDeep(JsonString *p){
-  p->eErr |= JSTRING_TOODEEP;
-  assert( p->pCtx!=0 );
-  sqlite3_result_error(p->pCtx, "JSON nested too deep", -1);
-  jsonStringReset(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 jsonStringGrow(JsonString *p, u32 N){
-  u64 nTotal = N<p->nAlloc ? p->nAlloc*2 : p->nAlloc+N+10;
-  char *zNew;
-  if( p->bStatic ){
-    if( p->eErr ) return 1;
-    zNew = sqlite3RCStrNew(nTotal);
-    if( zNew==0 ){
-      jsonStringOom(p);
-      return SQLITE_NOMEM;
-    }
-    memcpy(zNew, p->zBuf, (size_t)p->nUsed);
-    p->zBuf = zNew;
-    p->bStatic = 0;
-  }else{
-    p->zBuf = sqlite3RCStrResize(p->zBuf, nTotal);
-    if( p->zBuf==0 ){
-      p->eErr |= JSTRING_OOM;
-      jsonStringZero(p);
-      return SQLITE_NOMEM;
-    }
-  }
-  p->nAlloc = nTotal;
-  return SQLITE_OK;
-}
-
-/* Append N bytes from zIn onto the end of the JsonString string.
-*/
-static SQLITE_NOINLINE void jsonStringExpandAndAppend(
-  JsonString *p,
-  const char *zIn,
-  u32 N
-){
-  assert( N>0 );
-  if( jsonStringGrow(p,N) ) return;
-  memcpy(p->zBuf+p->nUsed, zIn, N);
-  p->nUsed += N;
-}
-static void jsonAppendRaw(JsonString *p, const char *zIn, u32 N){
-  if( N==0 ) return;
-  if( N+p->nUsed >= p->nAlloc ){
-    jsonStringExpandAndAppend(p,zIn,N);
-  }else{
-    memcpy(p->zBuf+p->nUsed, zIn, N);
-    p->nUsed += N;
-  }
-}
-static void jsonAppendRawNZ(JsonString *p, const char *zIn, u32 N){
-  assert( N>0 );
-  if( N+p->nUsed >= p->nAlloc ){
-    jsonStringExpandAndAppend(p,zIn,N);
-  }else{
-    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) && jsonStringGrow(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 SQLITE_NOINLINE void jsonAppendCharExpand(JsonString *p, char c){
-  if( jsonStringGrow(p,1) ) return;
-  p->zBuf[p->nUsed++] = c;
-}
-static void jsonAppendChar(JsonString *p, char c){
-  if( p->nUsed>=p->nAlloc ){
-    jsonAppendCharExpand(p,c);
-  }else{
-    p->zBuf[p->nUsed++] = c;
-  }
-}
-
-/* Remove a single character from the end of the string
-*/
-static void jsonStringTrimOneChar(JsonString *p){
-  if( p->eErr==0 ){
-    assert( p->nUsed>0 );
-    p->nUsed--;
-  }
-}
-
-
-/* Make sure there is a zero terminator on p->zBuf[]
-**
-** Return true on success.  Return false if an OOM prevents this
-** from happening.
-*/
-static int jsonStringTerminate(JsonString *p){
-  jsonAppendChar(p, 0);
-  jsonStringTrimOneChar(p);
-  return p->eErr==0;
-}
-
-/* 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=='{' ) return;
-  jsonAppendChar(p, ',');
-}
-
-/* c is a control character.  Append the canonical JSON representation
-** of that control character to p.
-**
-** This routine assumes that the output buffer has already been enlarged
-** sufficiently to hold the worst-case encoding plus a nul terminator.
-*/
-static void jsonAppendControlChar(JsonString *p, u8 c){
-  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' );
-  assert( c>=0 && c<sizeof(aSpecial) );
-  assert( p->nUsed+7 <= p->nAlloc );
-  if( aSpecial[c] ){
-    p->zBuf[p->nUsed] = '\\';
-    p->zBuf[p->nUsed+1] = aSpecial[c];
-    p->nUsed += 2;
-  }else{
-    p->zBuf[p->nUsed] = '\\';
-    p->zBuf[p->nUsed+1] = 'u';
-    p->zBuf[p->nUsed+2] = '0';
-    p->zBuf[p->nUsed+3] = '0';
-    p->zBuf[p->nUsed+4] = "0123456789abcdef"[c>>4];
-    p->zBuf[p->nUsed+5] = "0123456789abcdef"[c&0xf];
-    p->nUsed += 6;
-  }
-}
-
-/* Append the N-byte string in zIn to the end of the JsonString string
-** under construction.  Enclose the string in double-quotes ("...") and
-** escape any double-quotes or backslash characters contained within the
-** string.
-**
-** This routine is a high-runner.  There is a measurable performance
-** increase associated with unwinding the jsonIsOk[] loop.
-*/
-static void jsonAppendString(JsonString *p, const char *zIn, u32 N){
-  u32 k;
-  u8 c;
-  const u8 *z = (const u8*)zIn;
-  if( z==0 ) return;
-  if( (N+p->nUsed+2 >= p->nAlloc) && jsonStringGrow(p,N+2)!=0 ) return;
-  p->zBuf[p->nUsed++] = '"';
-  while( 1 /*exit-by-break*/ ){
-    k = 0;
-    /* The following while() is the 4-way unwound equivalent of
-    **
-    **     while( k<N && jsonIsOk[z[k]] ){ k++; }
-    */
-    while( 1 /* Exit by break */ ){
-      if( k+3>=N ){
-        while( k<N && jsonIsOk[z[k]] ){ k++; }
-        break;
-      }
-      if( !jsonIsOk[z[k]] ){
-        break;
-      }
-      if( !jsonIsOk[z[k+1]] ){
-        k += 1;
-        break;
-      }
-      if( !jsonIsOk[z[k+2]] ){
-        k += 2;
-        break;
-      }
-      if( !jsonIsOk[z[k+3]] ){
-        k += 3;
-        break;
-      }else{
-        k += 4;
-      }
-    }
-    if( k>=N ){
-      if( k>0 ){
-        memcpy(&p->zBuf[p->nUsed], z, k);
-        p->nUsed += k;
-      }
-      break;
-    }
-    if( k>0 ){
-      memcpy(&p->zBuf[p->nUsed], z, k);
-      p->nUsed += k;
-      z += k;
-      N -= k;
-    }
-    c = z[0];
-    if( c=='"' || c=='\\' ){
-      if( (p->nUsed+N+3 > p->nAlloc) && jsonStringGrow(p,N+3)!=0 ) return;
-      p->zBuf[p->nUsed++] = '\\';
-      p->zBuf[p->nUsed++] = c;
-    }else if( c=='\'' ){
-      p->zBuf[p->nUsed++] = c;
-    }else{
-      if( (p->nUsed+N+7 > p->nAlloc) && jsonStringGrow(p,N+7)!=0 ) return;
-      jsonAppendControlChar(p, c);
-    }
-    z++;
-    N--;
-  }
-  p->zBuf[p->nUsed++] = '"';
-  assert( p->nUsed<p->nAlloc );
-}
-
-/*
-** Append an sqlite3_value (such as a function parameter) to the JSON
-** string under construction in p.
-*/
-static void jsonAppendSqlValue(
-  JsonString *p,                 /* Append to this JSON string */
-  sqlite3_value *pValue          /* Value to append */
-){
-  switch( sqlite3_value_type(pValue) ){
-    case SQLITE_NULL: {
-      jsonAppendRawNZ(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: {
-      JsonParse px;
-      memset(&px, 0, sizeof(px));
-      if( jsonArgIsJsonb(pValue, &px) ){
-        jsonTranslateBlobToText(&px, 0, p);
-      }else if( p->eErr==0 ){
-        sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
-        p->eErr = JSTRING_ERR;
-        jsonStringReset(p);
-      }
-      break;
-    }
-  }
-}
-
-/* Make the text in p (which is probably a generated JSON text string)
-** the result of the SQL function.
-**
-** The JsonString is reset.
-**
-** If pParse and ctx are both non-NULL, then the SQL string in p is
-** loaded into the zJson field of the pParse object as a RCStr and the
-** pParse is added to the cache.
-*/
-static void jsonReturnString(
-  JsonString *p,            /* String to return */
-  JsonParse *pParse,        /* JSONB source or NULL */
-  sqlite3_context *ctx      /* Where to cache */
-){
-  assert( (pParse!=0)==(ctx!=0) );
-  assert( ctx==0 || ctx==p->pCtx );
-  jsonStringTerminate(p);
-  if( p->eErr==0 ){
-    int flags = SQLITE_PTR_TO_INT(sqlite3_user_data(p->pCtx));
-    if( flags & JSON_BLOB ){
-      jsonReturnStringAsBlob(p);
-    }else if( p->bStatic ){
-      sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed,
-                            SQLITE_TRANSIENT, SQLITE_UTF8);
-    }else{
-      if( pParse && pParse->bJsonIsRCStr==0 && pParse->nBlobAlloc>0 ){
-        int rc;
-        pParse->zJson = sqlite3RCStrRef(p->zBuf);
-        pParse->nJson = p->nUsed;
-        pParse->bJsonIsRCStr = 1;
-        rc = jsonCacheInsert(ctx, pParse);
-        if( rc==SQLITE_NOMEM ){
-          sqlite3_result_error_nomem(ctx);
-          jsonStringReset(p);
-          return;
-        }
-      }
-      sqlite3_result_text64(p->pCtx, sqlite3RCStrRef(p->zBuf), p->nUsed,
-                            sqlite3RCStrUnref,
-                            SQLITE_UTF8);
-    }
-  }else if( p->eErr & JSTRING_OOM ){
-    sqlite3_result_error_nomem(p->pCtx);
-  }else if( p->eErr & JSTRING_TOODEEP ){
-    /* error already in p->pCtx */
-  }else if( p->eErr & JSTRING_MALFORMED ){
-    sqlite3_result_error(p->pCtx, "malformed JSON", -1);
-  }
-  jsonStringReset(p);
-}
-
-/**************************************************************************
-** Utility routines for dealing with JsonParse objects
-**************************************************************************/
-
-/*
-** Reclaim all memory allocated by a JsonParse object.  But do not
-** delete the JsonParse object itself.
-*/
-static void jsonParseReset(JsonParse *pParse){
-  assert( pParse->nJPRef<=1 );
-  if( pParse->bJsonIsRCStr ){
-    sqlite3RCStrUnref(pParse->zJson);
-    pParse->zJson = 0;
-    pParse->nJson = 0;
-    pParse->bJsonIsRCStr = 0;
-  }
-  if( pParse->nBlobAlloc ){
-    sqlite3DbFree(pParse->db, pParse->aBlob);
-    pParse->aBlob = 0;
-    pParse->nBlob = 0;
-    pParse->nBlobAlloc = 0;
-  }
-}
-
-/*
-** Decrement the reference count on the JsonParse object.  When the
-** count reaches zero, free the object.
-*/
-static void jsonParseFree(JsonParse *pParse){
-  if( pParse ){
-    if( pParse->nJPRef>1 ){
-      pParse->nJPRef--;
-    }else{
-      jsonParseReset(pParse);
-      sqlite3DbFree(pParse->db, pParse);
-    }
-  }
-}
-
-/**************************************************************************
-** Utility routines for the JSON text parser
-**************************************************************************/
-
-/*
-** Translate a single byte of Hex into an integer.
-** This routine only gives a correct answer if h really is a valid hexadecimal
-** character:  0..9a..fA..F.  But unlike sqlite3HexToInt(), it does not
-** assert() if the digit is not hex.
-*/
-static u8 jsonHexToInt(int h){
-#ifdef SQLITE_ASCII
-  h += 9*(1&(h>>6));
-#endif
-#ifdef SQLITE_EBCDIC
-  h += 9*(1&~(h>>4));
-#endif
-  return (u8)(h & 0xf);
-}
-
-/*
-** Convert a 4-byte hex string into an integer
-*/
-static u32 jsonHexToInt4(const char *z){
-  u32 v;
-  v = (jsonHexToInt(z[0])<<12)
-    + (jsonHexToInt(z[1])<<8)
-    + (jsonHexToInt(z[2])<<4)
-    + jsonHexToInt(z[3]);
-  return v;
-}
-
-/*
-** 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, JSONB_FLOAT, 7, "inf", "9.0e999" },
-  { 'i', 'I', 8, JSONB_FLOAT, 7, "infinity", "9.0e999" },
-  { 'n', 'N', 3, JSONB_NULL, 4, "NaN", "null" },
-  { 'q', 'Q', 4, JSONB_NULL, 4, "QNaN", "null" },
-  { 's', 'S', 4, JSONB_NULL, 4, "SNaN", "null" },
-};
-
-
-/*
-** 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);
-}
-
-/****************************************************************************
-** Utility routines for dealing with the binary BLOB representation of JSON
-****************************************************************************/
-
-/*
-** Expand pParse->aBlob so that it holds at least N bytes.
-**
-** Return the number of errors.
-*/
-static int jsonBlobExpand(JsonParse *pParse, u32 N){
-  u8 *aNew;
-  u64 t;
-  assert( N>pParse->nBlobAlloc );
-  if( pParse->nBlobAlloc==0 ){
-    t = 100;
-  }else{
-    t = pParse->nBlobAlloc*2;
-  }
-  if( t<N ) t = N+100;
-  aNew = sqlite3DbRealloc(pParse->db, pParse->aBlob, t);
-  if( aNew==0 ){ pParse->oom = 1; return 1; }
-  assert( t<0x7fffffff );
-  pParse->aBlob = aNew;
-  pParse->nBlobAlloc = (u32)t;
-  return 0;
-}
-
-/*
-** If pParse->aBlob is not previously editable (because it is taken
-** from sqlite3_value_blob(), as indicated by the fact that
-** pParse->nBlobAlloc==0 and pParse->nBlob>0) then make it editable
-** by making a copy into space obtained from malloc.
-**
-** Return true on success.  Return false on OOM.
-*/
-static int jsonBlobMakeEditable(JsonParse *pParse, u32 nExtra){
-  u8 *aOld;
-  u32 nSize;
-  assert( !pParse->bReadOnly );
-  if( pParse->oom ) return 0;
-  if( pParse->nBlobAlloc>0 ) return 1;
-  aOld = pParse->aBlob;
-  nSize = pParse->nBlob + nExtra;
-  pParse->aBlob = 0;
-  if( jsonBlobExpand(pParse, nSize) ){
-    return 0;
-  }
-  assert( pParse->nBlobAlloc >= pParse->nBlob + nExtra );
-  memcpy(pParse->aBlob, aOld, pParse->nBlob);
-  return 1;
-}
-
-/* Expand pParse->aBlob and append one bytes.
-*/
-static SQLITE_NOINLINE void jsonBlobExpandAndAppendOneByte(
-  JsonParse *pParse,
-  u8 c
-){
-  jsonBlobExpand(pParse, pParse->nBlob+1);
-  if( pParse->oom==0 ){
-    assert( pParse->nBlob+1<=pParse->nBlobAlloc );
-    pParse->aBlob[pParse->nBlob++] = c;
-  }
-}
-
-/* Append a single character.
-*/
-static void jsonBlobAppendOneByte(JsonParse *pParse, u8 c){
-  if( pParse->nBlob >= pParse->nBlobAlloc ){
-    jsonBlobExpandAndAppendOneByte(pParse, c);
-  }else{
-    pParse->aBlob[pParse->nBlob++] = c;
-  }
-}
-
-/* Slow version of jsonBlobAppendNode() that first resizes the
-** pParse->aBlob structure.
-*/
-static void jsonBlobAppendNode(JsonParse*,u8,u64,const void*);
-static SQLITE_NOINLINE void jsonBlobExpandAndAppendNode(
-  JsonParse *pParse,
-  u8 eType,
-  u64 szPayload,
-  const void *aPayload
-){
-  if( jsonBlobExpand(pParse, pParse->nBlob+szPayload+9) ) return;
-  jsonBlobAppendNode(pParse, eType, szPayload, aPayload);
-}
-
-
-/* Append a node type byte together with the payload size and
-** possibly also the payload.
-**
-** If aPayload is not NULL, then it is a pointer to the payload which
-** is also appended.  If aPayload is NULL, the pParse->aBlob[] array
-** is resized (if necessary) so that it is big enough to hold the
-** payload, but the payload is not appended and pParse->nBlob is left
-** pointing to where the first byte of payload will eventually be.
-*/
-static void jsonBlobAppendNode(
-  JsonParse *pParse,          /* The JsonParse object under construction */
-  u8 eType,                   /* Node type.  One of JSONB_* */
-  u64 szPayload,              /* Number of bytes of payload */
-  const void *aPayload        /* The payload.  Might be NULL */
-){
-  u8 *a;
-  if( pParse->nBlob+szPayload+9 > pParse->nBlobAlloc ){
-    jsonBlobExpandAndAppendNode(pParse,eType,szPayload,aPayload);
-    return;
-  }
-  assert( pParse->aBlob!=0 );
-  a = &pParse->aBlob[pParse->nBlob];
-  if( szPayload<=11 ){
-    a[0] = eType | (szPayload<<4);
-    pParse->nBlob += 1;
-  }else if( szPayload<=0xff ){
-    a[0] = eType | 0xc0;
-    a[1] = szPayload & 0xff;
-    pParse->nBlob += 2;
-  }else if( szPayload<=0xffff ){
-    a[0] = eType | 0xd0;
-    a[1] = (szPayload >> 8) & 0xff;
-    a[2] = szPayload & 0xff;
-    pParse->nBlob += 3;
-  }else{
-    a[0] = eType | 0xe0;
-    a[1] = (szPayload >> 24) & 0xff;
-    a[2] = (szPayload >> 16) & 0xff;
-    a[3] = (szPayload >> 8) & 0xff;
-    a[4] = szPayload & 0xff;
-    pParse->nBlob += 5;
-  }
-  if( aPayload ){
-    pParse->nBlob += szPayload;
-    memcpy(&pParse->aBlob[pParse->nBlob-szPayload], aPayload, szPayload);
-  }
-}
-
-/* Change the payload size for the node at index i to be szPayload.
-*/
-static int jsonBlobChangePayloadSize(
-  JsonParse *pParse,
-  u32 i,
-  u32 szPayload
-){
-  u8 *a;
-  u8 szType;
-  u8 nExtra;
-  u8 nNeeded;
-  int delta;
-  if( pParse->oom ) return 0;
-  a = &pParse->aBlob[i];
-  szType = a[0]>>4;
-  if( szType<=11 ){
-    nExtra = 0;
-  }else if( szType==12 ){
-    nExtra = 1;
-  }else if( szType==13 ){
-    nExtra = 2;
-  }else if( szType==14 ){
-    nExtra = 4;
-  }else{
-    nExtra = 8;
-  }
-  if( szPayload<=11 ){
-    nNeeded = 0;
-  }else if( szPayload<=0xff ){
-    nNeeded = 1;
-  }else if( szPayload<=0xffff ){
-    nNeeded = 2;
-  }else{
-    nNeeded = 4;
-  }
-  delta = nNeeded - nExtra;
-  if( delta ){
-    u32 newSize = pParse->nBlob + delta;
-    if( delta>0 ){
-      if( newSize>pParse->nBlobAlloc && jsonBlobExpand(pParse, newSize) ){
-        return 0;  /* OOM error.  Error state recorded in pParse->oom. */
-      }
-      a = &pParse->aBlob[i];
-      memmove(&a[1+delta], &a[1], pParse->nBlob - (i+1));
-    }else{
-      memmove(&a[1], &a[1-delta], pParse->nBlob - (i+1-delta));
-    }
-    pParse->nBlob = newSize;
-  }
-  if( nNeeded==0 ){
-    a[0] = (a[0] & 0x0f) | (szPayload<<4);
-  }else if( nNeeded==1 ){
-    a[0] = (a[0] & 0x0f) | 0xc0;
-    a[1] = szPayload & 0xff;
-  }else if( nNeeded==2 ){
-    a[0] = (a[0] & 0x0f) | 0xd0;
-    a[1] = (szPayload >> 8) & 0xff;
-    a[2] = szPayload & 0xff;
-  }else{
-    a[0] = (a[0] & 0x0f) | 0xe0;
-    a[1] = (szPayload >> 24) & 0xff;
-    a[2] = (szPayload >> 16) & 0xff;
-    a[3] = (szPayload >> 8) & 0xff;
-    a[4] = szPayload & 0xff;
-  }
-  return delta;
-}
-
-/*
-** If z[0] is 'u' and is followed by exactly 4 hexadecimal character,
-** then set *pOp to JSONB_TEXTJ and return true.  If not, do not make
-** any changes to *pOp and return false.
-*/
-static int jsonIs4HexB(const char *z, int *pOp){
-  if( z[0]!='u' ) return 0;
-  if( !jsonIs4Hex(&z[1]) ) return 0;
-  *pOp = JSONB_TEXTJ;
-  return 1;
-}
-
-/*
-** Check a single element of the JSONB in pParse for validity.
-**
-** The element to be checked starts at offset i and must end at on the
-** last byte before iEnd.
-**
-** Return 0 if everything is correct.  Return the 1-based byte offset of the
-** error if a problem is detected.  (In other words, if the error is at offset
-** 0, return 1).
-*/
-static u32 jsonbValidityCheck(
-  const JsonParse *pParse,    /* Input JSONB.  Only aBlob and nBlob are used */
-  u32 i,                      /* Start of element as pParse->aBlob[i] */
-  u32 iEnd,                   /* One more than the last byte of the element */
-  u32 iDepth                  /* Current nesting depth */
-){
-  u32 n, sz, j, k;
-  const u8 *z;
-  u8 x;
-  if( iDepth>JSON_MAX_DEPTH ) return i+1;
-  sz = 0;
-  n = jsonbPayloadSize(pParse, i, &sz);
-  if( NEVER(n==0) ) return i+1;          /* Checked by caller */
-  if( NEVER(i+n+sz!=iEnd) ) return i+1;  /* Checked by caller */
-  z = pParse->aBlob;
-  x = z[i] & 0x0f;
-  switch( x ){
-    case JSONB_NULL:
-    case JSONB_TRUE:
-    case JSONB_FALSE: {
-      return n+sz==1 ? 0 : i+1;
-    }
-    case JSONB_INT: {
-      if( sz<1 ) return i+1;
-      j = i+n;
-      if( z[j]=='-' ){
-        j++;
-        if( sz<2 ) return i+1;
-      }
-      k = i+n+sz;
-      while( j<k ){
-        if( sqlite3Isdigit(z[j]) ){
-          j++;
-        }else{
-          return j+1;
-        }
-      }
-      return 0;
-    }
-    case JSONB_INT5: {
-      if( sz<3 ) return i+1;
-      j = i+n;
-      if( z[j]=='-' ){
-        if( sz<4 ) return i+1;
-        j++;
-      }
-      if( z[j]!='0' ) return i+1;
-      if( z[j+1]!='x' && z[j+1]!='X' ) return j+2;
-      j += 2;
-      k = i+n+sz;
-      while( j<k ){
-        if( sqlite3Isxdigit(z[j]) ){
-          j++;
-        }else{
-          return j+1;
-        }
-      }
-      return 0;
-    }
-    case JSONB_FLOAT:
-    case JSONB_FLOAT5: {
-      u8 seen = 0;   /* 0: initial.  1: '.' seen  2: 'e' seen */
-      if( sz<2 ) return i+1;
-      j = i+n;
-      k = j+sz;
-      if( z[j]=='-' ){
-        j++;
-        if( sz<3 ) return i+1;
-      }
-      if( z[j]=='.' ){
-        if( x==JSONB_FLOAT ) return j+1;
-        if( !sqlite3Isdigit(z[j+1]) ) return j+1;
-        j += 2;
-        seen = 1;
-      }else if( z[j]=='0' && x==JSONB_FLOAT ){
-        if( j+3>k ) return j+1;
-        if( z[j+1]!='.' && z[j+1]!='e' && z[j+1]!='E' ) return j+1;
-        j++;
-      }
-      for(; j<k; j++){
-        if( sqlite3Isdigit(z[j]) ) continue;
-        if( z[j]=='.' ){
-          if( seen>0 ) return j+1;
-          if( x==JSONB_FLOAT && (j==k-1 || !sqlite3Isdigit(z[j+1])) ){
-            return j+1;
-          }
-          seen = 1;
-          continue;
-        }
-        if( z[j]=='e' || z[j]=='E' ){
-          if( seen==2 ) return j+1;
-          if( j==k-1 ) return j+1;
-          if( z[j+1]=='+' || z[j+1]=='-' ){
-            j++;
-            if( j==k-1 ) return j+1;
-          }
-          seen = 2;
-          continue;
-        }
-        return j+1;
-      }
-      if( seen==0 ) return i+1;
-      return 0;
-    }
-    case JSONB_TEXT: {
-      j = i+n;
-      k = j+sz;
-      while( j<k ){
-        if( !jsonIsOk[z[j]] && z[j]!='\'' ) return j+1;
-        j++;
-      }
-      return 0;
-    }
-    case JSONB_TEXTJ:
-    case JSONB_TEXT5: {
-      j = i+n;
-      k = j+sz;
-      while( j<k ){
-        if( !jsonIsOk[z[j]] && z[j]!='\'' ){
-          if( z[j]=='"' ){
-            if( x==JSONB_TEXTJ ) return j+1;
-          }else if( z[j]<=0x1f ){
-            /* Control characters in JSON5 string literals are ok */
-            if( x==JSONB_TEXTJ ) return j+1;
-          }else if( NEVER(z[j]!='\\') || j+1>=k ){
-            return j+1;
-          }else if( strchr("\"\\/bfnrt",z[j+1])!=0 ){
-            j++;
-          }else if( z[j+1]=='u' ){
-            if( j+5>=k ) return j+1;
-            if( !jsonIs4Hex((const char*)&z[j+2]) ) return j+1;
-            j++;
-          }else if( x!=JSONB_TEXT5 ){
-            return j+1;
-          }else{
-            u32 c = 0;
-            u32 szC = jsonUnescapeOneChar((const char*)&z[j], k-j, &c);
-            if( c==JSON_INVALID_CHAR ) return j+1;
-            j += szC - 1;
-          }
-        }
-        j++;
-      }
-      return 0;
-    }
-    case JSONB_TEXTRAW: {
-      return 0;
-    }
-    case JSONB_ARRAY: {
-      u32 sub;
-      j = i+n;
-      k = j+sz;
-      while( j<k ){
-        sz = 0;
-        n = jsonbPayloadSize(pParse, j, &sz);
-        if( n==0 ) return j+1;
-        if( j+n+sz>k ) return j+1;
-        sub = jsonbValidityCheck(pParse, j, j+n+sz, iDepth+1);
-        if( sub ) return sub;
-        j += n + sz;
-      }
-      assert( j==k );
-      return 0;
-    }
-    case JSONB_OBJECT: {
-      u32 cnt = 0;
-      u32 sub;
-      j = i+n;
-      k = j+sz;
-      while( j<k ){
-        sz = 0;
-        n = jsonbPayloadSize(pParse, j, &sz);
-        if( n==0 ) return j+1;
-        if( j+n+sz>k ) return j+1;
-        if( (cnt & 1)==0 ){
-          x = z[j] & 0x0f;
-          if( x<JSONB_TEXT || x>JSONB_TEXTRAW ) return j+1;
-        }
-        sub = jsonbValidityCheck(pParse, j, j+n+sz, iDepth+1);
-        if( sub ) return sub;
-        cnt++;
-        j += n + sz;
-      }
-      assert( j==k );
-      if( (cnt & 1)!=0 ) return j+1;
-      return 0;
-    }
-    default: {
-      return i+1;
-    }
-  }
-}
-
-/*
-** Translate a single element of JSON text at pParse->zJson[i] into
-** its equivalent binary JSONB representation.  Append the translation into
-** pParse->aBlob[] beginning at pParse->nBlob.  The size of
-** pParse->aBlob[] is increased as necessary.
-**
-** Return the index of the first character past the end of the element parsed,
-** or one of the following special result codes:
-**
-**      0    End of input
-**     -1    Syntax error or OOM
-**     -2    '}' seen   \
-**     -3    ']' seen    \___  For these returns, pParse->iErr is set to
-**     -4    ',' seen    /     the index in zJson[] of the seen character
-**     -5    ':' seen   /
-*/
-static int jsonTranslateTextToBlob(JsonParse *pParse, u32 i){
-  char c;
-  u32 j;
-  u32 iThis, iStart;
-  int x;
-  u8 t;
-  const char *z = pParse->zJson;
-json_parse_restart:
-  switch( (u8)z[i] ){
-  case '{': {
-    /* Parse object */
-    iThis = pParse->nBlob;
-    jsonBlobAppendNode(pParse, JSONB_OBJECT, pParse->nJson-i, 0);
-    if( ++pParse->iDepth > JSON_MAX_DEPTH ){
-      pParse->iErr = i;
-      return -1;
-    }
-    iStart = pParse->nBlob;
-    for(j=i+1;;j++){
-      u32 iBlob = pParse->nBlob;
-      x = jsonTranslateTextToBlob(pParse, j);
-      if( x<=0 ){
-        int op;
-        if( x==(-2) ){
-          j = pParse->iErr;
-          if( pParse->nBlob!=(u32)iStart ) pParse->hasNonstd = 1;
-          break;
-        }
-        j += json5Whitespace(&z[j]);
-        op = JSONB_TEXT;
-        if( sqlite3JsonId1(z[j])
-         || (z[j]=='\\' && jsonIs4HexB(&z[j+1], &op))
-        ){
-          int k = j+1;
-          while( (sqlite3JsonId2(z[k]) && json5Whitespace(&z[k])==0)
-            || (z[k]=='\\' && jsonIs4HexB(&z[k+1], &op))
-          ){
-            k++;
-          }
-          assert( iBlob==pParse->nBlob );
-          jsonBlobAppendNode(pParse, op, k-j, &z[j]);
-          pParse->hasNonstd = 1;
-          x = k;
-        }else{
-          if( x!=-1 ) pParse->iErr = j;
-          return -1;
-        }
-      }
-      if( pParse->oom ) return -1;
-      t = pParse->aBlob[iBlob] & 0x0f;
-      if( t<JSONB_TEXT || t>JSONB_TEXTRAW ){
-        pParse->iErr = j;
-        return -1;
-      }
-      j = x;
-      if( z[j]==':' ){
-        j++;
-      }else{
-        if( jsonIsspace(z[j]) ){
-          /* strspn() is not helpful here */
-          do{ j++; }while( jsonIsspace(z[j]) );
-          if( z[j]==':' ){
-            j++;
-            goto parse_object_value;
-          }
-        }
-        x = jsonTranslateTextToBlob(pParse, j);
-        if( x!=(-5) ){
-          if( x!=(-1) ) pParse->iErr = j;
-          return -1;
-        }
-        j = pParse->iErr+1;
-      }
-    parse_object_value:
-      x = jsonTranslateTextToBlob(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( jsonIsspace(z[j]) ){
-          j += 1 + (u32)strspn(&z[j+1], jsonSpaces);
-          if( z[j]==',' ){
-            continue;
-          }else if( z[j]=='}' ){
-            break;
-          }
-        }
-        x = jsonTranslateTextToBlob(pParse, j);
-        if( x==(-4) ){
-          j = pParse->iErr;
-          continue;
-        }
-        if( x==(-2) ){
-          j = pParse->iErr;
-          break;
-        }
-      }
-      pParse->iErr = j;
-      return -1;
-    }
-    jsonBlobChangePayloadSize(pParse, iThis, pParse->nBlob - iStart);
-    pParse->iDepth--;
-    return j+1;
-  }
-  case '[': {
-    /* Parse array */
-    iThis = pParse->nBlob;
-    assert( i<=(u32)pParse->nJson );
-    jsonBlobAppendNode(pParse, JSONB_ARRAY, pParse->nJson - i, 0);
-    iStart = pParse->nBlob;
-    if( pParse->oom ) return -1;
-    if( ++pParse->iDepth > JSON_MAX_DEPTH ){
-      pParse->iErr = i;
-      return -1;
-    }
-    for(j=i+1;;j++){
-      x = jsonTranslateTextToBlob(pParse, j);
-      if( x<=0 ){
-        if( x==(-3) ){
-          j = pParse->iErr;
-          if( pParse->nBlob!=iStart ) 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( jsonIsspace(z[j]) ){
-          j += 1 + (u32)strspn(&z[j+1], jsonSpaces);
-          if( z[j]==',' ){
-            continue;
-          }else if( z[j]==']' ){
-            break;
-          }
-        }
-        x = jsonTranslateTextToBlob(pParse, j);
-        if( x==(-4) ){
-          j = pParse->iErr;
-          continue;
-        }
-        if( x==(-3) ){
-          j = pParse->iErr;
-          break;
-        }
-      }
-      pParse->iErr = j;
-      return -1;
-    }
-    jsonBlobChangePayloadSize(pParse, iThis, pParse->nBlob - iStart);
-    pParse->iDepth--;
-    return j+1;
-  }
-  case '\'': {
-    u8 opcode;
-    char cDelim;
-    pParse->hasNonstd = 1;
-    opcode = JSONB_TEXT;
-    goto parse_string;
-  case '"':
-    /* Parse string */
-    opcode = JSONB_TEXT;
-  parse_string:
-    cDelim = z[i];
-    j = i+1;
-    while( 1 /*exit-by-break*/ ){
-      if( jsonIsOk[(u8)z[j]] ){
-        if( !jsonIsOk[(u8)z[j+1]] ){
-          j += 1;
-        }else if( !jsonIsOk[(u8)z[j+2]] ){
-          j += 2;
-        }else{
-          j += 3;
-          continue;
-        }
-      }
-      c = z[j];
-      if( c==cDelim ){
-        break;
-      }else 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])) ){
-          if( opcode==JSONB_TEXT ) opcode = JSONB_TEXTJ;
-        }else if( c=='\'' ||  c=='v' || c=='\n'
-#ifdef SQLITE_BUG_COMPATIBLE_20250510
-           || (c=='0')                            /* Legacy bug compatible */
-#else
-           || (c=='0' && !sqlite3Isdigit(z[j+1])) /* Correct implementation */
-#endif
-           || (0xe2==(u8)c && 0x80==(u8)z[j+1]
-                && (0xa8==(u8)z[j+2] || 0xa9==(u8)z[j+2]))
-           || (c=='x' && jsonIs2Hex(&z[j+1])) ){
-          opcode = JSONB_TEXT5;
-          pParse->hasNonstd = 1;
-        }else if( c=='\r' ){
-          if( z[j+1]=='\n' ) j++;
-          opcode = JSONB_TEXT5;
-          pParse->hasNonstd = 1;
-        }else{
-          pParse->iErr = j;
-          return -1;
-        }
-      }else if( c<=0x1f ){
-        if( c==0 ){
-          pParse->iErr = j;
-          return -1;
-        }
-        /* Control characters are not allowed in canonical JSON string
-        ** literals, but are allowed in JSON5 string literals. */
-        opcode = JSONB_TEXT5;
-        pParse->hasNonstd = 1;
-      }else if( c=='"' ){
-        opcode = JSONB_TEXT5;
-      }
-      j++;
-    }
-    jsonBlobAppendNode(pParse, opcode, j-1-i, &z[i+1]);
-    return j+1;
-  }
-  case 't': {
-    if( strncmp(z+i,"true",4)==0 && !sqlite3Isalnum(z[i+4]) ){
-      jsonBlobAppendOneByte(pParse, JSONB_TRUE);
-      return i+4;
-    }
-    pParse->iErr = i;
-    return -1;
-  }
-  case 'f': {
-    if( strncmp(z+i,"false",5)==0 && !sqlite3Isalnum(z[i+5]) ){
-      jsonBlobAppendOneByte(pParse, JSONB_FALSE);
-      return i+5;
-    }
-    pParse->iErr = i;
-    return -1;
-  }
-  case '+': {
-    u8 seenE;
-    pParse->hasNonstd = 1;
-    t = 0x00;            /* Bit 0x01:  JSON5.   Bit 0x02:  FLOAT */
-    goto parse_number;
-  case '.':
-    if( sqlite3Isdigit(z[i+1]) ){
-      pParse->hasNonstd = 1;
-      t = 0x03;          /* Bit 0x01:  JSON5.   Bit 0x02:  FLOAT */
-      seenE = 0;
-      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 */
-    t = 0x00;            /* Bit 0x01:  JSON5.   Bit 0x02:  FLOAT */
-  parse_number:
-    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( t==0x00 );
-          pParse->hasNonstd = 1;
-          t = 0x01;
-          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]=='-' ){
-              jsonBlobAppendNode(pParse, JSONB_FLOAT, 6, "-9e999");
-            }else{
-              jsonBlobAppendNode(pParse, JSONB_FLOAT, 5, "9e999");
-            }
-            return i + (sqlite3StrNICmp(&z[i+4],"inity",5)==0 ? 9 : 4);
-          }
-          if( z[i+1]=='.' ){
-            pParse->hasNonstd = 1;
-            t |= 0x01;
-            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;
-            t |= 0x01;
-            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( (t & 0x02)!=0 ){
-          pParse->iErr = j;
-          return -1;
-        }
-        t |= 0x02;
-        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;
-            t |= 0x01;
-          }else{
-            pParse->iErr = j;
-            return -1;
-          }
-        }
-        if( seenE ){
-          pParse->iErr = j;
-          return -1;
-        }
-        t |= 0x02;
-        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;
-        t |= 0x01;
-      }else{
-        pParse->iErr = j;
-        return -1;
-      }
-    }
-  parse_number_finish:
-    assert( JSONB_INT+0x01==JSONB_INT5 );
-    assert( JSONB_FLOAT+0x01==JSONB_FLOAT5 );
-    assert( JSONB_INT+0x02==JSONB_FLOAT );
-    if( z[i]=='+' ) i++;
-    jsonBlobAppendNode(pParse, JSONB_INT+t, 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: {
-    i += 1 + (u32)strspn(&z[i+1], jsonSpaces);
-    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]) ){
-      jsonBlobAppendOneByte(pParse, JSONB_NULL);
-      return i+4;
-    }
-    /* fall-through into the default case that checks for NaN */
-    /* no break */ deliberate_fall_through
-  }
-  default: {
-    u32 k;
-    int nn;
-    c = z[i];
-    for(k=0; k<sizeof(aNanInfName)/sizeof(aNanInfName[0]); k++){
-      if( c!=aNanInfName[k].c1 && c!=aNanInfName[k].c2 ) continue;
-      nn = aNanInfName[k].n;
-      if( sqlite3StrNICmp(&z[i], aNanInfName[k].zMatch, nn)!=0 ){
-        continue;
-      }
-      if( sqlite3Isalnum(z[i+nn]) ) continue;
-      if( aNanInfName[k].eType==JSONB_FLOAT ){
-        jsonBlobAppendNode(pParse, JSONB_FLOAT, 5, "9e999");
-      }else{
-        jsonBlobAppendOneByte(pParse, JSONB_NULL);
-      }
-      pParse->hasNonstd = 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 held by pParse,
-** but not pParse itself.
-**
-** pParse must be initialized to an empty parse object prior to calling
-** this routine.
-*/
-static int jsonConvertTextToBlob(
-  JsonParse *pParse,           /* Initialize and fill this JsonParse object */
-  sqlite3_context *pCtx        /* Report errors here */
-){
-  int i;
-  const char *zJson = pParse->zJson;
-  i = jsonTranslateTextToBlob(pParse, 0);
-  if( pParse->oom ) i = -1;
-  if( i>0 ){
-#ifdef SQLITE_DEBUG
-    assert( pParse->iDepth==0 );
-    if( sqlite3Config.bJsonSelfcheck ){
-      assert( jsonbValidityCheck(pParse, 0, pParse->nBlob, 0)==0 );
-    }
-#endif
-    while( jsonIsspace(zJson[i]) ) i++;
-    if( zJson[i] ){
-      i += json5Whitespace(&zJson[i]);
-      if( zJson[i] ){
-        if( pCtx ) sqlite3_result_error(pCtx, "malformed JSON", -1);
-        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;
-}
-
-/*
-** The input string pStr is a well-formed JSON text string.  Convert
-** this into the JSONB format and make it the return value of the
-** SQL function.
-*/
-static void jsonReturnStringAsBlob(JsonString *pStr){
-  JsonParse px;
-  assert( pStr->eErr==0 );
-  memset(&px, 0, sizeof(px));
-  px.zJson = pStr->zBuf;
-  px.nJson = pStr->nUsed;
-  px.db = sqlite3_context_db_handle(pStr->pCtx);
-  (void)jsonTranslateTextToBlob(&px, 0);
-  if( px.oom ){
-    sqlite3DbFree(px.db, px.aBlob);
-    sqlite3_result_error_nomem(pStr->pCtx);
-  }else{
-    assert( px.nBlobAlloc>0 );
-    assert( !px.bReadOnly );
-    sqlite3_result_blob(pStr->pCtx, px.aBlob, px.nBlob, SQLITE_DYNAMIC);
-  }
-}
-
-/* The byte at index i is a node type-code.  This routine
-** determines the payload size for that node and writes that
-** payload size in to *pSz.  It returns the offset from i to the
-** beginning of the payload.  Return 0 on error.
-*/
-static u32 jsonbPayloadSize(const JsonParse *pParse, u32 i, u32 *pSz){
-  u8 x;
-  u32 sz;
-  u32 n;
-  assert( i<=pParse->nBlob );
-  x = pParse->aBlob[i]>>4;
-  if( x<=11 ){
-    sz = x;
-    n = 1;
-  }else if( x==12 ){
-    if( i+1>=pParse->nBlob ){
-      *pSz = 0;
-      return 0;
-    }
-    sz = pParse->aBlob[i+1];
-    n = 2;
-  }else if( x==13 ){
-    if( i+2>=pParse->nBlob ){
-      *pSz = 0;
-      return 0;
-    }
-    sz = (pParse->aBlob[i+1]<<8) + pParse->aBlob[i+2];
-    n = 3;
-  }else if( x==14 ){
-    if( i+4>=pParse->nBlob ){
-      *pSz = 0;
-      return 0;
-    }
-    sz = ((u32)pParse->aBlob[i+1]<<24) + (pParse->aBlob[i+2]<<16) +
-         (pParse->aBlob[i+3]<<8) + pParse->aBlob[i+4];
-    n = 5;
-  }else{
-    if( i+8>=pParse->nBlob
-     || pParse->aBlob[i+1]!=0
-     || pParse->aBlob[i+2]!=0
-     || pParse->aBlob[i+3]!=0
-     || pParse->aBlob[i+4]!=0
-    ){
-      *pSz = 0;
-      return 0;
-    }
-    sz = ((u32)pParse->aBlob[i+5]<<24) + (pParse->aBlob[i+6]<<16) +
-         (pParse->aBlob[i+7]<<8) + pParse->aBlob[i+8];
-    n = 9;
-  }
-  if( (i64)i+sz+n > pParse->nBlob
-   && (i64)i+sz+n > pParse->nBlob-pParse->delta
-  ){
-    *pSz = 0;
-    return 0;
-  }
-  *pSz = sz;
-  return n;
-}
-
-
-/*
-** Translate the binary JSONB representation of JSON beginning at
-** pParse->aBlob[i] into a JSON text string.  Append the JSON
-** text onto the end of pOut.  Return the index in pParse->aBlob[]
-** of the first byte past the end of the element that is translated.
-**
-** If an error is detected in the BLOB input, the pOut->eErr flag
-** might get set to JSTRING_MALFORMED.  But not all BLOB input errors
-** are detected.  So a malformed JSONB input might either result
-** in an error, or in incorrect JSON.
-**
-** The pOut->eErr JSTRING_OOM flag is set on a OOM.
-*/
-static u32 jsonTranslateBlobToText(
-  JsonParse *pParse,             /* the complete parse of the JSON */
-  u32 i,                         /* Start rendering at this index */
-  JsonString *pOut               /* Write JSON here */
-){
-  u32 sz, n, j, iEnd;
-
-  n = jsonbPayloadSize(pParse, i, &sz);
-  if( n==0 ){
-    pOut->eErr |= JSTRING_MALFORMED;
-    return pParse->nBlob+1;
-  }
-  switch( pParse->aBlob[i] & 0x0f ){
-    case JSONB_NULL: {
-      jsonAppendRawNZ(pOut, "null", 4);
-      return i+1;
-    }
-    case JSONB_TRUE: {
-      jsonAppendRawNZ(pOut, "true", 4);
-      return i+1;
-    }
-    case JSONB_FALSE: {
-      jsonAppendRawNZ(pOut, "false", 5);
-      return i+1;
-    }
-    case JSONB_INT:
-    case JSONB_FLOAT: {
-      if( sz==0 ) goto malformed_jsonb;
-      jsonAppendRaw(pOut, (const char*)&pParse->aBlob[i+n], sz);
-      break;
-    }
-    case JSONB_INT5: {  /* Integer literal in hexadecimal notation */
-      u32 k = 2;
-      sqlite3_uint64 u = 0;
-      const char *zIn = (const char*)&pParse->aBlob[i+n];
-      int bOverflow = 0;
-      if( sz==0 ) goto malformed_jsonb;
-      if( zIn[0]=='-' ){
-        jsonAppendChar(pOut, '-');
-        k++;
-      }else if( zIn[0]=='+' ){
-        k++;
-      }
-      for(; k<sz; k++){
-        if( !sqlite3Isxdigit(zIn[k]) ){
-          pOut->eErr |= JSTRING_MALFORMED;
-          break;
-        }else if( (u>>60)!=0 ){
-          bOverflow = 1;
-        }else{
-          u = u*16 + sqlite3HexToInt(zIn[k]);
-        }
-      }
-      jsonPrintf(100,pOut,bOverflow?"9.0e999":"%llu", u);
-      break;
-    }
-    case JSONB_FLOAT5: { /* Float literal missing digits beside "." */
-      u32 k = 0;
-      const char *zIn = (const char*)&pParse->aBlob[i+n];
-      if( sz==0 ) goto malformed_jsonb;
-      if( zIn[0]=='-' ){
-        jsonAppendChar(pOut, '-');
-        k++;
-      }
-      if( zIn[k]=='.' ){
-        jsonAppendChar(pOut, '0');
-      }
-      for(; k<sz; k++){
-        jsonAppendChar(pOut, zIn[k]);
-        if( zIn[k]=='.' && (k+1==sz || !sqlite3Isdigit(zIn[k+1])) ){
-          jsonAppendChar(pOut, '0');
-        }
-      }
-      break;
-    }
-    case JSONB_TEXT:
-    case JSONB_TEXTJ: {
-      if( pOut->nUsed+sz+2<=pOut->nAlloc || jsonStringGrow(pOut, sz+2)==0 ){
-        pOut->zBuf[pOut->nUsed] = '"';
-        memcpy(pOut->zBuf+pOut->nUsed+1,(const char*)&pParse->aBlob[i+n],sz);
-        pOut->zBuf[pOut->nUsed+sz+1] = '"';
-        pOut->nUsed += sz+2;
-      }
-      break;
-    }
-    case JSONB_TEXT5: {
-      const char *zIn;
-      u32 k;
-      u32 sz2 = sz;
-      zIn = (const char*)&pParse->aBlob[i+n];
-      jsonAppendChar(pOut, '"');
-      while( sz2>0 ){
-        for(k=0; k<sz2 && (jsonIsOk[(u8)zIn[k]] || zIn[k]=='\''); k++){}
-        if( k>0 ){
-          jsonAppendRawNZ(pOut, zIn, k);
-          if( k>=sz2 ){
-            break;
-          }
-          zIn += k;
-          sz2 -= k;
-        }
-        if( zIn[0]=='"' ){
-          jsonAppendRawNZ(pOut, "\\\"", 2);
-          zIn++;
-          sz2--;
-          continue;
-        }
-        if( zIn[0]<=0x1f ){
-          if( pOut->nUsed+7>pOut->nAlloc && jsonStringGrow(pOut,7) ) break;
-          jsonAppendControlChar(pOut, zIn[0]);
-          zIn++;
-          sz2--;
-          continue;
-        }
-        assert( zIn[0]=='\\' );
-        assert( sz2>=1 );
-        if( sz2<2 ){
-          pOut->eErr |= JSTRING_MALFORMED;
-          break;
-        }
-        switch( (u8)zIn[1] ){
-          case '\'':
-            jsonAppendChar(pOut, '\'');
-            break;
-          case 'v':
-            jsonAppendRawNZ(pOut, "\\u000b", 6);
-            break;
-          case 'x':
-            if( sz2<4 ){
-              pOut->eErr |= JSTRING_MALFORMED;
-              sz2 = 2;
-              break;
-            }
-            jsonAppendRawNZ(pOut, "\\u00", 4);
-            jsonAppendRawNZ(pOut, &zIn[2], 2);
-            zIn += 2;
-            sz2 -= 2;
-            break;
-          case '0':
-            jsonAppendRawNZ(pOut, "\\u0000", 6);
-            break;
-          case '\r':
-            if( sz2>2 && zIn[2]=='\n' ){
-              zIn++;
-              sz2--;
-            }
-            break;
-          case '\n':
-            break;
-          case 0xe2:
-            /* '\' followed by either U+2028 or U+2029 is ignored as
-            ** whitespace.  Not that in UTF8, U+2028 is 0xe2 0x80 0x29.
-            ** U+2029 is the same except for the last byte */
-            if( sz2<4
-             || 0x80!=(u8)zIn[2]
-             || (0xa8!=(u8)zIn[3] && 0xa9!=(u8)zIn[3])
-            ){
-              pOut->eErr |= JSTRING_MALFORMED;
-              sz2 = 2;
-              break;
-            }
-            zIn += 2;
-            sz2 -= 2;
-            break;
-          default:
-            jsonAppendRawNZ(pOut, zIn, 2);
-            break;
-        }
-        assert( sz2>=2 );
-        zIn += 2;
-        sz2 -= 2;
-      }
-      jsonAppendChar(pOut, '"');
-      break;
-    }
-    case JSONB_TEXTRAW: {
-      jsonAppendString(pOut, (const char*)&pParse->aBlob[i+n], sz);
-      break;
-    }
-    case JSONB_ARRAY: {
-      jsonAppendChar(pOut, '[');
-      j = i+n;
-      iEnd = j+sz;
-      if( ++pParse->iDepth > JSON_MAX_DEPTH ){
-        jsonStringTooDeep(pOut);
-      }
-      while( j<iEnd && pOut->eErr==0 ){
-        j = jsonTranslateBlobToText(pParse, j, pOut);
-        jsonAppendChar(pOut, ',');
-      }
-      pParse->iDepth--;
-      if( j>iEnd ) pOut->eErr |= JSTRING_MALFORMED;
-      if( sz>0 ) jsonStringTrimOneChar(pOut);
-      jsonAppendChar(pOut, ']');
-      break;
-    }
-    case JSONB_OBJECT: {
-      int x = 0;
-      jsonAppendChar(pOut, '{');
-      j = i+n;
-      iEnd = j+sz;
-      if( ++pParse->iDepth > JSON_MAX_DEPTH ){
-        jsonStringTooDeep(pOut);
-      }
-      while( j<iEnd && pOut->eErr==0 ){
-        j = jsonTranslateBlobToText(pParse, j, pOut);
-        jsonAppendChar(pOut, (x++ & 1) ? ',' : ':');
-      }
-      pParse->iDepth--;
-      if( (x & 1)!=0 || j>iEnd ) pOut->eErr |= JSTRING_MALFORMED;
-      if( sz>0 ) jsonStringTrimOneChar(pOut);
-      jsonAppendChar(pOut, '}');
-      break;
-    }
-
-    default: {
-      malformed_jsonb:
-      pOut->eErr |= JSTRING_MALFORMED;
-      break;
-    }
-  }
-  return i+n+sz;
-}
-
-/* Context for recursion of json_pretty()
-*/
-typedef struct JsonPretty JsonPretty;
-struct JsonPretty {
-  JsonParse *pParse;        /* The BLOB being rendered */
-  JsonString *pOut;         /* Generate pretty output into this string */
-  const char *zIndent;      /* Use this text for indentation */
-  u32 szIndent;             /* Bytes in zIndent[] */
-  u32 nIndent;              /* Current level of indentation */
-};
-
-/* Append indentation to the pretty JSON under construction */
-static void jsonPrettyIndent(JsonPretty *pPretty){
-  u32 jj;
-  for(jj=0; jj<pPretty->nIndent; jj++){
-    jsonAppendRaw(pPretty->pOut, pPretty->zIndent, pPretty->szIndent);
-  }
-}
-
-/*
-** Translate the binary JSONB representation of JSON beginning at
-** pParse->aBlob[i] into a JSON text string.  Append the JSON
-** text onto the end of pOut.  Return the index in pParse->aBlob[]
-** of the first byte past the end of the element that is translated.
-**
-** This is a variant of jsonTranslateBlobToText() that "pretty-prints"
-** the output.  Extra whitespace is inserted to make the JSON easier
-** for humans to read.
-**
-** If an error is detected in the BLOB input, the pOut->eErr flag
-** might get set to JSTRING_MALFORMED.  But not all BLOB input errors
-** are detected.  So a malformed JSONB input might either result
-** in an error, or in incorrect JSON.
-**
-** The pOut->eErr JSTRING_OOM flag is set on a OOM.
-*/
-static u32 jsonTranslateBlobToPrettyText(
-  JsonPretty *pPretty,       /* Pretty-printing context */
-  u32 i                      /* Start rendering at this index */
-){
-  u32 sz, n, j, iEnd;
-  JsonParse *pParse = pPretty->pParse;
-  JsonString *pOut = pPretty->pOut;
-  n = jsonbPayloadSize(pParse, i, &sz);
-  if( n==0 ){
-    pOut->eErr |= JSTRING_MALFORMED;
-    return pParse->nBlob+1;
-  }
-  switch( pParse->aBlob[i] & 0x0f ){
-    case JSONB_ARRAY: {
-      j = i+n;
-      iEnd = j+sz;
-      jsonAppendChar(pOut, '[');
-      if( j<iEnd ){
-        jsonAppendChar(pOut, '\n');
-        pPretty->nIndent++;
-        if( pPretty->nIndent >= JSON_MAX_DEPTH ){
-          jsonStringTooDeep(pOut);
-        }
-        while( pOut->eErr==0 ){
-          jsonPrettyIndent(pPretty);
-          j = jsonTranslateBlobToPrettyText(pPretty, j);
-          if( j>=iEnd ) break;
-          jsonAppendRawNZ(pOut, ",\n", 2);
-        }
-        jsonAppendChar(pOut, '\n');
-        pPretty->nIndent--;
-        jsonPrettyIndent(pPretty);
-      }
-      jsonAppendChar(pOut, ']');
-      i = iEnd;
-      break;
-    }
-    case JSONB_OBJECT: {
-      j = i+n;
-      iEnd = j+sz;
-      jsonAppendChar(pOut, '{');
-      if( j<iEnd ){
-        jsonAppendChar(pOut, '\n');
-        pPretty->nIndent++;
-        if( pPretty->nIndent >= JSON_MAX_DEPTH ){
-          jsonStringTooDeep(pOut);
-        }
-        pParse->iDepth = pPretty->nIndent;
-        while( pOut->eErr==0 ){
-          jsonPrettyIndent(pPretty);
-          j = jsonTranslateBlobToText(pParse, j, pOut);
-          if( j>iEnd ){
-            pOut->eErr |= JSTRING_MALFORMED;
-            break;
-          }
-          jsonAppendRawNZ(pOut, ": ", 2);
-          j = jsonTranslateBlobToPrettyText(pPretty, j);
-          if( j>=iEnd ) break;
-          jsonAppendRawNZ(pOut, ",\n", 2);
-        }
-        jsonAppendChar(pOut, '\n');
-        pPretty->nIndent--;
-        jsonPrettyIndent(pPretty);
-      }
-      jsonAppendChar(pOut, '}');
-      i = iEnd;
-      break;
-    }
-    default: {
-      i = jsonTranslateBlobToText(pParse, i, pOut);
-      break;
-    }
-  }
-  return i;
-}
-
-/*
-** Given that a JSONB_ARRAY object starts at offset i, return
-** the number of entries in that array.
-*/
-static u32 jsonbArrayCount(JsonParse *pParse, u32 iRoot){
-  u32 n, sz, i, iEnd;
-  u32 k = 0;
-  n = jsonbPayloadSize(pParse, iRoot, &sz);
-  iEnd = iRoot+n+sz;
-  for(i=iRoot+n; n>0 && i<iEnd; i+=sz+n, k++){
-    n = jsonbPayloadSize(pParse, i, &sz);
-  }
-  return k;
-}
-
-/*
-** Edit the payload size of the element at iRoot by the amount in
-** pParse->delta.
-*/
-static void jsonAfterEditSizeAdjust(JsonParse *pParse, u32 iRoot){
-  u32 sz = 0;
-  u32 nBlob;
-  assert( pParse->delta!=0 );
-  assert( pParse->nBlobAlloc >= pParse->nBlob );
-  nBlob = pParse->nBlob;
-  pParse->nBlob = pParse->nBlobAlloc;
-  (void)jsonbPayloadSize(pParse, iRoot, &sz);
-  pParse->nBlob = nBlob;
-  sz += pParse->delta;
-  pParse->delta += jsonBlobChangePayloadSize(pParse, iRoot, sz);
-}
-
-/*
-** If the JSONB at aIns[0..nIns-1] can be expanded (by denormalizing the
-** size field) by d bytes, then write the expansion into aOut[] and
-** return true.  In this way, an overwrite happens without changing the
-** size of the JSONB, which reduces memcpy() operations and also make it
-** faster and easier to update the B-Tree entry that contains the JSONB
-** in the database.
-**
-** If the expansion of aIns[] by d bytes cannot be (easily) accomplished
-** then return false.
-**
-** The d parameter is guaranteed to be between 1 and 8.
-**
-** This routine is an optimization.  A correct answer is obtained if it
-** always leaves the output unchanged and returns false.
-*/
-static int jsonBlobOverwrite(
-  u8 *aOut,                 /* Overwrite here */
-  const u8 *aIns,           /* New content */
-  u32 nIns,                 /* Bytes of new content */
-  u32 d                     /* Need to expand new content by this much */
-){
-  u32 szPayload;       /* Bytes of payload */
-  u32 i;               /* New header size, after expansion & a loop counter */
-  u8 szHdr;            /* Size of header before expansion */
-
-  /* Lookup table for finding the upper 4 bits of the first byte of the
-  ** expanded aIns[], based on the size of the expanded aIns[] header:
-  **
-  **                             2     3  4     5  6  7  8     9 */
-  static const u8 aType[] = { 0xc0, 0xd0, 0, 0xe0, 0, 0, 0, 0xf0 };
-
-  if( (aIns[0]&0x0f)<=2 ) return 0;    /* Cannot enlarge NULL, true, false */
-  switch( aIns[0]>>4 ){
-    default: {                         /* aIns[] header size 1 */
-      if( ((1<<d)&0x116)==0 ) return 0;  /* d must be 1, 2, 4, or 8 */
-      i = d + 1;                         /* New hdr sz: 2, 3, 5, or 9 */
-      szHdr = 1;
-      break;
-    }
-    case 12: {                         /* aIns[] header size is 2 */
-      if( ((1<<d)&0x8a)==0) return 0;    /* d must be 1, 3, or 7 */
-      i = d + 2;                         /* New hdr sz: 2, 5, or 9 */
-      szHdr = 2;
-      break;
-    }
-    case 13: {                         /* aIns[] header size is 3 */
-      if( d!=2 && d!=6 ) return 0;       /* d must be 2 or 6 */
-      i = d + 3;                         /* New hdr sz: 5 or 9 */
-      szHdr = 3;
-      break;
-    }
-    case 14: {                         /* aIns[] header size is 5 */
-      if( d!=4 ) return 0;               /* d must be 4 */
-      i = 9;                             /* New hdr sz: 9 */
-      szHdr = 5;
-      break;
-    }
-    case 15: {                         /* aIns[] header size is 9 */
-      return 0;                          /* No solution */
-    }
-  }
-  assert( i>=2 && i<=9 && aType[i-2]!=0 );
-  aOut[0] = (aIns[0] & 0x0f) | aType[i-2];
-  memcpy(&aOut[i], &aIns[szHdr], nIns-szHdr);
-  szPayload = nIns - szHdr;
-  while( 1/*edit-by-break*/ ){
-    i--;
-    aOut[i] = szPayload & 0xff;
-    if( i==1 ) break;
-    szPayload >>= 8;
-  }
-  assert( (szPayload>>8)==0 );
-  return 1;
-}
-
-/*
-** Modify the JSONB blob at pParse->aBlob by removing nDel bytes of
-** content beginning at iDel, and replacing them with nIns bytes of
-** content given by aIns.
-**
-** nDel may be zero, in which case no bytes are removed.  But iDel is
-** still important as new bytes will be insert beginning at iDel.
-**
-** aIns may be zero, in which case space is created to hold nIns bytes
-** beginning at iDel, but that space is uninitialized.
-**
-** Set pParse->oom if an OOM occurs.
-*/
-static void jsonBlobEdit(
-  JsonParse *pParse,     /* The JSONB to be modified is in pParse->aBlob */
-  u32 iDel,              /* First byte to be removed */
-  u32 nDel,              /* Number of bytes to remove */
-  const u8 *aIns,        /* Content to insert */
-  u32 nIns               /* Bytes of content to insert */
-){
-  i64 d = (i64)nIns - (i64)nDel;
-  assert( pParse->nBlob >= (u64)iDel + (u64)nDel );
-  if( d<0 && d>=(-8) && aIns!=0
-   && jsonBlobOverwrite(&pParse->aBlob[iDel], aIns, nIns, (int)-d)
-  ){
-    return;
-  }
-  if( d!=0 ){
-    if( pParse->nBlob + d > pParse->nBlobAlloc ){
-      jsonBlobExpand(pParse, pParse->nBlob+d);
-      if( pParse->oom ) return;
-    }
-    memmove(&pParse->aBlob[iDel+nIns],
-            &pParse->aBlob[iDel+nDel],
-            pParse->nBlob - (iDel+nDel));
-    pParse->nBlob += d;
-    pParse->delta += d;
-  }
-  if( nIns && aIns ){
-    memcpy(&pParse->aBlob[iDel], aIns, nIns);
-  }
-}
-
-/*
-** Return the number of escaped newlines to be ignored.
-** An escaped newline is a one of the following byte sequences:
-**
-**    0x5c 0x0a
-**    0x5c 0x0d
-**    0x5c 0x0d 0x0a
-**    0x5c 0xe2 0x80 0xa8
-**    0x5c 0xe2 0x80 0xa9
-*/
-static u32 jsonBytesToBypass(const char *z, u32 n){
-  u32 i = 0;
-  while( i+1<n ){
-    if( z[i]!='\\' ) return i;
-    if( z[i+1]=='\n' ){
-      i += 2;
-      continue;
-    }
-    if( z[i+1]=='\r' ){
-      if( i+2<n && z[i+2]=='\n' ){
-        i += 3;
-      }else{
-        i += 2;
-      }
-      continue;
-    }
-    if( 0xe2==(u8)z[i+1]
-     && i+3<n
-     && 0x80==(u8)z[i+2]
-     && (0xa8==(u8)z[i+3] || 0xa9==(u8)z[i+3])
-    ){
-      i += 4;
-      continue;
-    }
-    break;
-  }
-  return i;
-}
-
-/*
-** Input z[0..n] defines JSON escape sequence including the leading '\\'.
-** Decode that escape sequence into a single character.  Write that
-** character into *piOut.  Return the number of bytes in the escape sequence.
-**
-** If there is a syntax error of some kind (for example too few characters
-** after the '\\' to complete the encoding) then *piOut is set to
-** JSON_INVALID_CHAR.
-*/
-static u32 jsonUnescapeOneChar(const char *z, u32 n, u32 *piOut){
-  assert( n>0 );
-  assert( z[0]=='\\' );
-  if( n<2 ){
-    *piOut = JSON_INVALID_CHAR;
-    return n;
-  }
-  switch( (u8)z[1] ){
-    case 'u': {
-      u32 v, vlo;
-      if( n<6 ){
-        *piOut = JSON_INVALID_CHAR;
-        return n;
-      }
-      v = jsonHexToInt4(&z[2]);
-      if( (v & 0xfc00)==0xd800
-       && n>=12
-       && z[6]=='\\'
-       && z[7]=='u'
-       && ((vlo = jsonHexToInt4(&z[8]))&0xfc00)==0xdc00
-      ){
-        *piOut = ((v&0x3ff)<<10) + (vlo&0x3ff) + 0x10000;
-        return 12;
-      }else{
-        *piOut = v;
-        return 6;
-      }
-    }
-    case 'b': {   *piOut = '\b';  return 2; }
-    case 'f': {   *piOut = '\f';  return 2; }
-    case 'n': {   *piOut = '\n';  return 2; }
-    case 'r': {   *piOut = '\r';  return 2; }
-    case 't': {   *piOut = '\t';  return 2; }
-    case 'v': {   *piOut = '\v';  return 2; }
-    case '0': {
-      /* JSON5 requires that the \0 escape not be followed by a digit.
-      ** But SQLite did not enforce this restriction in versions 3.42.0
-      ** through 3.49.2.  That was a bug.  But some applications might have
-      ** come to depend on that bug.  Use the SQLITE_BUG_COMPATIBLE_20250510
-      ** option to restore the old buggy behavior. */
-#ifdef SQLITE_BUG_COMPATIBLE_20250510
-      /* Legacy bug-compatible behavior */
-      *piOut = 0;
-#else
-      /* Correct behavior */
-      *piOut = (n>2 && sqlite3Isdigit(z[2])) ? JSON_INVALID_CHAR : 0;
-#endif
-      return 2;
-    }
-    case '\'':
-    case '"':
-    case '/':
-    case '\\':{   *piOut = z[1];  return 2; }
-    case 'x': {
-      if( n<4 ){
-        *piOut = JSON_INVALID_CHAR;
-        return n;
-      }
-      *piOut = (jsonHexToInt(z[2])<<4) | jsonHexToInt(z[3]);
-      return 4;
-    }
-    case 0xe2:
-    case '\r':
-    case '\n': {
-      u32 nSkip = jsonBytesToBypass(z, n);
-      if( nSkip==0 ){
-        *piOut = JSON_INVALID_CHAR;
-        return n;
-      }else if( nSkip==n ){
-        *piOut = 0;
-        return n;
-      }else if( z[nSkip]=='\\' ){
-        return nSkip + jsonUnescapeOneChar(&z[nSkip], n-nSkip, piOut);
-      }else{
-        int sz = sqlite3Utf8ReadLimited((u8*)&z[nSkip], n-nSkip, piOut);
-        return nSkip + sz;
-      }
-    }
-    default: {
-      *piOut = JSON_INVALID_CHAR;
-      return 2;
-    }
-  }
-}
-
-
-/*
-** Compare two object labels.  Return 1 if they are equal and
-** 0 if they differ.
-**
-** In this version, we know that one or the other or both of the
-** two comparands contains an escape sequence.
-*/
-static SQLITE_NOINLINE int jsonLabelCompareEscaped(
-  const char *zLeft,          /* The left label */
-  u32 nLeft,                  /* Size of the left label in bytes */
-  int rawLeft,                /* True if zLeft contains no escapes */
-  const char *zRight,         /* The right label */
-  u32 nRight,                 /* Size of the right label in bytes */
-  int rawRight                /* True if zRight is escape-free */
-){
-  u32 cLeft, cRight;
-  assert( rawLeft==0 || rawRight==0 );
-  while( 1 /*exit-by-return*/ ){
-    if( nLeft==0 ){
-      cLeft = 0;
-    }else if( rawLeft || zLeft[0]!='\\' ){
-      cLeft = ((u8*)zLeft)[0];
-      if( cLeft>=0xc0 ){
-        int sz = sqlite3Utf8ReadLimited((u8*)zLeft, nLeft, &cLeft);
-        zLeft += sz;
-        nLeft -= sz;
-      }else{
-        zLeft++;
-        nLeft--;
-      }
-    }else{
-      u32 n = jsonUnescapeOneChar(zLeft, nLeft, &cLeft);
-      zLeft += n;
-      assert( n<=nLeft );
-      nLeft -= n;
-    }
-    if( nRight==0 ){
-      cRight = 0;
-    }else if( rawRight || zRight[0]!='\\' ){
-      cRight = ((u8*)zRight)[0];
-      if( cRight>=0xc0 ){
-        int sz = sqlite3Utf8ReadLimited((u8*)zRight, nRight, &cRight);
-        zRight += sz;
-        nRight -= sz;
-      }else{
-        zRight++;
-        nRight--;
-      }
-    }else{
-      u32 n = jsonUnescapeOneChar(zRight, nRight, &cRight);
-      zRight += n;
-      assert( n<=nRight );
-      nRight -= n;
-    }
-    if( cLeft!=cRight ) return 0;
-    if( cLeft==0 ) return 1;
-  }
-}
-
-/*
-** Compare two object labels.  Return 1 if they are equal and
-** 0 if they differ.  Return -1 if an OOM occurs.
-*/
-static int jsonLabelCompare(
-  const char *zLeft,          /* The left label */
-  u32 nLeft,                  /* Size of the left label in bytes */
-  int rawLeft,                /* True if zLeft contains no escapes */
-  const char *zRight,         /* The right label */
-  u32 nRight,                 /* Size of the right label in bytes */
-  int rawRight                /* True if zRight is escape-free */
-){
-  if( rawLeft && rawRight ){
-    /* Simpliest case:  Neither label contains escapes.  A simple
-    ** memcmp() is sufficient. */
-    if( nLeft!=nRight ) return 0;
-    return memcmp(zLeft, zRight, nLeft)==0;
-  }else{
-    return jsonLabelCompareEscaped(zLeft, nLeft, rawLeft,
-                                   zRight, nRight, rawRight);
-  }
-}
-
-/*
-** Error returns from jsonLookupStep()
-*/
-#define JSON_LOOKUP_ERROR      0xffffffff
-#define JSON_LOOKUP_NOTFOUND   0xfffffffe
-#define JSON_LOOKUP_NOTARRAY   0xfffffffd
-#define JSON_LOOKUP_TOODEEP    0xfffffffc
-#define JSON_LOOKUP_PATHERROR  0xfffffffb
-#define JSON_LOOKUP_ISERROR(x) ((x)>=JSON_LOOKUP_PATHERROR)
-
-/* Forward declaration */
-static u32 jsonLookupStep(JsonParse*,u32,const char*,u32);
-
-
-/* This helper routine for jsonLookupStep() populates pIns with
-** binary data that is to be inserted into pParse.
-**
-** In the common case, pIns just points to pParse->aIns and pParse->nIns.
-** But if the zPath of the original edit operation includes path elements
-** that go deeper, additional substructure must be created.
-**
-** For example:
-**
-**     json_insert('{}', '$.a.b.c', 123);
-**
-** The search stops at '$.a'  But additional substructure must be
-** created for the ".b.c" part of the patch so that the final result
-** is:  {"a":{"b":{"c"::123}}}.  This routine populates pIns with
-** the binary equivalent of {"b":{"c":123}} so that it can be inserted.
-**
-** The caller is responsible for resetting pIns when it has finished
-** using the substructure.
-*/
-static u32 jsonCreateEditSubstructure(
-  JsonParse *pParse,  /* The original JSONB that is being edited */
-  JsonParse *pIns,    /* Populate this with the blob data to insert */
-  const char *zTail   /* Tail of the path that determines substructure */
-){
-  static const u8 emptyObject[] = { JSONB_ARRAY, JSONB_OBJECT };
-  int rc;
-  memset(pIns, 0, sizeof(*pIns));
-  pIns->db = pParse->db;
-  if( zTail[0]==0 ){
-    /* No substructure.  Just insert what is given in pParse. */
-    pIns->aBlob = pParse->aIns;
-    pIns->nBlob = pParse->nIns;
-    rc = 0;
-  }else{
-    /* Construct the binary substructure */
-    pIns->nBlob = 1;
-    pIns->aBlob = (u8*)&emptyObject[zTail[0]=='.'];
-    pIns->eEdit = pParse->eEdit;
-    pIns->nIns = pParse->nIns;
-    pIns->aIns = pParse->aIns;
-    pIns->iDepth = pParse->iDepth+1;
-    if( pIns->iDepth >= JSON_MAX_DEPTH ){
-      return JSON_LOOKUP_TOODEEP;
-    }
-    rc = jsonLookupStep(pIns, 0, zTail, 0);
-    pParse->iDepth--;
-    pParse->oom |= pIns->oom;
-  }
-  return rc;  /* Error code only */
-}
-
-/*
-** Search along zPath to find the Json element specified.  Return an
-** index into pParse->aBlob[] for the start of that element's value.
-**
-** If the value found by this routine is the value half of label/value pair
-** within an object, then set pPath->iLabel to the start of the corresponding
-** label, before returning.
-**
-** Return one of the JSON_LOOKUP error codes if problems are seen.
-**
-** This routine will also modify the blob.  If pParse->eEdit is one of
-** JEDIT_DEL, JEDIT_REPL, JEDIT_INS, JEDIT_SET, or JEDIT_AINS, then changes
-** might be made to the selected value. If an edit is performed, then the
-** return value does not necessarily point to the select element. If an edit
-** is performed, the return value is only useful for detecting error
-** conditions.
-*/
-static u32 jsonLookupStep(
-  JsonParse *pParse,      /* The JSON to search */
-  u32 iRoot,              /* Begin the search at this element of aBlob[] */
-  const char *zPath,      /* The path to search */
-  u32 iLabel              /* Label if iRoot is a value of in an object */
-){
-  u32 i, j, k, nKey, sz, n, iEnd, rc;
-  const char *zKey;
-  u8 x;
-
-  if( zPath[0]==0 ){
-    if( pParse->eEdit && jsonBlobMakeEditable(pParse, pParse->nIns) ){
-      n = jsonbPayloadSize(pParse, iRoot, &sz);
-      sz += n;
-      if( pParse->eEdit==JEDIT_DEL ){
-        if( iLabel>0 ){
-          sz += iRoot - iLabel;
-          iRoot = iLabel;
-        }
-        jsonBlobEdit(pParse, iRoot, sz, 0, 0);
-      }else if( pParse->eEdit==JEDIT_INS ){
-        /* Already exists, so json_insert() is a no-op */
-      }else if( pParse->eEdit==JEDIT_AINS ){
-        /* json_array_insert() */
-        if( zPath[-1]!=']' ){
-          return JSON_LOOKUP_NOTARRAY;
-        }else{
-          jsonBlobEdit(pParse, iRoot, 0, pParse->aIns, pParse->nIns);
-        }
-      }else{
-        /* json_set() or json_replace() */
-        jsonBlobEdit(pParse, iRoot, sz, pParse->aIns, pParse->nIns);
-      }
-    }
-    pParse->iLabel = iLabel;
-    return iRoot;
-  }
-  if( zPath[0]=='.' ){
-    int rawKey = 1;
-    x = pParse->aBlob[iRoot];
-    zPath++;
-    if( zPath[0]=='"' ){
-      zKey = zPath + 1;
-      for(i=1; zPath[i] && zPath[i]!='"'; i++){
-        if( zPath[i]=='\\' && zPath[i+1]!=0 ) i++;
-      }
-      nKey = i-1;
-      if( zPath[i] ){
-        i++;
-      }else{
-        return JSON_LOOKUP_PATHERROR;
-      }
-      testcase( nKey==0 );
-      rawKey = memchr(zKey, '\\', nKey)==0;
-    }else{
-      zKey = zPath;
-      for(i=0; zPath[i] && zPath[i]!='.' && zPath[i]!='['; i++){}
-      nKey = i;
-      if( nKey==0 ){
-        return JSON_LOOKUP_PATHERROR;
-      }
-    }
-    if( (x & 0x0f)!=JSONB_OBJECT ) return JSON_LOOKUP_NOTFOUND;
-    n = jsonbPayloadSize(pParse, iRoot, &sz);
-    j = iRoot + n;  /* j is the index of a label */
-    iEnd = j+sz;
-    while( j<iEnd ){
-      int rawLabel;
-      const char *zLabel;
-      x = pParse->aBlob[j] & 0x0f;
-      if( x<JSONB_TEXT || x>JSONB_TEXTRAW ) return JSON_LOOKUP_ERROR;
-      n = jsonbPayloadSize(pParse, j, &sz);
-      if( n==0 ) return JSON_LOOKUP_ERROR;
-      k = j+n;  /* k is the index of the label text */
-      if( k+sz>=iEnd ) return JSON_LOOKUP_ERROR;
-      zLabel = (const char*)&pParse->aBlob[k];
-      rawLabel = x==JSONB_TEXT || x==JSONB_TEXTRAW;
-      if( jsonLabelCompare(zKey, nKey, rawKey, zLabel, sz, rawLabel) ){
-        u32 v = k+sz;  /* v is the index of the value */
-        if( ((pParse->aBlob[v])&0x0f)>JSONB_OBJECT ) return JSON_LOOKUP_ERROR;
-        n = jsonbPayloadSize(pParse, v, &sz);
-        if( n==0 || v+n+sz>iEnd ) return JSON_LOOKUP_ERROR;
-        assert( j>0 );
-        if( ++pParse->iDepth >= JSON_MAX_DEPTH ){
-          return JSON_LOOKUP_TOODEEP;
-        }
-        rc = jsonLookupStep(pParse, v, &zPath[i], j);
-        pParse->iDepth--;
-        if( pParse->delta ) jsonAfterEditSizeAdjust(pParse, iRoot);
-        return rc;
-      }
-      j = k+sz;
-      if( ((pParse->aBlob[j])&0x0f)>JSONB_OBJECT ) return JSON_LOOKUP_ERROR;
-      n = jsonbPayloadSize(pParse, j, &sz);
-      if( n==0 ) return JSON_LOOKUP_ERROR;
-      j += n+sz;
-    }
-    if( j>iEnd ) return JSON_LOOKUP_ERROR;
-    if( pParse->eEdit>=JEDIT_INS ){
-      u32 nIns;          /* Total bytes to insert (label+value) */
-      JsonParse v;       /* BLOB encoding of the value to be inserted */
-      JsonParse ix;      /* Header of the label to be inserted */
-      testcase( pParse->eEdit==JEDIT_INS );
-      testcase( pParse->eEdit==JEDIT_SET );
-      testcase( pParse->eEdit==JEDIT_AINS );
-      if( pParse->eEdit==JEDIT_AINS && sqlite3_strglob("*]",&zPath[i])!=0 ){
-        return JSON_LOOKUP_NOTARRAY;
-      }
-      memset(&ix, 0, sizeof(ix));
-      ix.db = pParse->db;
-      jsonBlobAppendNode(&ix, rawKey?JSONB_TEXTRAW:JSONB_TEXT5, nKey, 0);
-      pParse->oom |= ix.oom;
-      rc = jsonCreateEditSubstructure(pParse, &v, &zPath[i]);
-      if( !JSON_LOOKUP_ISERROR(rc)
-       && jsonBlobMakeEditable(pParse, ix.nBlob+nKey+v.nBlob)
-      ){
-        assert( !pParse->oom );
-        nIns = ix.nBlob + nKey + v.nBlob;
-        jsonBlobEdit(pParse, j, 0, 0, nIns);
-        if( !pParse->oom ){
-          assert( pParse->aBlob!=0 ); /* Because pParse->oom!=0 */
-          assert( ix.aBlob!=0 );      /* Because pPasre->oom!=0 */
-          memcpy(&pParse->aBlob[j], ix.aBlob, ix.nBlob);
-          k = j + ix.nBlob;
-          memcpy(&pParse->aBlob[k], zKey, nKey);
-          k += nKey;
-          memcpy(&pParse->aBlob[k], v.aBlob, v.nBlob);
-          if( ALWAYS(pParse->delta) ) jsonAfterEditSizeAdjust(pParse, iRoot);
-        }
-      }
-      jsonParseReset(&v);
-      jsonParseReset(&ix);
-      return rc;
-    }
-  }else if( zPath[0]=='[' ){
-    u64 kk = 0;
-    x = pParse->aBlob[iRoot] & 0x0f;
-    if( x!=JSONB_ARRAY )  return JSON_LOOKUP_NOTFOUND;
-    n = jsonbPayloadSize(pParse, iRoot, &sz);
-    i = 1;
-    while( sqlite3Isdigit(zPath[i]) ){
-      if( kk<0xffffffff ) kk = kk*10 + zPath[i] - '0';
-      /*     ^^^^^^^^^^--- Allow kk to be bigger than any JSON array so that
-      ** we get NOTFOUND instead of PATHERROR, without overflowing kk. */
-      i++;
-    }
-    if( i<2 || zPath[i]!=']' ){
-      if( zPath[1]=='#' ){
-        kk = jsonbArrayCount(pParse, iRoot);
-        i = 2;
-        if( zPath[2]=='-' && sqlite3Isdigit(zPath[3]) ){
-          u64 nn = 0;
-          i = 3;
-          do{
-            if( nn<0xffffffff ) nn = nn*10 + zPath[i] - '0';
-            /*     ^^^^^^^^^^--- Allow nn to be bigger than any JSON array to
-            ** get NOTFOUND instead of PATHERROR, without overflowing nn. */
-            i++;
-          }while( sqlite3Isdigit(zPath[i]) );
-          if( nn>kk ) return JSON_LOOKUP_NOTFOUND;
-          kk -= nn;
-        }
-        if( zPath[i]!=']' ){
-          return JSON_LOOKUP_PATHERROR;
-        }
-      }else{
-        return JSON_LOOKUP_PATHERROR;
-      }
-    }
-    j = iRoot+n;
-    iEnd = j+sz;
-    while( j<iEnd ){
-      if( kk==0 ){
-        if( ++pParse->iDepth >= JSON_MAX_DEPTH ){
-          return JSON_LOOKUP_TOODEEP;
-        }
-        rc = jsonLookupStep(pParse, j, &zPath[i+1], 0);
-        pParse->iDepth--;
-        if( pParse->delta ) jsonAfterEditSizeAdjust(pParse, iRoot);
-        return rc;
-      }
-      kk--;
-      n = jsonbPayloadSize(pParse, j, &sz);
-      if( n==0 ) return JSON_LOOKUP_ERROR;
-      j += n+sz;
-    }
-    if( j>iEnd ) return JSON_LOOKUP_ERROR;
-    if( kk>0 ) return JSON_LOOKUP_NOTFOUND;
-    if( pParse->eEdit>=JEDIT_INS ){
-      JsonParse v;
-      testcase( pParse->eEdit==JEDIT_INS );
-      testcase( pParse->eEdit==JEDIT_AINS );
-      testcase( pParse->eEdit==JEDIT_SET );
-      rc = jsonCreateEditSubstructure(pParse, &v, &zPath[i+1]);
-      if( !JSON_LOOKUP_ISERROR(rc)
-       && jsonBlobMakeEditable(pParse, v.nBlob)
-      ){
-        assert( !pParse->oom );
-        jsonBlobEdit(pParse, j, 0, v.aBlob, v.nBlob);
-      }
-      jsonParseReset(&v);
-      if( pParse->delta ) jsonAfterEditSizeAdjust(pParse, iRoot);
-      return rc;
-    }
-  }else{
-    return JSON_LOOKUP_PATHERROR;
-  }
-  return JSON_LOOKUP_NOTFOUND;
-}
-
-/*
-** Convert a JSON BLOB into text and make that text the return value
-** of an SQL function.
-*/
-static void jsonReturnTextJsonFromBlob(
-  sqlite3_context *ctx,
-  const u8 *aBlob,
-  u32 nBlob
-){
-  JsonParse x;
-  JsonString s;
-
-  if( NEVER(aBlob==0) ) return;
-  memset(&x, 0, sizeof(x));
-  x.aBlob = (u8*)aBlob;
-  x.nBlob = nBlob;
-  jsonStringInit(&s, ctx);
-  jsonTranslateBlobToText(&x, 0, &s);
-  jsonReturnString(&s, 0, 0);
-}
-
-
-/*
-** Return the value of the BLOB node at index i.
-**
-** If the value is a primitive, return it as an SQL value.
-** If the value is an array or object, return it as either
-** JSON text or the BLOB encoding, depending on the eMode flag
-** as follows:
-**
-**     eMode==0     JSONB if the JSON_B flag is set in userdata or
-**                  text if the JSON_B flag is omitted from userdata.
-**
-**     eMode==1     Text
-**
-**     eMode==2     JSONB
-*/
-static void jsonReturnFromBlob(
-  JsonParse *pParse,          /* Complete JSON parse tree */
-  u32 i,                      /* Index of the node */
-  sqlite3_context *pCtx,      /* Return value for this function */
-  int eMode                   /* Format of return: text of JSONB */
-){
-  u32 n, sz;
-  int rc;
-  sqlite3 *db = sqlite3_context_db_handle(pCtx);
-
-  assert( eMode>=0 && eMode<=2 );
-  n = jsonbPayloadSize(pParse, i, &sz);
-  if( n==0 ){
-    sqlite3_result_error(pCtx, "malformed JSON", -1);
-    return;
-  }
-  switch( pParse->aBlob[i] & 0x0f ){
-    case JSONB_NULL: {
-      if( sz ) goto returnfromblob_malformed;
-      sqlite3_result_null(pCtx);
-      break;
-    }
-    case JSONB_TRUE: {
-      if( sz ) goto returnfromblob_malformed;
-      sqlite3_result_int(pCtx, 1);
-      break;
-    }
-    case JSONB_FALSE: {
-      if( sz ) goto returnfromblob_malformed;
-      sqlite3_result_int(pCtx, 0);
-      break;
-    }
-    case JSONB_INT5:
-    case JSONB_INT: {
-      sqlite3_int64 iRes = 0;
-      char *z;
-      int bNeg = 0;
-      char x;
-      if( sz==0 ) goto returnfromblob_malformed;
-      x = (char)pParse->aBlob[i+n];
-      if( x=='-' ){
-        if( sz<2 ) goto returnfromblob_malformed;
-        n++;
-        sz--;
-        bNeg = 1;
-      }
-      z = sqlite3DbStrNDup(db, (const char*)&pParse->aBlob[i+n], (int)sz);
-      if( z==0 ) goto returnfromblob_oom;
-      rc = sqlite3DecOrHexToI64(z, &iRes);
-      sqlite3DbFree(db, z);
-      if( rc==0 ){
-        if( iRes<0 ){
-          /* A hexadecimal literal with 16 significant digits and with the
-          ** high-order bit set is a negative integer in SQLite (and hence
-          ** iRes comes back as negative) but should be interpreted as a
-          ** positive value if it occurs within JSON.  The value is too
-          ** large to appear as an SQLite integer so it must be converted
-          ** into floating point. */
-          double r;
-          r = (double)*(sqlite3_uint64*)&iRes;
-          sqlite3_result_double(pCtx, bNeg ? -r : r);
-        }else{
-          sqlite3_result_int64(pCtx, bNeg ? -iRes : iRes);
-        }
-      }else if( rc==3 && bNeg ){
-        sqlite3_result_int64(pCtx, SMALLEST_INT64);
-      }else if( rc==1 ){
-        goto returnfromblob_malformed;
-      }else{
-        if( bNeg ){ n--; sz++; }
-        goto to_double;
-      }
-      break;
-    }
-    case JSONB_FLOAT5:
-    case JSONB_FLOAT: {
-      double r;
-      char *z;
-      if( sz==0 ) goto returnfromblob_malformed;
-    to_double:
-      z = sqlite3DbStrNDup(db, (const char*)&pParse->aBlob[i+n], (int)sz);
-      if( z==0 ) goto returnfromblob_oom;
-      rc = sqlite3AtoF(z, &r);
-      sqlite3DbFree(db, z);
-      if( rc<=0 ) goto returnfromblob_malformed;
-      sqlite3_result_double(pCtx, r);
-      break;
-    }
-    case JSONB_TEXTRAW:
-    case JSONB_TEXT: {
-      sqlite3_result_text(pCtx, (char*)&pParse->aBlob[i+n], sz,
-                          SQLITE_TRANSIENT);
-      break;
-    }
-    case JSONB_TEXT5:
-    case JSONB_TEXTJ: {
-      /* Translate JSON formatted string into raw text */
-      u32 iIn, iOut;
-      const char *z;
-      char *zOut;
-      u32 nOut = sz;
-      z = (const char*)&pParse->aBlob[i+n];
-      zOut = sqlite3DbMallocRaw(db, ((u64)nOut)+1);
-      if( zOut==0 ) goto returnfromblob_oom;
-      for(iIn=iOut=0; iIn<sz; iIn++){
-        char c = z[iIn];
-        if( c=='\\' ){
-          u32 v;
-          u32 szEscape = jsonUnescapeOneChar(&z[iIn], sz-iIn, &v);
-          if( v<=0x7f ){
-            zOut[iOut++] = (char)v;
-          }else if( v<=0x7ff ){
-            assert( szEscape>=2 );
-            zOut[iOut++] = (char)(0xc0 | (v>>6));
-            zOut[iOut++] = 0x80 | (v&0x3f);
-          }else if( v<0x10000 ){
-            assert( szEscape>=3 );
-            zOut[iOut++] = 0xe0 | (v>>12);
-            zOut[iOut++] = 0x80 | ((v>>6)&0x3f);
-            zOut[iOut++] = 0x80 | (v&0x3f);
-          }else if( v==JSON_INVALID_CHAR ){
-            /* Silently ignore illegal unicode */
-          }else{
-            assert( szEscape>=4 );
-            zOut[iOut++] = 0xf0 | (v>>18);
-            zOut[iOut++] = 0x80 | ((v>>12)&0x3f);
-            zOut[iOut++] = 0x80 | ((v>>6)&0x3f);
-            zOut[iOut++] = 0x80 | (v&0x3f);
-          }
-          iIn += szEscape - 1;
-        }else{
-          zOut[iOut++] = c;
-        }
-      } /* end for() */
-      assert( iOut<=nOut );
-      zOut[iOut] = 0;
-      sqlite3_result_text(pCtx, zOut, iOut, SQLITE_DYNAMIC);
-      break;
-    }
-    case JSONB_ARRAY:
-    case JSONB_OBJECT: {
-      if( eMode==0 ){
-        if( (SQLITE_PTR_TO_INT(sqlite3_user_data(pCtx)) & JSON_BLOB)!=0 ){
-          eMode = 2;
-        }else{
-          eMode = 1;
-        }
-      }
-      if( eMode==2 ){
-        sqlite3_result_blob(pCtx, &pParse->aBlob[i], sz+n, SQLITE_TRANSIENT);
-      }else{
-        jsonReturnTextJsonFromBlob(pCtx, &pParse->aBlob[i], sz+n);
-      }
-      break;
-    }
-    default: {
-      goto returnfromblob_malformed;
-    }
-  }
-  return;
-
-returnfromblob_oom:
-  sqlite3_result_error_nomem(pCtx);
-  return;
-
-returnfromblob_malformed:
-  sqlite3_result_error(pCtx, "malformed JSON", -1);
-  return;
-}
-
-/*
-** pArg is a function argument that might be an SQL value or a JSON
-** value.  Figure out what it is and encode it as a JSONB blob.
-** Return the results in pParse.
-**
-** pParse is uninitialized upon entry.  This routine will handle the
-** initialization of pParse.  The result will be contained in
-** pParse->aBlob and pParse->nBlob.  pParse->aBlob might be dynamically
-** allocated (if pParse->nBlobAlloc is greater than zero) in which case
-** the caller is responsible for freeing the space allocated to pParse->aBlob
-** when it has finished with it.  Or pParse->aBlob might be a static string
-** or a value obtained from sqlite3_value_blob(pArg).
-**
-** If the argument is a BLOB that is clearly not a JSONB, then this
-** function might set an error message in ctx and return non-zero.
-** It might also set an error message and return non-zero on an OOM error.
-*/
-static int jsonFunctionArgToBlob(
-  sqlite3_context *ctx,
-  sqlite3_value *pArg,
-  JsonParse *pParse
-){
-  int eType = sqlite3_value_type(pArg);
-  static u8 aNull[] = { 0x00 };
-  memset(pParse, 0, sizeof(pParse[0]));
-  pParse->db = sqlite3_context_db_handle(ctx);
-  switch( eType ){
-    default: {
-      pParse->aBlob = aNull;
-      pParse->nBlob = 1;
-      return 0;
-    }
-    case SQLITE_BLOB: {
-      if( !jsonArgIsJsonb(pArg, pParse) ){
-        sqlite3_result_error(ctx, "JSON cannot hold BLOB values", -1);
-        return 1;
-      }
-      break;
-    }
-    case SQLITE_TEXT: {
-      const char *zJson = (const char*)sqlite3_value_text(pArg);
-      int nJson = sqlite3_value_bytes(pArg);
-      if( zJson==0 ) return 1;
-      if( sqlite3_value_subtype(pArg)==JSON_SUBTYPE ){
-        pParse->zJson = (char*)zJson;
-        pParse->nJson = nJson;
-        if( jsonConvertTextToBlob(pParse, ctx) ){
-          sqlite3_result_error(ctx, "malformed JSON", -1);
-          sqlite3DbFree(pParse->db, pParse->aBlob);
-          memset(pParse, 0, sizeof(pParse[0]));
-          return 1;
-        }
-      }else{
-        jsonBlobAppendNode(pParse, JSONB_TEXTRAW, nJson, zJson);
-      }
-      break;
-    }
-    case SQLITE_FLOAT: {
-      double r = sqlite3_value_double(pArg);
-      if( NEVER(sqlite3IsNaN(r)) ){
-        jsonBlobAppendNode(pParse, JSONB_NULL, 0, 0);
-      }else{
-        int n = sqlite3_value_bytes(pArg);
-        const char *z = (const char*)sqlite3_value_text(pArg);
-        if( z==0 ) return 1;
-        if( z[0]=='I' ){
-          jsonBlobAppendNode(pParse, JSONB_FLOAT, 5, "9e999");
-        }else if( z[0]=='-' && z[1]=='I' ){
-          jsonBlobAppendNode(pParse, JSONB_FLOAT, 6, "-9e999");
-        }else{
-          jsonBlobAppendNode(pParse, JSONB_FLOAT, n, z);
-        }
-      }
-      break;
-    }
-    case SQLITE_INTEGER: {
-      int n = sqlite3_value_bytes(pArg);
-      const char *z = (const char*)sqlite3_value_text(pArg);
-      if( z==0 ) return 1;
-      jsonBlobAppendNode(pParse, JSONB_INT, n, z);
-      break;
-    }
-  }
-  if( pParse->oom ){
-    sqlite3_result_error_nomem(ctx);
-    return 1;
-  }else{
-    return 0;
-  }
-}
-
-/*
-** Generate a path error.
-**
-** The specifics of the error are determined by the rc argument.
-**
-**          rc                        error
-**  -----------------       ----------------------
-**  JSON_LOOKUP_ARRAY       "not an array"
-**  JSON_LOOKUP_TOODEEP     "JSON nested too deep"
-**  JSON_LOOKUP_ERROR       "malformed JSON"
-**  otherwise...            "bad JSON path"
-**
-** If ctx is not NULL then push the error message into ctx and return NULL.
-** If ctx is NULL, then return the text of the error message.
-*/
-static char *jsonBadPathError(
-  sqlite3_context *ctx,     /* The function call containing the error */
-  const char *zPath,        /* The path with the problem */
-  int rc                    /* Maybe JSON_LOOKUP_NOTARRAY */
-){
-  char *zMsg;
-  if( rc==(int)JSON_LOOKUP_NOTARRAY ){
-    zMsg = sqlite3_mprintf("not an array element: %Q", zPath);
-  }else if( rc==(int)JSON_LOOKUP_ERROR ){
-    zMsg = sqlite3_mprintf("malformed JSON");
-  }else if( rc==(int)JSON_LOOKUP_TOODEEP ){
-    zMsg = sqlite3_mprintf("JSON path too deep");
-  }else{
-    zMsg = sqlite3_mprintf("bad JSON path: %Q", zPath);
-  }
-  if( ctx==0 ) return zMsg;
-  if( zMsg ){
-    sqlite3_result_error(ctx, zMsg, -1);
-    sqlite3_free(zMsg);
-  }else{
-    sqlite3_result_error_nomem(ctx);
-  }
-  return 0;
-}
-
-/* argv[0] is a BLOB that seems likely to be a JSONB.  Subsequent
-** arguments come in pairs where each pair contains a JSON path and
-** content to insert or set at that patch.  Do the updates
-** and return the result.
-**
-** The specific operation is determined by eEdit, which can be one
-** of JEDIT_INS, JEDIT_REPL, JEDIT_SET, or JEDIT_AINS.
-*/
-static void jsonInsertIntoBlob(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv,
-  int eEdit                /* JEDIT_INS, JEDIT_REPL, JEDIT_SET, JEDIT_AINS */
-){
-  int i;
-  u32 rc = 0;
-  const char *zPath = 0;
-  int flgs;
-  JsonParse *p;
-  JsonParse ax;
-
-  assert( (argc&1)==1 );
-  flgs = argc==1 ? 0 : JSON_EDITABLE;
-  p = jsonParseFuncArg(ctx, argv[0], flgs);
-  if( p==0 ) return;
-  for(i=1; i<argc-1; i+=2){
-    if( sqlite3_value_type(argv[i])==SQLITE_NULL ) continue;
-    zPath = (const char*)sqlite3_value_text(argv[i]);
-    if( zPath==0 ){
-      sqlite3_result_error_nomem(ctx);
-      jsonParseFree(p);
-      return;
-    }
-    if( zPath[0]!='$' ) goto jsonInsertIntoBlob_patherror;
-    if( jsonFunctionArgToBlob(ctx, argv[i+1], &ax) ){
-      jsonParseReset(&ax);
-      jsonParseFree(p);
-      return;
-    }
-    if( zPath[1]==0 ){
-      if( eEdit==JEDIT_REPL || eEdit==JEDIT_SET ){
-        jsonBlobEdit(p, 0, p->nBlob, ax.aBlob, ax.nBlob);
-      }
-      rc = 0;
-   }else{
-      p->eEdit = eEdit;
-      p->nIns = ax.nBlob;
-      p->aIns = ax.aBlob;
-      p->delta = 0;
-      p->iDepth = 0;
-      rc = jsonLookupStep(p, 0, zPath+1, 0);
-    }
-    jsonParseReset(&ax);
-    if( rc==JSON_LOOKUP_NOTFOUND ) continue;
-    if( JSON_LOOKUP_ISERROR(rc) ) goto jsonInsertIntoBlob_patherror;
-  }
-  jsonReturnParse(ctx, p);
-  jsonParseFree(p);
-  return;
-
-jsonInsertIntoBlob_patherror:
-  jsonParseFree(p);
-  jsonBadPathError(ctx, zPath, rc);
-  return;
-}
-
-/*
-** If pArg is a blob that seems like a JSONB blob, then initialize
-** p to point to that JSONB and return TRUE.  If pArg does not seem like
-** a JSONB blob, then return FALSE.
-**
-** For small BLOBs (having no more than 7 bytes of payload) a full
-** validity check is done.  So for small BLOBs this routine only returns
-** true if the value is guaranteed to be a valid JSONB.  For larger BLOBs
-** (8 byte or more of payload) only the size of the outermost element is
-** checked to verify that the BLOB is superficially valid JSONB.
-**
-** A full JSONB validation is done on smaller BLOBs because those BLOBs might
-** also be text JSON that has been incorrectly cast into a BLOB.
-** (See tag-20240123-a and https://sqlite.org/forum/forumpost/012136abd5)
-** If the BLOB is 9 bytes are larger, then it is not possible for the
-** superficial size check done here to pass if the input is really text
-** JSON so we do not need to look deeper in that case.
-**
-** Why we only need to do full JSONB validation for smaller BLOBs:
-**
-** The first byte of valid JSON text must be one of: '{', '[', '"', ' ', '\n',
-** '\r', '\t', '-', or a digit '0' through '9'.  Of these, only a subset
-** can also be the first byte of JSONB:  '{', '[', and digits '3'
-** through '9'.  In every one of those cases, the payload size is 7 bytes
-** or less.  So if we do full JSONB validation for every BLOB where the
-** payload is less than 7 bytes, we will never get a false positive for
-** JSONB on an input that is really text JSON.
-*/
-static int jsonArgIsJsonb(sqlite3_value *pArg, JsonParse *p){
-  u32 n, sz = 0;
-  u8 c;
-  if( sqlite3_value_type(pArg)!=SQLITE_BLOB ) return 0;
-  p->aBlob = (u8*)sqlite3_value_blob(pArg);
-  p->nBlob = (u32)sqlite3_value_bytes(pArg);
-  if( p->nBlob>0
-   && ALWAYS(p->aBlob!=0)
-   && ((c = p->aBlob[0]) & 0x0f)<=JSONB_OBJECT
-   && (n = jsonbPayloadSize(p, 0, &sz))>0
-   && sz+n==p->nBlob
-   && ((c & 0x0f)>JSONB_FALSE || sz==0)
-   && (sz>7
-      || (c!=0x7b && c!=0x5b && !sqlite3Isdigit(c))
-      || jsonbValidityCheck(p, 0, p->nBlob, 1)==0)
-  ){
-    return 1;
-  }
-  p->aBlob = 0;
-  p->nBlob = 0;
-  return 0;
-}
-
-/*
-** Generate a JsonParse object, containing valid JSONB in aBlob and nBlob,
-** from the SQL function argument pArg.  Return a pointer to the new
-** JsonParse object.
-**
-** Ownership of the new JsonParse object is passed to the caller.  The
-** caller should invoke jsonParseFree() on the return value when it
-** has finished using it.
-**
-** If any errors are detected, an appropriate error messages is set
-** using sqlite3_result_error() or the equivalent and this routine
-** returns NULL.  This routine also returns NULL if the pArg argument
-** is an SQL NULL value, but no error message is set in that case.  This
-** is so that SQL functions that are given NULL arguments will return
-** a NULL value.
-*/
-static JsonParse *jsonParseFuncArg(
-  sqlite3_context *ctx,
-  sqlite3_value *pArg,
-  u32 flgs
-){
-  int eType;                   /* Datatype of pArg */
-  JsonParse *p = 0;            /* Value to be returned */
-  JsonParse *pFromCache = 0;   /* Value taken from cache */
-  sqlite3 *db;                 /* The database connection */
-
-  assert( ctx!=0 );
-  eType = sqlite3_value_type(pArg);
-  if( eType==SQLITE_NULL ){
-    return 0;
-  }
-  pFromCache = jsonCacheSearch(ctx, pArg);
-  if( pFromCache ){
-    pFromCache->nJPRef++;
-    if( (flgs & JSON_EDITABLE)==0 ){
-      return pFromCache;
-    }
-  }
-  db = sqlite3_context_db_handle(ctx);
-rebuild_from_cache:
-  p = sqlite3DbMallocZero(db, sizeof(*p));
-  if( p==0 ) goto json_pfa_oom;
-  memset(p, 0, sizeof(*p));
-  p->db = db;
-  p->nJPRef = 1;
-  if( pFromCache!=0 ){
-    u32 nBlob = pFromCache->nBlob;
-    p->aBlob = sqlite3DbMallocRaw(db, nBlob);
-    if( p->aBlob==0 ) goto json_pfa_oom;
-    memcpy(p->aBlob, pFromCache->aBlob, nBlob);
-    p->nBlobAlloc = p->nBlob = nBlob;
-    p->hasNonstd = pFromCache->hasNonstd;
-    jsonParseFree(pFromCache);
-    return p;
-  }
-  if( eType==SQLITE_BLOB ){
-    if( jsonArgIsJsonb(pArg,p) ){
-      if( (flgs & JSON_EDITABLE)!=0 && jsonBlobMakeEditable(p, 0)==0 ){
-        goto json_pfa_oom;
-      }
-      return p;
-    }
-    /* If the blob is not valid JSONB, fall through into trying to cast
-    ** the blob into text which is then interpreted as JSON.  (tag-20240123-a)
-    **
-    ** This goes against all historical documentation about how the SQLite
-    ** JSON functions were suppose to work.  From the beginning, blob was
-    ** reserved for expansion and a blob value should have raised an error.
-    ** But it did not, due to a bug.  And many applications came to depend
-    ** upon this buggy behavior, especially when using the CLI and reading
-    ** JSON text using readfile(), which returns a blob.  For this reason
-    ** we will continue to support the bug moving forward.
-    ** See for example https://sqlite.org/forum/forumpost/012136abd5292b8d
-    */
-  }
-  p->zJson = (char*)sqlite3_value_text(pArg);
-  p->nJson = sqlite3_value_bytes(pArg);
-  if( db->mallocFailed ) goto json_pfa_oom;
-  if( p->nJson==0 ) goto json_pfa_malformed;
-  assert( p->zJson!=0 );
-  if( jsonConvertTextToBlob(p, (flgs & JSON_KEEPERROR) ? 0 : ctx) ){
-    if( flgs & JSON_KEEPERROR ){
-      p->nErr = 1;
-      return p;
-    }else{
-      jsonParseFree(p);
-      return 0;
-    }
-  }else{
-    int isRCStr = sqlite3ValueIsOfClass(pArg, sqlite3RCStrUnref);
-    int rc;
-    if( !isRCStr ){
-      char *zNew = sqlite3RCStrNew( p->nJson );
-      if( zNew==0 ) goto json_pfa_oom;
-      memcpy(zNew, p->zJson, p->nJson);
-      p->zJson = zNew;
-      p->zJson[p->nJson] = 0;
-    }else{
-      sqlite3RCStrRef(p->zJson);
-    }
-    p->bJsonIsRCStr = 1;
-    rc = jsonCacheInsert(ctx, p);
-    if( rc==SQLITE_NOMEM ) goto json_pfa_oom;
-    if( flgs & JSON_EDITABLE ){
-      pFromCache = p;
-      p = 0;
-      goto rebuild_from_cache;
-    }
-  }
-  return p;
-
-json_pfa_malformed:
-  if( flgs & JSON_KEEPERROR ){
-    p->nErr = 1;
-    return p;
-  }else{
-    jsonParseFree(p);
-    sqlite3_result_error(ctx, "malformed JSON", -1);
-    return 0;
-  }
-
-json_pfa_oom:
-  jsonParseFree(pFromCache);
-  jsonParseFree(p);
-  sqlite3_result_error_nomem(ctx);
-  return 0;
-}
-
-/*
-** Make the return value of a JSON function either the raw JSONB blob
-** or make it JSON text, depending on whether the JSON_BLOB flag is
-** set on the function.
-*/
-static void jsonReturnParse(
-  sqlite3_context *ctx,
-  JsonParse *p
-){
-  int flgs;
-  if( p->oom ){
-    sqlite3_result_error_nomem(ctx);
-    return;
-  }
-  flgs = SQLITE_PTR_TO_INT(sqlite3_user_data(ctx));
-  if( flgs & JSON_BLOB ){
-    if( p->nBlobAlloc>0 && !p->bReadOnly ){
-      sqlite3_result_blob(ctx, p->aBlob, p->nBlob, SQLITE_DYNAMIC);
-      p->nBlobAlloc = 0;
-    }else{
-      sqlite3_result_blob(ctx, p->aBlob, p->nBlob, SQLITE_TRANSIENT);
-    }
-  }else{
-    JsonString s;
-    jsonStringInit(&s, ctx);
-    p->delta = 0;
-    jsonTranslateBlobToText(p, 0, &s);
-    jsonReturnString(&s, p, ctx);
-    sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-  }
-}
-
-/****************************************************************************
-** SQL functions used for testing and debugging
-****************************************************************************/
-
-#if SQLITE_DEBUG
-/*
-** Decode JSONB bytes in aBlob[] starting at iStart through but not
-** including iEnd.  Indent the
-** content by nIndent spaces.
-*/
-static void jsonDebugPrintBlob(
-  JsonParse *pParse, /* JSON content */
-  u32 iStart,        /* Start rendering here */
-  u32 iEnd,          /* Do not render this byte or any byte after this one */
-  int nIndent,       /* Indent by this many spaces */
-  sqlite3_str *pOut  /* Generate output into this sqlite3_str object */
-){
-  while( iStart<iEnd ){
-    u32 i, n, nn, sz = 0;
-    int showContent = 1;
-    u8 x = pParse->aBlob[iStart] & 0x0f;
-    u32 savedNBlob = pParse->nBlob;
-    sqlite3_str_appendf(pOut, "%5d:%*s", iStart, nIndent, "");
-    if( pParse->nBlobAlloc>pParse->nBlob ){
-      pParse->nBlob = pParse->nBlobAlloc;
-    }
-    nn = n = jsonbPayloadSize(pParse, iStart, &sz);
-    if( nn==0 ) nn = 1;
-    if( sz>0 && x<JSONB_ARRAY ){
-      nn += sz;
-    }
-    for(i=0; i<nn; i++){
-      sqlite3_str_appendf(pOut, " %02x", pParse->aBlob[iStart+i]);
-    }
-    if( n==0 ){
-      sqlite3_str_appendf(pOut, "   ERROR invalid node size\n");
-      iStart = n==0 ? iStart+1 : iEnd;
-      continue;
-    }
-    pParse->nBlob = savedNBlob;
-    if( iStart+n+sz>iEnd ){
-      iEnd = iStart+n+sz;
-      if( iEnd>pParse->nBlob ){
-        if( pParse->nBlobAlloc>0 && iEnd>pParse->nBlobAlloc ){
-          iEnd = pParse->nBlobAlloc;
-        }else{
-          iEnd = pParse->nBlob;
-        }
-      }
-    }
-    sqlite3_str_appendall(pOut,"  <-- ");
-    switch( x ){
-      case JSONB_NULL:     sqlite3_str_appendall(pOut,"null"); break;
-      case JSONB_TRUE:     sqlite3_str_appendall(pOut,"true"); break;
-      case JSONB_FALSE:    sqlite3_str_appendall(pOut,"false"); break;
-      case JSONB_INT:      sqlite3_str_appendall(pOut,"int"); break;
-      case JSONB_INT5:     sqlite3_str_appendall(pOut,"int5"); break;
-      case JSONB_FLOAT:    sqlite3_str_appendall(pOut,"float"); break;
-      case JSONB_FLOAT5:   sqlite3_str_appendall(pOut,"float5"); break;
-      case JSONB_TEXT:     sqlite3_str_appendall(pOut,"text"); break;
-      case JSONB_TEXTJ:    sqlite3_str_appendall(pOut,"textj"); break;
-      case JSONB_TEXT5:    sqlite3_str_appendall(pOut,"text5"); break;
-      case JSONB_TEXTRAW:  sqlite3_str_appendall(pOut,"textraw"); break;
-      case JSONB_ARRAY: {
-        sqlite3_str_appendf(pOut,"array, %u bytes\n", sz);
-        jsonDebugPrintBlob(pParse, iStart+n, iStart+n+sz, nIndent+2, pOut);
-        showContent = 0;
-        break;
-      }
-      case JSONB_OBJECT: {
-        sqlite3_str_appendf(pOut, "object, %u bytes\n", sz);
-        jsonDebugPrintBlob(pParse, iStart+n, iStart+n+sz, nIndent+2, pOut);
-        showContent = 0;
-        break;
-      }
-      default: {
-        sqlite3_str_appendall(pOut, "ERROR: unknown node type\n");
-        showContent = 0;
-        break;
-      }
-    }
-    if( showContent ){
-      if( sz==0 && x<=JSONB_FALSE ){
-        sqlite3_str_append(pOut, "\n", 1);
-      }else{
-        u32 j;
-        sqlite3_str_appendall(pOut, ": \"");
-        for(j=iStart+n; j<iStart+n+sz; j++){
-          u8 c = pParse->aBlob[j];
-          if( c<0x20 || c>=0x7f ) c = '.';
-          sqlite3_str_append(pOut, (char*)&c, 1);
-        }
-        sqlite3_str_append(pOut, "\"\n", 2);
-      }
-    }
-    iStart += n + sz;
-  }
-}
-static void jsonShowParse(JsonParse *pParse){
-  sqlite3_str out;
-  char zBuf[1000];
-  if( pParse==0 ){
-    printf("NULL pointer\n");
-    return;
-  }else{
-    printf("nBlobAlloc = %u\n", pParse->nBlobAlloc);
-    printf("nBlob = %u\n", pParse->nBlob);
-    printf("delta = %d\n", pParse->delta);
-    if( pParse->nBlob==0 ) return;
-    printf("content (bytes 0..%u):\n", pParse->nBlob-1);
-  }
-  sqlite3StrAccumInit(&out, 0, zBuf, sizeof(zBuf), 1000000);
-  jsonDebugPrintBlob(pParse, 0, pParse->nBlob, 0, &out);
-  printf("%s", sqlite3_str_value(&out));
-  sqlite3_str_reset(&out);
-}
-#endif /* SQLITE_DEBUG */
-
-#ifdef SQLITE_DEBUG
-/*
-** SQL function:   json_parse(JSON)
-**
-** Parse JSON using jsonParseFuncArg().  Return text that is a
-** human-readable dump of the binary JSONB for the input parameter.
-*/
-static void jsonParseFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse *p;        /* The parse */
-  sqlite3_str out;
-
-  assert( argc>=1 );
-  sqlite3StrAccumInit(&out, 0, 0, 0, 1000000);
-  p = jsonParseFuncArg(ctx, argv[0], 0);
-  if( p==0 ) return;
-  if( argc==1 ){
-    jsonDebugPrintBlob(p, 0, p->nBlob, 0, &out);
-    sqlite3_result_text64(ctx,out.zText,out.nChar,SQLITE_TRANSIENT,SQLITE_UTF8);
-  }else{
-    jsonShowParse(p);
-  }
-  jsonParseFree(p);
-  sqlite3_str_reset(&out);
-}
-#endif /* SQLITE_DEBUG */
-
-/****************************************************************************
-** Scalar SQL function implementations
-****************************************************************************/
-
-/*
-** Implementation of the json_quote(VALUE) function.  Return a JSON value
-** corresponding to the SQL value input.  Mostly this means putting
-** double-quotes around strings and returning the unquoted string "null"
-** when given a NULL input.
-*/
-static void jsonQuoteFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonString jx;
-  UNUSED_PARAMETER(argc);
-
-  jsonStringInit(&jx, ctx);
-  jsonAppendSqlValue(&jx, argv[0]);
-  jsonReturnString(&jx, 0, 0);
-  sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-}
-
-/*
-** Implementation of the json_array(VALUE,...) function.  Return a JSON
-** array that contains all values given in arguments.  Or if any argument
-** is a BLOB, throw an error.
-*/
-static void jsonArrayFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  int i;
-  JsonString jx;
-
-  jsonStringInit(&jx, ctx);
-  jsonAppendChar(&jx, '[');
-  for(i=0; i<argc; i++){
-    jsonAppendSeparator(&jx);
-    jsonAppendSqlValue(&jx, argv[i]);
-  }
-  jsonAppendChar(&jx, ']');
-  jsonReturnString(&jx, 0, 0);
-  sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-}
-
-/*
-** json_array_length(JSON)
-** json_array_length(JSON, PATH)
-**
-** Return the number of elements in the top-level JSON array.
-** Return 0 if the input is not a well-formed JSON array.
-*/
-static void jsonArrayLengthFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse *p;          /* The parse */
-  sqlite3_int64 cnt = 0;
-  u32 i;
-  u8 eErr = 0;
-
-  p = jsonParseFuncArg(ctx, argv[0], 0);
-  if( p==0 ) return;
-  if( argc==2 ){
-    const char *zPath = (const char*)sqlite3_value_text(argv[1]);
-    if( zPath==0 ){
-      jsonParseFree(p);
-      return;
-    }
-    i = jsonLookupStep(p, 0, zPath[0]=='$' ? zPath+1 : "@", 0);
-    if( JSON_LOOKUP_ISERROR(i) ){
-      if( i==JSON_LOOKUP_NOTFOUND ){
-        /* no-op */
-      }else{
-        jsonBadPathError(ctx, zPath, i);
-      }
-      eErr = 1;
-      i = 0;
-    }
-  }else{
-    i = 0;
-  }
-  if( (p->aBlob[i] & 0x0f)==JSONB_ARRAY ){
-    cnt = jsonbArrayCount(p, i);
-  }
-  if( !eErr ) sqlite3_result_int64(ctx, cnt);
-  jsonParseFree(p);
-}
-
-/* True if the string is all alphanumerics and underscores */
-static int jsonAllAlphanum(const char *z, int n){
-  int i;
-  for(i=0; i<n && (sqlite3Isalnum(z[i]) || z[i]=='_'); i++){}
-  return i==n;
-}
-
-/*
-** 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 = 0;      /* The parse */
-  int flags;             /* Flags associated with the function */
-  int i;                 /* Loop counter */
-  JsonString jx;         /* String for array result */
-
-  if( argc<2 ) return;
-  p = jsonParseFuncArg(ctx, argv[0], 0);
-  if( p==0 ) return;
-  flags = SQLITE_PTR_TO_INT(sqlite3_user_data(ctx));
-  jsonStringInit(&jx, ctx);
-  if( argc>2 ){
-    jsonAppendChar(&jx, '[');
-  }
-  for(i=1; i<argc; i++){
-    /* With a single PATH argument */
-    const char *zPath = (const char*)sqlite3_value_text(argv[i]);
-    int nPath;
-    u32 j;
-    if( zPath==0 ) goto json_extract_error;
-    nPath = sqlite3Strlen30(zPath);
-    if( zPath[0]=='$' ){
-      j = jsonLookupStep(p, 0, zPath+1, 0);
-    }else if( (flags & JSON_ABPATH) ){
-      /* 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
-      **
-      ** Updated 2024-05-27:  If the NUMBER is negative, then PG counts from
-      ** the right of the array.  Hence for negative NUMBER:
-      **
-      **     NUMBER   ==>  $[#NUMBER]    // PG compatible
-      */
-      jsonStringInit(&jx, ctx);
-      if( sqlite3_value_type(argv[i])==SQLITE_INTEGER ){
-        jsonAppendRawNZ(&jx, "[", 1);
-        if( zPath[0]=='-' ) jsonAppendRawNZ(&jx,"#",1);
-        jsonAppendRaw(&jx, zPath, nPath);
-        jsonAppendRawNZ(&jx, "]", 2);
-      }else if( jsonAllAlphanum(zPath, nPath) ){
-        jsonAppendRawNZ(&jx, ".", 1);
-        jsonAppendRaw(&jx, zPath, nPath);
-      }else if( zPath[0]=='[' && nPath>=3 && zPath[nPath-1]==']' ){
-        jsonAppendRaw(&jx, zPath, nPath);
-      }else{
-        jsonAppendRawNZ(&jx, ".\"", 2);
-        jsonAppendRaw(&jx, zPath, nPath);
-        jsonAppendRawNZ(&jx, "\"", 1);
-      }
-      jsonStringTerminate(&jx);
-      j = jsonLookupStep(p, 0, jx.zBuf, 0);
-      jsonStringReset(&jx);
-    }else{
-      jsonBadPathError(ctx, zPath, 0);
-      goto json_extract_error;
-    }
-    if( j<p->nBlob ){
-      if( argc==2 ){
-        if( flags & JSON_JSON ){
-          jsonStringInit(&jx, ctx);
-          jsonTranslateBlobToText(p, j, &jx);
-          jsonReturnString(&jx, 0, 0);
-          jsonStringReset(&jx);
-          assert( (flags & JSON_BLOB)==0 );
-          sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-        }else{
-          jsonReturnFromBlob(p, j, ctx, 0);
-          if( (flags & (JSON_SQL|JSON_BLOB))==0
-           && (p->aBlob[j]&0x0f)>=JSONB_ARRAY
-          ){
-            sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-          }
-        }
-      }else{
-        jsonAppendSeparator(&jx);
-        jsonTranslateBlobToText(p, j, &jx);
-      }
-    }else if( j==JSON_LOOKUP_NOTFOUND ){
-      if( argc==2 ){
-        goto json_extract_error;  /* Return NULL if not found */
-      }else{
-        jsonAppendSeparator(&jx);
-        jsonAppendRawNZ(&jx, "null", 4);
-      }
-    }else{
-      jsonBadPathError(ctx, zPath, j);
-      goto json_extract_error;
-    }
-  }
-  if( argc>2 ){
-    jsonAppendChar(&jx, ']');
-    jsonReturnString(&jx, 0, 0);
-    if( (flags & JSON_BLOB)==0 ){
-      sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-    }
-  }
-json_extract_error:
-  jsonStringReset(&jx);
-  jsonParseFree(p);
-  return;
-}
-
-/*
-** Return codes for jsonMergePatch()
-*/
-#define JSON_MERGE_OK          0     /* Success */
-#define JSON_MERGE_BADTARGET   1     /* Malformed TARGET blob */
-#define JSON_MERGE_BADPATCH    2     /* Malformed PATCH blob */
-#define JSON_MERGE_OOM         3     /* Out-of-memory condition */
-#define JSON_MERGE_TOODEEP     4     /* Nested too deep */
-
-/*
-** RFC-7396 MergePatch for two JSONB blobs.
-**
-** pTarget is the target. pPatch is the patch.  The target is updated
-** in place.  The patch is read-only.
-**
-** The original RFC-7396 algorithm is this:
-**
-**   define MergePatch(Target, Patch):
-**     if Patch is an Object:
-**       if Target is not an Object:
-**         Target = {} # Ignore the contents and set it to an empty Object
-**     for each Name/Value pair in Patch:
-**         if Value is null:
-**           if Name exists in Target:
-**             remove the Name/Value pair from Target
-**         else:
-**           Target[Name] = MergePatch(Target[Name], Value)
-**       return Target
-**     else:
-**       return Patch
-**
-** Here is an equivalent algorithm restructured to show the actual
-** implementation:
-**
-** 01   define MergePatch(Target, Patch):
-** 02      if Patch is not an Object:
-** 03         return Patch
-** 04      else: // if Patch is an Object
-** 05         if Target is not an Object:
-** 06            Target = {}
-** 07      for each Name/Value pair in Patch:
-** 08         if Name exists in Target:
-** 09            if Value is null:
-** 10               remove the Name/Value pair from Target
-** 11            else
-** 12               Target[name] = MergePatch(Target[Name], Value)
-** 13         else if Value is not NULL:
-** 14            if Value is not an Object:
-** 15               Target[name] = Value
-** 16            else:
-** 17               Target[name] = MergePatch('{}',value)
-** 18      return Target
-**  |
-**  ^---- Line numbers referenced in comments in the implementation
-*/
-static int jsonMergePatch(
-  JsonParse *pTarget,      /* The JSON parser that contains the TARGET */
-  u32 iTarget,             /* Index of TARGET in pTarget->aBlob[] */
-  const JsonParse *pPatch, /* The PATCH */
-  u32 iPatch,              /* Index of PATCH in pPatch->aBlob[] */
-  u32 iDepth               /* Nesting depth */
-){
-  u8 x;             /* Type of a single node */
-  u32 n, sz=0;      /* Return values from jsonbPayloadSize() */
-  u32 iTCursor;     /* Cursor position while scanning the target object */
-  u32 iTStart;      /* First label in the target object */
-  u32 iTEndBE;      /* Original first byte past end of target, before edit */
-  u32 iTEnd;        /* Current first byte past end of target */
-  u8 eTLabel;       /* Node type of the target label */
-  u32 iTLabel = 0;  /* Index of the label */
-  u32 nTLabel = 0;  /* Header size in bytes for the target label */
-  u32 szTLabel = 0; /* Size of the target label payload */
-  u32 iTValue = 0;  /* Index of the target value */
-  u32 nTValue = 0;  /* Header size of the target value */
-  u32 szTValue = 0; /* Payload size for the target value */
-
-  u32 iPCursor;     /* Cursor position while scanning the patch */
-  u32 iPEnd;        /* First byte past the end of the patch */
-  u8 ePLabel;       /* Node type of the patch label */
-  u32 iPLabel;      /* Start of patch label */
-  u32 nPLabel;      /* Size of header on the patch label */
-  u32 szPLabel;     /* Payload size of the patch label */
-  u32 iPValue;      /* Start of patch value */
-  u32 nPValue;      /* Header size for the patch value */
-  u32 szPValue;     /* Payload size of the patch value */
-
-  assert( iTarget>=0 && iTarget<pTarget->nBlob );
-  assert( iPatch>=0 && iPatch<pPatch->nBlob );
-  x = pPatch->aBlob[iPatch] & 0x0f;
-  if( x!=JSONB_OBJECT ){  /* Algorithm line 02 */
-    u32 szPatch;        /* Total size of the patch, header+payload */
-    u32 szTarget;       /* Total size of the target, header+payload */
-    n = jsonbPayloadSize(pPatch, iPatch, &sz);
-    szPatch = n+sz;
-    sz = 0;
-    n = jsonbPayloadSize(pTarget, iTarget, &sz);
-    szTarget = n+sz;
-    jsonBlobEdit(pTarget, iTarget, szTarget, pPatch->aBlob+iPatch, szPatch);
-    return pTarget->oom ? JSON_MERGE_OOM : JSON_MERGE_OK;  /* Line 03 */
-  }
-  x = pTarget->aBlob[iTarget] & 0x0f;
-  if( x!=JSONB_OBJECT ){  /* Algorithm line 05 */
-    n = jsonbPayloadSize(pTarget, iTarget, &sz);
-    jsonBlobEdit(pTarget, iTarget+n, sz, 0, 0);
-    x = pTarget->aBlob[iTarget];
-    pTarget->aBlob[iTarget] = (x & 0xf0) | JSONB_OBJECT;
-  }
-  n = jsonbPayloadSize(pPatch, iPatch, &sz);
-  if( NEVER(n==0) ) return JSON_MERGE_BADPATCH;
-  iPCursor = iPatch+n;
-  iPEnd = iPCursor+sz;
-  n = jsonbPayloadSize(pTarget, iTarget, &sz);
-  if( NEVER(n==0) ) return JSON_MERGE_BADTARGET;
-  iTStart = iTarget+n;
-  iTEndBE = iTStart+sz;
-
-  while( iPCursor<iPEnd ){  /* Algorithm line 07 */
-    iPLabel = iPCursor;
-    ePLabel = pPatch->aBlob[iPCursor] & 0x0f;
-    if( ePLabel<JSONB_TEXT || ePLabel>JSONB_TEXTRAW ){
-      return JSON_MERGE_BADPATCH;
-    }
-    nPLabel = jsonbPayloadSize(pPatch, iPCursor, &szPLabel);
-    if( nPLabel==0 ) return JSON_MERGE_BADPATCH;
-    iPValue = iPCursor + nPLabel + szPLabel;
-    if( iPValue>=iPEnd ) return JSON_MERGE_BADPATCH;
-    nPValue = jsonbPayloadSize(pPatch, iPValue, &szPValue);
-    if( nPValue==0 ) return JSON_MERGE_BADPATCH;
-    iPCursor = iPValue + nPValue + szPValue;
-    if( iPCursor>iPEnd ) return JSON_MERGE_BADPATCH;
-
-    iTCursor = iTStart;
-    iTEnd = iTEndBE + pTarget->delta;
-    while( iTCursor<iTEnd ){
-      int isEqual;   /* true if the patch and target labels match */
-      iTLabel = iTCursor;
-      eTLabel = pTarget->aBlob[iTCursor] & 0x0f;
-      if( eTLabel<JSONB_TEXT || eTLabel>JSONB_TEXTRAW ){
-        return JSON_MERGE_BADTARGET;
-      }
-      nTLabel = jsonbPayloadSize(pTarget, iTCursor, &szTLabel);
-      if( nTLabel==0 ) return JSON_MERGE_BADTARGET;
-      iTValue = iTLabel + nTLabel + szTLabel;
-      if( iTValue>=iTEnd ) return JSON_MERGE_BADTARGET;
-      nTValue = jsonbPayloadSize(pTarget, iTValue, &szTValue);
-      if( nTValue==0 ) return JSON_MERGE_BADTARGET;
-      if( iTValue + nTValue + szTValue > iTEnd ) return JSON_MERGE_BADTARGET;
-      isEqual = jsonLabelCompare(
-                   (const char*)&pPatch->aBlob[iPLabel+nPLabel],
-                   szPLabel,
-                   (ePLabel==JSONB_TEXT || ePLabel==JSONB_TEXTRAW),
-                   (const char*)&pTarget->aBlob[iTLabel+nTLabel],
-                   szTLabel,
-                   (eTLabel==JSONB_TEXT || eTLabel==JSONB_TEXTRAW));
-      if( isEqual ) break;
-      iTCursor = iTValue + nTValue + szTValue;
-    }
-    x = pPatch->aBlob[iPValue] & 0x0f;
-    if( iTCursor<iTEnd ){
-      /* A match was found.  Algorithm line 08 */
-      if( x==0 ){
-        /* Patch value is NULL.  Algorithm line 09 */
-        jsonBlobEdit(pTarget, iTLabel, nTLabel+szTLabel+nTValue+szTValue, 0,0);
-        /*  vvvvvv----- No OOM on a delete-only edit */
-        if( NEVER(pTarget->oom) ) return JSON_MERGE_OOM;
-      }else{
-        /* Algorithm line 12 */
-        int rc, savedDelta = pTarget->delta;
-        pTarget->delta = 0;
-        if( iDepth>=JSON_MAX_DEPTH ) return JSON_MERGE_TOODEEP;
-        rc = jsonMergePatch(pTarget, iTValue, pPatch, iPValue, iDepth+1);
-        if( rc ) return rc;
-        pTarget->delta += savedDelta;
-      }
-    }else if( x>0 ){  /* Algorithm line 13 */
-      /* No match and patch value is not NULL */
-      u32 szNew = szPLabel+nPLabel;
-      if( (pPatch->aBlob[iPValue] & 0x0f)!=JSONB_OBJECT ){  /* Line 14 */
-        jsonBlobEdit(pTarget, iTEnd, 0, 0, szPValue+nPValue+szNew);
-        if( pTarget->oom ) return JSON_MERGE_OOM;
-        memcpy(&pTarget->aBlob[iTEnd], &pPatch->aBlob[iPLabel], szNew);
-        memcpy(&pTarget->aBlob[iTEnd+szNew],
-               &pPatch->aBlob[iPValue], szPValue+nPValue);
-      }else{
-        int rc, savedDelta;
-        jsonBlobEdit(pTarget, iTEnd, 0, 0, szNew+1);
-        if( pTarget->oom ) return JSON_MERGE_OOM;
-        memcpy(&pTarget->aBlob[iTEnd], &pPatch->aBlob[iPLabel], szNew);
-        pTarget->aBlob[iTEnd+szNew] = 0x00;
-        savedDelta = pTarget->delta;
-        pTarget->delta = 0;
-        if( iDepth>=JSON_MAX_DEPTH ) return JSON_MERGE_TOODEEP;
-        rc = jsonMergePatch(pTarget, iTEnd+szNew,pPatch,iPValue,iDepth+1);
-        if( rc ) return rc;
-        pTarget->delta += savedDelta;
-      }
-    }
-  }
-  if( pTarget->delta ) jsonAfterEditSizeAdjust(pTarget, iTarget);
-  return pTarget->oom ? JSON_MERGE_OOM : JSON_MERGE_OK;
-}
-
-
-/*
-** 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 *pTarget;    /* The TARGET */
-  JsonParse *pPatch;     /* The PATCH */
-  int rc;                /* Result code */
-
-  UNUSED_PARAMETER(argc);
-  assert( argc==2 );
-  pTarget = jsonParseFuncArg(ctx, argv[0], JSON_EDITABLE);
-  if( pTarget==0 ) return;
-  pPatch = jsonParseFuncArg(ctx, argv[1], 0);
-  if( pPatch ){
-    rc = jsonMergePatch(pTarget, 0, pPatch, 0, 0);
-    if( rc==JSON_MERGE_OK ){
-      jsonReturnParse(ctx, pTarget);
-    }else if( rc==JSON_MERGE_OOM ){
-      sqlite3_result_error_nomem(ctx);
-    }else if( rc==JSON_MERGE_TOODEEP ){
-      sqlite3_result_error(ctx, "JSON nested too deep", -1);
-    }else{
-      sqlite3_result_error(ctx, "malformed JSON", -1);
-    }
-    jsonParseFree(pPatch);
-  }
-  jsonParseFree(pTarget);
-}
-
-
-/*
-** 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;
-  }
-  jsonStringInit(&jx, ctx);
-  jsonAppendChar(&jx, '{');
-  for(i=0; i<argc; i+=2){
-    if( sqlite3_value_type(argv[i])!=SQLITE_TEXT ){
-      sqlite3_result_error(ctx, "json_object() labels must be TEXT", -1);
-      jsonStringReset(&jx);
-      return;
-    }
-    jsonAppendSeparator(&jx);
-    z = (const char*)sqlite3_value_text(argv[i]);
-    n = sqlite3_value_bytes(argv[i]);
-    jsonAppendString(&jx, z, n);
-    jsonAppendChar(&jx, ':');
-    jsonAppendSqlValue(&jx, argv[i+1]);
-  }
-  jsonAppendChar(&jx, '}');
-  jsonReturnString(&jx, 0, 0);
-  sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-}
-
-
-/*
-** json_remove(JSON, PATH, ...)
-**
-** Remove the named elements from JSON and return the result.  malformed
-** JSON or PATH arguments result in an error.
-*/
-static void jsonRemoveFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse *p;          /* The parse */
-  const char *zPath = 0; /* Path of element to be removed */
-  int i;                 /* Loop counter */
-  u32 rc;                /* Subroutine return code */
-
-  if( argc<1 ) return;
-  p = jsonParseFuncArg(ctx, argv[0], argc>1 ? JSON_EDITABLE : 0);
-  if( p==0 ) return;
-  for(i=1; i<argc; i++){
-    zPath = (const char*)sqlite3_value_text(argv[i]);
-    if( zPath==0 ){
-      goto json_remove_done;
-    }
-    if( zPath[0]!='$' ){
-      goto json_remove_patherror;
-    }
-    if( zPath[1]==0 ){
-      /* json_remove(j,'$') returns NULL */
-      goto json_remove_done;
-    }
-    p->eEdit = JEDIT_DEL;
-    p->delta = 0;
-    rc = jsonLookupStep(p, 0, zPath+1, 0);
-    if( JSON_LOOKUP_ISERROR(rc) ){
-      if( rc==JSON_LOOKUP_NOTFOUND ){
-        continue;  /* No-op */
-      }else{
-        jsonBadPathError(ctx, zPath, rc);
-      }
-      goto json_remove_done;
-    }
-  }
-  jsonReturnParse(ctx, p);
-  jsonParseFree(p);
-  return;
-
-json_remove_patherror:
-  jsonBadPathError(ctx, zPath, 0);
-
-json_remove_done:
-  jsonParseFree(p);
-  return;
-}
-
-/*
-** 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
-){
-  if( argc<1 ) return;
-  if( (argc&1)==0 ) {
-    jsonWrongNumArgs(ctx, "replace");
-    return;
-  }
-  jsonInsertIntoBlob(ctx, argc, argv, JEDIT_REPL);
-}
-
-
-/*
-** 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
-){
-  int flags = SQLITE_PTR_TO_INT(sqlite3_user_data(ctx));
-  int eInsType = JSON_INSERT_TYPE(flags);
-  static const char *azInsType[] = { "insert", "set", "array_insert" };
-  static const u8 aEditType[] = { JEDIT_INS, JEDIT_SET, JEDIT_AINS };
-
-  if( argc<1 ) return;
-  assert( eInsType>=0 && eInsType<=2 );
-  if( (argc&1)==0 ) {
-    jsonWrongNumArgs(ctx, azInsType[eInsType]);
-    return;
-  }
-  jsonInsertIntoBlob(ctx, argc, argv, aEditType[eInsType]);
-}
-
-/*
-** 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 = 0;
-  u32 i;
-
-  p = jsonParseFuncArg(ctx, argv[0], 0);
-  if( p==0 ) return;
-  if( argc==2 ){
-    zPath = (const char*)sqlite3_value_text(argv[1]);
-    if( zPath==0 ) goto json_type_done;
-    if( zPath[0]!='$' ){
-      jsonBadPathError(ctx, zPath, 0);
-      goto json_type_done;
-    }
-    i = jsonLookupStep(p, 0, zPath+1, 0);
-    if( JSON_LOOKUP_ISERROR(i) ){
-      if( i==JSON_LOOKUP_NOTFOUND ){
-        /* no-op */
-      }else{
-        jsonBadPathError(ctx, zPath, i);
-      }
-      goto json_type_done;
-    }
-  }else{
-    i = 0;
-  }
-  sqlite3_result_text(ctx, jsonbType[p->aBlob[i]&0x0f], -1, SQLITE_STATIC);
-json_type_done:
-  jsonParseFree(p);
-}
-
-/*
-** json_pretty(JSON)
-** json_pretty(JSON, INDENT)
-**
-** Return text that is a pretty-printed rendering of the input JSON.
-** If the argument is not valid JSON, return NULL.
-**
-** The INDENT argument is text that is used for indentation.  If omitted,
-** it defaults to four spaces (the same as PostgreSQL).
-*/
-static void jsonPrettyFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonString s;          /* The output string */
-  JsonPretty x;          /* Pretty printing context */
-
-  memset(&x, 0, sizeof(x));
-  x.pParse = jsonParseFuncArg(ctx, argv[0], 0);
-  if( x.pParse==0 ) return;
-  x.pOut = &s;
-  jsonStringInit(&s, ctx);
-  if( argc==1 || (x.zIndent = (const char*)sqlite3_value_text(argv[1]))==0 ){
-    x.zIndent = "    ";
-    x.szIndent = 4;
-  }else{
-    x.szIndent = (u32)strlen(x.zIndent);
-  }
-  jsonTranslateBlobToPrettyText(&x, 0);
-  jsonReturnString(&s, 0, 0);
-  jsonParseFree(x.pParse);
-}
-
-/*
-** json_valid(JSON)
-** json_valid(JSON, FLAGS)
-**
-** Check the JSON argument to see if it is well-formed.  The FLAGS argument
-** encodes the various constraints on what is meant by "well-formed":
-**
-**     0x01      Canonical RFC-8259 JSON text
-**     0x02      JSON text with optional JSON-5 extensions
-**     0x04      Superficially appears to be JSONB
-**     0x08      Strictly well-formed JSONB
-**
-** If the FLAGS argument is omitted, it defaults to 1.  Useful values for
-** FLAGS include:
-**
-**    1          Strict canonical JSON text
-**    2          JSON text perhaps with JSON-5 extensions
-**    4          Superficially appears to be JSONB
-**    5          Canonical JSON text or superficial JSONB
-**    6          JSON-5 text or superficial JSONB
-**    8          Strict JSONB
-**    9          Canonical JSON text or strict JSONB
-**    10         JSON-5 text or strict JSONB
-**
-** Other flag combinations are redundant.  For example, every canonical
-** JSON text is also well-formed JSON-5 text, so FLAG values 2 and 3
-** are the same.  Similarly, any input that passes a strict JSONB validation
-** will also pass the superficial validation so 12 through 15 are the same
-** as 8 through 11 respectively.
-**
-** This routine runs in linear time to validate text and when doing strict
-** JSONB validation.  Superficial JSONB validation is constant time,
-** assuming the BLOB is already in memory.  The performance advantage
-** of superficial JSONB validation is why that option is provided.
-** Application developers can choose to do fast superficial validation or
-** slower strict validation, according to their specific needs.
-**
-** Only the lower four bits of the FLAGS argument are currently used.
-** Higher bits are reserved for future expansion.   To facilitate
-** compatibility, the current implementation raises an error if any bit
-** in FLAGS is set other than the lower four bits.
-**
-** The original circa 2015 implementation of the JSON routines in
-** SQLite only supported canonical RFC-8259 JSON text and the json_valid()
-** function only accepted one argument.  That is why the default value
-** for the FLAGS argument is 1, since FLAGS=1 causes this routine to only
-** recognize canonical RFC-8259 JSON text as valid.  The extra FLAGS
-** argument was added when the JSON routines were extended to support
-** JSON5-like extensions and binary JSONB stored in BLOBs.
-**
-** Return Values:
-**
-**   *   Raise an error if FLAGS is outside the range of 1 to 15.
-**   *   Return NULL if the input is NULL
-**   *   Return 1 if the input is well-formed.
-**   *   Return 0 if the input is not well-formed.
-*/
-static void jsonValidFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse *p;          /* The parse */
-  u8 flags = 1;
-  u8 res = 0;
-  if( argc==2 ){
-    i64 f = sqlite3_value_int64(argv[1]);
-    if( f<1 || f>15 ){
-      sqlite3_result_error(ctx, "FLAGS parameter to json_valid() must be"
-                                " between 1 and 15", -1);
-      return;
-    }
-    flags = f & 0x0f;
-  }
-  switch( sqlite3_value_type(argv[0]) ){
-    case SQLITE_NULL: {
-#ifdef SQLITE_LEGACY_JSON_VALID
-      /* Incorrect legacy behavior was to return FALSE for a NULL input */
-      sqlite3_result_int(ctx, 0);
-#endif
-      return;
-    }
-    case SQLITE_BLOB: {
-      JsonParse py;
-      memset(&py, 0, sizeof(py));
-      if( jsonArgIsJsonb(argv[0], &py) ){
-        if( flags & 0x04 ){
-          /* Superficial checking only - accomplished by the
-          ** jsonArgIsJsonb() call above. */
-          res = 1;
-        }else if( flags & 0x08 ){
-          /* Strict checking.  Check by translating BLOB->TEXT->BLOB.  If
-          ** no errors occur, call that a "strict check". */
-          res = 0==jsonbValidityCheck(&py, 0, py.nBlob, 1);
-        }
-        break;
-      }
-      /* Fall through into interpreting the input as text.  See note
-      ** above at tag-20240123-a. */
-      /* no break */ deliberate_fall_through
-    }
-    default: {
-      JsonParse px;
-      if( (flags & 0x3)==0 ) break;
-      memset(&px, 0, sizeof(px));
-
-      p = jsonParseFuncArg(ctx, argv[0], JSON_KEEPERROR);
-      if( p ){
-        if( p->oom ){
-          sqlite3_result_error_nomem(ctx);
-        }else if( p->nErr ){
-          /* no-op */
-        }else if( (flags & 0x02)!=0 || p->hasNonstd==0 ){
-          res = 1;
-        }
-        jsonParseFree(p);
-      }else{
-        sqlite3_result_error_nomem(ctx);
-      }
-      break;
-    }
-  }
-  sqlite3_result_int(ctx, res);
-}
-
-/*
-** json_error_position(JSON)
-**
-** If the argument is NULL, return NULL
-**
-** If the argument is BLOB, do a full validity check and return non-zero
-** if the check fails.  The return value is the approximate 1-based offset
-** to the byte of the element that contains the first error.
-**
-** Otherwise interpret the argument is TEXT (even if it is numeric) and
-** return the 1-based character position for where the parser first recognized
-** that the input was not valid JSON, or return 0 if the input text looks
-** ok.  JSON-5 extensions are accepted.
-*/
-static void jsonErrorFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  i64 iErrPos = 0;       /* Error position to be returned */
-  JsonParse s;
-
-  assert( argc==1 );
-  UNUSED_PARAMETER(argc);
-  memset(&s, 0, sizeof(s));
-  s.db = sqlite3_context_db_handle(ctx);
-  if( jsonArgIsJsonb(argv[0], &s) ){
-    iErrPos = (i64)jsonbValidityCheck(&s, 0, s.nBlob, 1);
-  }else{
-    s.zJson = (char*)sqlite3_value_text(argv[0]);
-    if( s.zJson==0 ) return;  /* NULL input or OOM */
-    s.nJson = sqlite3_value_bytes(argv[0]);
-    if( jsonConvertTextToBlob(&s,0) ){
-      if( s.oom ){
-        iErrPos = -1;
-      }else{
-        /* Convert byte-offset s.iErr into a character offset */
-        u32 k;
-        assert( s.zJson!=0 );  /* Because s.oom is false */
-        for(k=0; k<s.iErr && ALWAYS(s.zJson[k]); k++){
-          if( (s.zJson[k] & 0xc0)!=0x80 ) iErrPos++;
-        }
-        iErrPos++;
-      }
-    }
-  }
-  jsonParseReset(&s);
-  if( iErrPos<0 ){
-    sqlite3_result_error_nomem(ctx);
-  }else{
-    sqlite3_result_int64(ctx, iErrPos);
-  }
-}
-
-/****************************************************************************
-** 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 ){
-      jsonStringInit(pStr, ctx);
-      jsonAppendChar(pStr, '[');
-    }else if( pStr->nUsed>1 ){
-      jsonAppendChar(pStr, ',');
-    }
-    pStr->pCtx = ctx;
-    jsonAppendSqlValue(pStr, argv[0]);
-  }
-}
-static void jsonArrayCompute(sqlite3_context *ctx, int isFinal){
-  JsonString *pStr;
-  int flags = SQLITE_PTR_TO_INT(sqlite3_user_data(ctx));
-  pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
-  if( pStr ){
-    pStr->pCtx = ctx;
-    jsonAppendRawNZ(pStr, "]", 2);
-    jsonStringTrimOneChar(pStr);
-    if( pStr->eErr ){
-      jsonReturnString(pStr, 0, 0);
-      return;
-    }else if( flags & JSON_BLOB ){
-      jsonReturnStringAsBlob(pStr);
-      if( isFinal ){
-        if( !pStr->bStatic ) sqlite3RCStrUnref(pStr->zBuf);
-      }else{
-        jsonStringTrimOneChar(pStr);
-      }
-      return;
-    }else if( isFinal ){
-      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed,
-                          pStr->bStatic ? SQLITE_TRANSIENT :
-                              sqlite3RCStrUnref);
-      pStr->bStatic = 1;
-    }else{
-      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT);
-      jsonStringTrimOneChar(pStr);
-    }
-  }else if( flags & JSON_BLOB ){
-    static const u8 emptyArray = 0x0b;
-    sqlite3_result_blob(ctx, &emptyArray, 1, SQLITE_STATIC);
-  }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 initialize it */
-  if( NEVER(!pStr) ) return;
-#endif
-  z = pStr->zBuf;
-  for(i=1; i<pStr->nUsed && ((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( i<pStr->nUsed ){
-    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 ){
-    z = (const char*)sqlite3_value_text(argv[0]);
-    n = sqlite3Strlen30(z);
-    if( pStr->zBuf==0 ){
-      jsonStringInit(pStr, ctx);
-      jsonAppendChar(pStr, '{');
-    }else if( pStr->nUsed>1 && z!=0 ){
-      jsonAppendChar(pStr, ',');
-    }
-    pStr->pCtx = ctx;
-    if( z!=0 ){
-      jsonAppendString(pStr, z, n);
-      jsonAppendChar(pStr, ':');
-      jsonAppendSqlValue(pStr, argv[1]);
-    }
-  }
-}
-static void jsonObjectCompute(sqlite3_context *ctx, int isFinal){
-  JsonString *pStr;
-  int flags = SQLITE_PTR_TO_INT(sqlite3_user_data(ctx));
-  pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
-  if( pStr ){
-    jsonAppendRawNZ(pStr, "}", 2);
-    jsonStringTrimOneChar(pStr);
-    pStr->pCtx = ctx;
-    if( pStr->eErr ){
-      jsonReturnString(pStr, 0, 0);
-      return;
-    }else if( flags & JSON_BLOB ){
-      jsonReturnStringAsBlob(pStr);
-      if( isFinal ){
-        if( !pStr->bStatic ) sqlite3RCStrUnref(pStr->zBuf);
-      }else{
-        jsonStringTrimOneChar(pStr);
-      }
-      return;
-    }else if( isFinal ){
-      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed,
-                          pStr->bStatic ? SQLITE_TRANSIENT :
-                          sqlite3RCStrUnref);
-      pStr->bStatic = 1;
-    }else{
-      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT);
-      jsonStringTrimOneChar(pStr);
-    }
-  }else if( flags & JSON_BLOB ){
-    static const unsigned char emptyObject = 0x0c;
-    sqlite3_result_blob(ctx, &emptyObject, 1, SQLITE_STATIC);
-  }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 JsonParent JsonParent;
-struct JsonParent {
-  u32 iHead;                 /* Start of object or array */
-  u32 iValue;                /* Start of the value */
-  u32 iEnd;                  /* First byte past the end */
-  u32 nPath;                 /* Length of path */
-  i64 iKey;                  /* Key for JSONB_ARRAY */
-};
-
-typedef struct JsonEachCursor JsonEachCursor;
-struct JsonEachCursor {
-  sqlite3_vtab_cursor base;  /* Base class - must be first */
-  u32 iRowid;                /* The rowid */
-  u32 i;                     /* Index in sParse.aBlob[] of current row */
-  u32 iEnd;                  /* EOF when i equals or exceeds this value */
-  u32 nRoot;                 /* Size of the root path in bytes */
-  u8 eType;                  /* Type of the container for element i */
-  u8 bRecursive;             /* True for json_tree().  False for json_each() */
-  u8 eMode;                  /* 1 for json_each().  2 for jsonb_each() */
-  u32 nParent;               /* Current nesting depth */
-  u32 nParentAlloc;          /* Space allocated for aParent[] */
-  JsonParent *aParent;       /* Parent elements of i */
-  sqlite3 *db;               /* Database connection */
-  JsonString path;           /* Current path */
-  JsonParse sParse;          /* Parse of the input JSON */
-};
-typedef struct JsonEachConnection JsonEachConnection;
-struct JsonEachConnection {
-  sqlite3_vtab base;         /* Base class - must be first */
-  sqlite3 *db;               /* Database connection */
-  u8 eMode;                  /* 1 for json_each().  2 for jsonb_each() */
-  u8 bRecursive;             /* True for json_tree().  False for json_each() */
-};
-
-
-/* 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
-){
-  JsonEachConnection *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 = (JsonEachConnection*)sqlite3DbMallocZero(db, sizeof(*pNew));
-    *ppVtab = (sqlite3_vtab*)pNew;
-    if( pNew==0 ) return SQLITE_NOMEM;
-    sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS);
-    pNew->db = db;
-    pNew->eMode = argv[0][4]=='b' ? 2 : 1;
-    pNew->bRecursive = argv[0][4+pNew->eMode]=='t';
-  }
-  return rc;
-}
-
-/* destructor for json_each virtual table */
-static int jsonEachDisconnect(sqlite3_vtab *pVtab){
-  JsonEachConnection *p = (JsonEachConnection*)pVtab;
-  sqlite3DbFree(p->db, pVtab);
-  return SQLITE_OK;
-}
-
-/* constructor for a JsonEachCursor object for json_each()/json_tree(). */
-static int jsonEachOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
-  JsonEachConnection *pVtab = (JsonEachConnection*)p;
-  JsonEachCursor *pCur;
-
-  UNUSED_PARAMETER(p);
-  pCur = sqlite3DbMallocZero(pVtab->db, sizeof(*pCur));
-  if( pCur==0 ) return SQLITE_NOMEM;
-  pCur->db = pVtab->db;
-  pCur->eMode = pVtab->eMode;
-  pCur->bRecursive = pVtab->bRecursive;
-  jsonStringZero(&pCur->path);
-  *ppCursor = &pCur->base;
-  return SQLITE_OK;
-}
-
-/* Reset a JsonEachCursor back to its original state.  Free any memory
-** held. */
-static void jsonEachCursorReset(JsonEachCursor *p){
-  jsonParseReset(&p->sParse);
-  jsonStringReset(&p->path);
-  sqlite3DbFree(p->db, p->aParent);
-  p->iRowid = 0;
-  p->i = 0;
-  p->aParent = 0;
-  p->nParent = 0;
-  p->nParentAlloc = 0;
-  p->iEnd = 0;
-  p->eType = 0;
-}
-
-/* Destructor for a jsonEachCursor object */
-static int jsonEachClose(sqlite3_vtab_cursor *cur){
-  JsonEachCursor *p = (JsonEachCursor*)cur;
-  jsonEachCursorReset(p);
-
-  sqlite3DbFree(p->db, 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;
-}
-
-/*
-** If the cursor is currently pointing at the label of a object entry,
-** then return the index of the value.  For all other cases, return the
-** current pointer position, which is the value.
-*/
-static int jsonSkipLabel(JsonEachCursor *p){
-  if( p->eType==JSONB_OBJECT ){
-    u32 sz = 0;
-    u32 n = jsonbPayloadSize(&p->sParse, p->i, &sz);
-    return p->i + n + sz;
-  }else{
-    return p->i;
-  }
-}
-
-/*
-** Append the path name for the current element.
-*/
-static void jsonAppendPathName(JsonEachCursor *p){
-  assert( p->nParent>0 );
-  assert( p->eType==JSONB_ARRAY || p->eType==JSONB_OBJECT );
-  if( p->eType==JSONB_ARRAY ){
-    jsonPrintf(30, &p->path, "[%lld]", p->aParent[p->nParent-1].iKey);
-  }else{
-    u32 n, sz = 0, k, i;
-    const char *z;
-    int needQuote = 0;
-    n = jsonbPayloadSize(&p->sParse, p->i, &sz);
-    k = p->i + n;
-    z = (const char*)&p->sParse.aBlob[k];
-    if( sz==0 || !sqlite3Isalpha(z[0]) ){
-      needQuote = 1;
-    }else{
-      for(i=0; i<sz; i++){
-        if( !sqlite3Isalnum(z[i]) ){
-          needQuote = 1;
-          break;
-        }
-      }
-    }
-    if( needQuote ){
-      jsonPrintf(sz+4,&p->path,".\"%.*s\"", sz, z);
-    }else{
-      jsonPrintf(sz+2,&p->path,".%.*s", sz, z);
-    }
-  }
-}
-
-/* Advance the cursor to the next element for json_tree() */
-static int jsonEachNext(sqlite3_vtab_cursor *cur){
-  JsonEachCursor *p = (JsonEachCursor*)cur;
-  int rc = SQLITE_OK;
-  if( p->bRecursive ){
-    u8 x;
-    u8 levelChange = 0;
-    u32 n, sz = 0;
-    u32 i = jsonSkipLabel(p);
-    x = p->sParse.aBlob[i] & 0x0f;
-    n = jsonbPayloadSize(&p->sParse, i, &sz);
-    if( x==JSONB_OBJECT || x==JSONB_ARRAY ){
-      JsonParent *pParent;
-      if( p->nParent>=p->nParentAlloc ){
-        JsonParent *pNew;
-        u64 nNew;
-        nNew = p->nParentAlloc*2 + 3;
-        pNew = sqlite3DbRealloc(p->db, p->aParent, sizeof(JsonParent)*nNew);
-        if( pNew==0 ) return SQLITE_NOMEM;
-        p->nParentAlloc = (u32)nNew;
-        p->aParent = pNew;
-      }
-      levelChange = 1;
-      pParent = &p->aParent[p->nParent];
-      pParent->iHead = p->i;
-      pParent->iValue = i;
-      pParent->iEnd = i + n + sz;
-      pParent->iKey = -1;
-      pParent->nPath = (u32)p->path.nUsed;
-      if( p->eType && p->nParent ){
-        jsonAppendPathName(p);
-        if( p->path.eErr ) rc = SQLITE_NOMEM;
-      }
-      p->nParent++;
-      p->i = i + n;
-    }else{
-      p->i = i + n + sz;
-    }
-    while( p->nParent>0 && p->i >= p->aParent[p->nParent-1].iEnd ){
-      p->nParent--;
-      p->path.nUsed = p->aParent[p->nParent].nPath;
-      levelChange = 1;
-    }
-    if( levelChange ){
-      if( p->nParent>0 ){
-        JsonParent *pParent = &p->aParent[p->nParent-1];
-        u32 iVal = pParent->iValue;
-        p->eType = p->sParse.aBlob[iVal] & 0x0f;
-      }else{
-        p->eType = 0;
-      }
-    }
-  }else{
-    u32 n, sz = 0;
-    u32 i = jsonSkipLabel(p);
-    n = jsonbPayloadSize(&p->sParse, i, &sz);
-    p->i = i + n + sz;
-  }
-  if( p->eType==JSONB_ARRAY && p->nParent ){
-    p->aParent[p->nParent-1].iKey++;
-  }
-  p->iRowid++;
-  return rc;
-}
-
-/* Length of the path for rowid==0 in bRecursive mode.
-*/
-static int jsonEachPathLength(JsonEachCursor *p){
-  u32 n = p->path.nUsed;
-  char *z = p->path.zBuf;
-  if( p->iRowid==0 && p->bRecursive && n>=2 ){
-    while( n>1 ){
-      n--;
-      if( z[n]=='[' || z[n]=='.' ){
-        u32 x, sz = 0;
-        char cSaved = z[n];
-        z[n] = 0;
-        assert( p->sParse.eEdit==0 );
-        x = jsonLookupStep(&p->sParse, 0, z+1, 0);
-        z[n] = cSaved;
-        if( JSON_LOOKUP_ISERROR(x) ) continue;
-        if( x + jsonbPayloadSize(&p->sParse, x, &sz) == p->i ) break;
-      }
-    }
-  }
-  return n;
-}
-
-/* Return the value of a column */
-static int jsonEachColumn(
-  sqlite3_vtab_cursor *cur,   /* The cursor */
-  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */
-  int iColumn                 /* Which column to return */
-){
-  JsonEachCursor *p = (JsonEachCursor*)cur;
-  switch( iColumn ){
-    case JEACH_KEY: {
-      if( p->nParent==0 ){
-        u32 n, j;
-        if( p->nRoot==1 ) break;
-        j = jsonEachPathLength(p);
-        n = p->nRoot - j;
-        if( n==0 ){
-          break;
-        }else if( p->path.zBuf[j]=='[' ){
-          i64 x;
-          sqlite3Atoi64(&p->path.zBuf[j+1], &x, n-1, SQLITE_UTF8);
-          sqlite3_result_int64(ctx, x);
-        }else if( p->path.zBuf[j+1]=='"' ){
-          sqlite3_result_text(ctx, &p->path.zBuf[j+2], n-3, SQLITE_TRANSIENT);
-        }else{
-          sqlite3_result_text(ctx, &p->path.zBuf[j+1], n-1, SQLITE_TRANSIENT);
-        }
-        break;
-      }
-      if( p->eType==JSONB_OBJECT ){
-        jsonReturnFromBlob(&p->sParse, p->i, ctx, 1);
-      }else{
-        assert( p->eType==JSONB_ARRAY );
-        sqlite3_result_int64(ctx, p->aParent[p->nParent-1].iKey);
-      }
-      break;
-    }
-    case JEACH_VALUE: {
-      u32 i = jsonSkipLabel(p);
-      jsonReturnFromBlob(&p->sParse, i, ctx, p->eMode);
-      if( (p->sParse.aBlob[i] & 0x0f)>=JSONB_ARRAY ){
-        sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-      }
-      break;
-    }
-    case JEACH_TYPE: {
-      u32 i = jsonSkipLabel(p);
-      u8 eType = p->sParse.aBlob[i] & 0x0f;
-      sqlite3_result_text(ctx, jsonbType[eType], -1, SQLITE_STATIC);
-      break;
-    }
-    case JEACH_ATOM: {
-      u32 i = jsonSkipLabel(p);
-      if( (p->sParse.aBlob[i] & 0x0f)<JSONB_ARRAY ){
-        jsonReturnFromBlob(&p->sParse, i, ctx, 1);
-      }
-      break;
-    }
-    case JEACH_ID: {
-      sqlite3_result_int64(ctx, (sqlite3_int64)p->i);
-      break;
-    }
-    case JEACH_PARENT: {
-      if( p->nParent>0 && p->bRecursive ){
-        sqlite3_result_int64(ctx, p->aParent[p->nParent-1].iHead);
-      }
-      break;
-    }
-    case JEACH_FULLKEY: {
-      u64 nBase = p->path.nUsed;
-      if( p->nParent ) jsonAppendPathName(p);
-      sqlite3_result_text64(ctx, p->path.zBuf, p->path.nUsed,
-                            SQLITE_TRANSIENT, SQLITE_UTF8);
-      p->path.nUsed = nBase;
-      break;
-    }
-    case JEACH_PATH: {
-      u32 n = jsonEachPathLength(p);
-      sqlite3_result_text64(ctx, p->path.zBuf, n,
-                            SQLITE_TRANSIENT, SQLITE_UTF8);
-      break;
-    }
-    default: {
-      sqlite3_result_text(ctx, p->path.zBuf, p->nRoot, SQLITE_STATIC);
-      break;
-    }
-    case JEACH_JSON: {
-      if( p->sParse.zJson==0 ){
-        sqlite3_result_blob(ctx, p->sParse.aBlob, p->sParse.nBlob,
-                            SQLITE_TRANSIENT);
-      }else{
-        sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_TRANSIENT);
-      }
-      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; i<pIdxInfo->nConstraint; 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 *zRoot = 0;
-  u32 i, n, sz;
-
-  UNUSED_PARAMETER(idxStr);
-  UNUSED_PARAMETER(argc);
-  jsonEachCursorReset(p);
-  if( idxNum==0 ) return SQLITE_OK;
-  memset(&p->sParse, 0, sizeof(p->sParse));
-  p->sParse.nJPRef = 1;
-  p->sParse.db = p->db;
-  if( jsonArgIsJsonb(argv[0], &p->sParse) ){
-    /* We have JSONB */
-  }else{
-    p->sParse.zJson = (char*)sqlite3_value_text(argv[0]);
-    p->sParse.nJson = sqlite3_value_bytes(argv[0]);
-    if( p->sParse.zJson==0 ){
-      p->i = p->iEnd = 0;
-      return SQLITE_OK;
-    }
-    if( jsonConvertTextToBlob(&p->sParse, 0) ){
-      if( p->sParse.oom ){
-        return SQLITE_NOMEM;
-      }
-      goto json_each_malformed_input;
-    }
-  }
-  if( idxNum==3 ){
-    zRoot = (const char*)sqlite3_value_text(argv[1]);
-    if( zRoot==0 ) return SQLITE_OK;
-    if( zRoot[0]!='$' ){
-      sqlite3_free(cur->pVtab->zErrMsg);
-      cur->pVtab->zErrMsg = jsonBadPathError(0, zRoot, 0);
-      jsonEachCursorReset(p);
-      return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM;
-    }
-    p->nRoot = sqlite3Strlen30(zRoot);
-    if( zRoot[1]==0 ){
-      i = p->i = 0;
-      p->eType = 0;
-    }else{
-      i = jsonLookupStep(&p->sParse, 0, zRoot+1, 0);
-      if( JSON_LOOKUP_ISERROR(i) ){
-        if( i==JSON_LOOKUP_NOTFOUND ){
-          p->i = 0;
-          p->eType = 0;
-          p->iEnd = 0;
-          return SQLITE_OK;
-        }
-        sqlite3_free(cur->pVtab->zErrMsg);
-        cur->pVtab->zErrMsg = jsonBadPathError(0, zRoot, 0);
-        jsonEachCursorReset(p);
-        return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM;
-      }
-      if( p->sParse.iLabel ){
-        p->i = p->sParse.iLabel;
-        p->eType = JSONB_OBJECT;
-      }else{
-        p->i = i;
-        p->eType = JSONB_ARRAY;
-      }
-    }
-    jsonAppendRaw(&p->path, zRoot, p->nRoot);
-  }else{
-    i = p->i = 0;
-    p->eType = 0;
-    p->nRoot = 1;
-    jsonAppendRaw(&p->path, "$", 1);
-  }
-  p->nParent = 0;
-  n = jsonbPayloadSize(&p->sParse, i, &sz);
-  p->iEnd = i+n+sz;
-  if( (p->sParse.aBlob[i] & 0x0f)>=JSONB_ARRAY && !p->bRecursive ){
-    p->i = i + n;
-    p->eType = p->sParse.aBlob[i] & 0x0f;
-    p->aParent = sqlite3DbMallocZero(p->db, sizeof(JsonParent));
-    if( p->aParent==0 ) return SQLITE_NOMEM;
-    p->nParent = 1;
-    p->nParentAlloc = 1;
-    p->aParent[0].iKey = 0;
-    p->aParent[0].iEnd = p->iEnd;
-    p->aParent[0].iHead = p->i;
-    p->aParent[0].iValue = i;
-  }
-  return SQLITE_OK;
-
-json_each_malformed_input:
-  sqlite3_free(cur->pVtab->zErrMsg);
-  cur->pVtab->zErrMsg = sqlite3_mprintf("malformed JSON");
-  jsonEachCursorReset(p);
-  return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM;
-}
-
-/* The methods of the json_each virtual table */
-static sqlite3_module jsonEachModule = {
-  0,                         /* iVersion */
-  0,                         /* xCreate */
-  jsonEachConnect,           /* xConnect */
-  jsonEachBestIndex,         /* xBestIndex */
-  jsonEachDisconnect,        /* xDisconnect */
-  0,                         /* xDestroy */
-  jsonEachOpen,              /* 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 */
-  0                          /* xIntegrity */
-};
-#endif /* SQLITE_OMIT_VIRTUALTABLE */
-#endif /* !defined(SQLITE_OMIT_JSON) */
-
-/*
-** Register JSON functions.
-*/
-SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void){
-#ifndef SQLITE_OMIT_JSON
-  static FuncDef aJsonFunc[] = {
-    /*   sqlite3_result_subtype() ----,  ,--- sqlite3_value_subtype()       */
-    /*                                |  |                                  */
-    /*             Uses cache ------, |  | ,---- Returns JSONB              */
-    /*                              | |  | |                                */
-    /*     Number of arguments ---, | |  | | ,--- Flags                     */
-    /*                            | | |  | | |                              */
-    JFUNCTION(json,               1,1,1, 0,0,0,          jsonRemoveFunc),
-    JFUNCTION(jsonb,              1,1,0, 0,1,0,          jsonRemoveFunc),
-    JFUNCTION(json_array,        -1,0,1, 1,0,0,          jsonArrayFunc),
-    JFUNCTION(jsonb_array,       -1,0,1, 1,1,0,          jsonArrayFunc),
-    JFUNCTION(json_array_insert, -1,1,1, 1,0,JSON_AINS,  jsonSetFunc),
-    JFUNCTION(jsonb_array_insert,-1,1,0, 1,1,JSON_AINS,  jsonSetFunc),
-    JFUNCTION(json_array_length,  1,1,0, 0,0,0,          jsonArrayLengthFunc),
-    JFUNCTION(json_array_length,  2,1,0, 0,0,0,          jsonArrayLengthFunc),
-    JFUNCTION(json_error_position,1,1,0, 0,0,0,          jsonErrorFunc),
-    JFUNCTION(json_extract,      -1,1,1, 0,0,0,          jsonExtractFunc),
-    JFUNCTION(jsonb_extract,     -1,1,0, 0,1,0,          jsonExtractFunc),
-    JFUNCTION(->,                 2,1,1, 0,0,JSON_JSON,  jsonExtractFunc),
-    JFUNCTION(->>,                2,1,0, 0,0,JSON_SQL,   jsonExtractFunc),
-    JFUNCTION(json_insert,       -1,1,1, 1,0,0,          jsonSetFunc),
-    JFUNCTION(jsonb_insert,      -1,1,0, 1,1,0,          jsonSetFunc),
-    JFUNCTION(json_object,       -1,0,1, 1,0,0,          jsonObjectFunc),
-    JFUNCTION(jsonb_object,      -1,0,1, 1,1,0,          jsonObjectFunc),
-    JFUNCTION(json_patch,         2,1,1, 0,0,0,          jsonPatchFunc),
-    JFUNCTION(jsonb_patch,        2,1,0, 0,1,0,          jsonPatchFunc),
-    JFUNCTION(json_pretty,        1,1,0, 0,0,0,          jsonPrettyFunc),
-    JFUNCTION(json_pretty,        2,1,0, 0,0,0,          jsonPrettyFunc),
-    JFUNCTION(json_quote,         1,0,1, 1,0,0,          jsonQuoteFunc),
-    JFUNCTION(json_remove,       -1,1,1, 0,0,0,          jsonRemoveFunc),
-    JFUNCTION(jsonb_remove,      -1,1,0, 0,1,0,          jsonRemoveFunc),
-    JFUNCTION(json_replace,      -1,1,1, 1,0,0,          jsonReplaceFunc),
-    JFUNCTION(jsonb_replace,     -1,1,0, 1,1,0,          jsonReplaceFunc),
-    JFUNCTION(json_set,          -1,1,1, 1,0,JSON_ISSET, jsonSetFunc),
-    JFUNCTION(jsonb_set,         -1,1,0, 1,1,JSON_ISSET, jsonSetFunc),
-    JFUNCTION(json_type,          1,1,0, 0,0,0,          jsonTypeFunc),
-    JFUNCTION(json_type,          2,1,0, 0,0,0,          jsonTypeFunc),
-    JFUNCTION(json_valid,         1,1,0, 0,0,0,          jsonValidFunc),
-    JFUNCTION(json_valid,         2,1,0, 0,0,0,          jsonValidFunc),
-#if SQLITE_DEBUG
-    JFUNCTION(json_parse,         1,1,0, 0,0,0,          jsonParseFunc),
-#endif
-    WAGGREGATE(json_group_array,  1, 0, 0,
-       jsonArrayStep, jsonArrayFinal, jsonArrayValue, jsonGroupInverse,
-       SQLITE_SUBTYPE|SQLITE_RESULT_SUBTYPE|SQLITE_UTF8|
-       SQLITE_DETERMINISTIC),
-    WAGGREGATE(jsonb_group_array, 1, JSON_BLOB, 0,
-       jsonArrayStep, jsonArrayFinal, jsonArrayValue, jsonGroupInverse,
-       SQLITE_SUBTYPE|SQLITE_RESULT_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC),
-    WAGGREGATE(json_group_object, 2, 0, 0,
-       jsonObjectStep, jsonObjectFinal, jsonObjectValue, jsonGroupInverse,
-       SQLITE_SUBTYPE|SQLITE_RESULT_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC),
-    WAGGREGATE(jsonb_group_object,2, JSON_BLOB, 0,
-       jsonObjectStep, jsonObjectFinal, jsonObjectValue, jsonGroupInverse,
-       SQLITE_SUBTYPE|SQLITE_RESULT_SUBTYPE|SQLITE_UTF8|
-       SQLITE_DETERMINISTIC)
-  };
-  sqlite3InsertBuiltinFuncs(aJsonFunc, ArraySize(aJsonFunc));
-#endif
-}
-
-#if  !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON)
-/*
-** Register the JSON table-valued function named zName and return a
-** pointer to its Module object.  Return NULL if something goes wrong.
-*/
-SQLITE_PRIVATE Module *sqlite3JsonVtabRegister(sqlite3 *db, const char *zName){
-  unsigned int i;
-  static const char *azModule[] = {
-    "json_each", "json_tree", "jsonb_each", "jsonb_tree"
-  };
-  assert( sqlite3HashFind(&db->aModule, zName)==0 );
-  for(i=0; i<sizeof(azModule)/sizeof(azModule[0]); i++){
-    if( sqlite3StrICmp(azModule[i],zName)==0 ){
-      return sqlite3VtabCreateModule(db, azModule[i], &jsonEachModule, 0, 0);
-    }
-  }
-  return 0;
-}
-#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) */
-
-/************** End of json.c ************************************************/
-/************** Begin file rtree.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 for implementations of the r-tree and r*-tree
-** algorithms packaged as an SQLite virtual table module.
-*/
-
-/*
-** Database Format of R-Tree Tables
-** --------------------------------
-**
-** The data structure for a single virtual r-tree table is stored in three
-** native SQLite tables declared as follows. In each case, the '%' character
-** in the table name is replaced with the user-supplied name of the r-tree
-** table.
-**
-**   CREATE TABLE %_node(nodeno INTEGER PRIMARY KEY, data BLOB)
-**   CREATE TABLE %_parent(nodeno INTEGER PRIMARY KEY, parentnode INTEGER)
-**   CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER, ...)
-**
-** The data for each node of the r-tree structure is stored in the %_node
-** table. For each node that is not the root node of the r-tree, there is
-** an entry in the %_parent table associating the node with its parent.
-** And for each row of data in the table, there is an entry in the %_rowid
-** table that maps from the entries rowid to the id of the node that it
-** is stored on.  If the r-tree contains auxiliary columns, those are stored
-** on the end of the %_rowid table.
-**
-** The root node of an r-tree always exists, even if the r-tree table is
-** empty. The nodeno of the root node is always 1. All other nodes in the
-** table must be the same size as the root node. The content of each node
-** is formatted as follows:
-**
-**   1. If the node is the root node (node 1), then the first 2 bytes
-**      of the node contain the tree depth as a big-endian integer.
-**      For non-root nodes, the first 2 bytes are left unused.
-**
-**   2. The next 2 bytes contain the number of entries currently
-**      stored in the node.
-**
-**   3. The remainder of the node contains the node entries. Each entry
-**      consists of a single 8-byte integer followed by an even number
-**      of 4-byte coordinates. For leaf nodes the integer is the rowid
-**      of a record. For internal nodes it is the node number of a
-**      child page.
-*/
-
-#if !defined(SQLITE_CORE) \
-  || (defined(SQLITE_ENABLE_RTREE) && !defined(SQLITE_OMIT_VIRTUALTABLE))
-
-#ifndef SQLITE_CORE
-/*   #include "sqlite3ext.h" */
-  SQLITE_EXTENSION_INIT1
-#else
-/*   #include "sqlite3.h" */
-#endif
-SQLITE_PRIVATE sqlite3_int64 sqlite3GetToken(const unsigned char*,int*); /* In SQLite core */
-
-/* #include <stddef.h> */
-
-/*
-** If building separately, we will need some setup that is normally
-** found in sqliteInt.h
-*/
-#if !defined(SQLITE_AMALGAMATION)
-#include "sqlite3rtree.h"
-typedef sqlite3_int64 i64;
-typedef sqlite3_uint64 u64;
-typedef unsigned char u8;
-typedef unsigned short u16;
-typedef unsigned int u32;
-#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
-# define NDEBUG 1
-#endif
-#if defined(NDEBUG) && defined(SQLITE_DEBUG)
-# undef NDEBUG
-#endif
-#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
-#ifndef offsetof
-# define offsetof(ST,M) ((size_t)((char*)&((ST*)0)->M - (char*)0))
-#endif
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
-# define FLEXARRAY
-#else
-# define FLEXARRAY 1
-#endif
-#endif /* !defined(SQLITE_AMALGAMATION) */
-
-/* Macro to check for 4-byte alignment.  Only used inside of assert() */
-#ifdef SQLITE_DEBUG
-# define FOUR_BYTE_ALIGNED(X)  ((((char*)(X) - (char*)0) & 3)==0)
-#endif
-
-/* #include <string.h> */
-/* #include <stdio.h> */
-/* #include <assert.h> */
-/* #include <stdlib.h> */
-
-/*  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 */
-  char *zNodeName;            /* Name of the %_node 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;
-
-  /* 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[FLEXARRAY]; /* Values for parameters to the SQL function */
-};
-
-/* Size of an RtreeMatchArg object with N parameters */
-#define SZ_RTREEMATCHARG(N)  \
-        (offsetof(RtreeMatchArg,aParam)+(N)*sizeof(RtreeDValue))
-
-#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 <intrin.h> */
-#      pragma intrinsic(_byteswap_ulong)
-#      pragma intrinsic(_byteswap_uint64)
-#    else
-/* #      include <cmnintrin.h> */
-#    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 /* Replicate changes at tag-20230904a */
-# if defined(__BYTE_ORDER__) && __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
-#   define SQLITE_BYTEORDER 4321
-# elif defined(__BYTE_ORDER__) && __BYTE_ORDER__==__ORDER_LITTLE_ENDIAN__
-#   define SQLITE_BYTEORDER 1234
-# elif defined(__BIG_ENDIAN__) && __BIG_ENDIAN__==1
-#   define SQLITE_BYTEORDER 4321
-# elif 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(__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( FOUR_BYTE_ALIGNED(p) );
-#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( FOUR_BYTE_ALIGNED(p) );
-  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){
-  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 && ALWAYS(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 ){
-    rc = sqlite3_blob_open(pRtree->db, pRtree->zDb, pRtree->zNodeName,
-                           "data", iNode, 0,
-                           &pRtree->pNodeBlob);
-  }
-  if( rc ){
-    *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{
-    nodeBlobReset(pRtree);
-    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; ii<pRtree->nDim2; 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( nCell<nMaxCell ){
-    nodeOverwriteCell(pRtree, pNode, pCell, nCell);
-    writeInt16(&pNode->zData[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( iCell<NCELL(pNode) );
-  return readInt64(&pNode->zData[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 */
-){
-  assert( iCell<NCELL(pNode) );
-  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( ii<pRtree->nDim2 );
-}
-
-
-/* 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);
-    if( pRtree->nNodeRef ){
-      int i;
-      assert( pRtree->bCorrupt );
-      for(i=0; i<HASHSIZE; i++){
-        while( pRtree->aHash[i] ){
-          RtreeNode *pNext = pRtree->aHash[i]->pNext;
-          sqlite3_free(pRtree->aHash[i]);
-          pRtree->aHash[i] = pNext;
-        }
-      }
-    }
-    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; i<pCsr->nConstraint; 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; ii<RTREE_CACHE_SZ; ii++) nodeRelease(pRtree, pCsr->aNode[ii]);
-  sqlite3_free(pCsr->aPoint);
-  pStmt = pCsr->pReadAux;
-  memset(pCsr, 0, sizeof(RtreeCursor));
-  pCsr->base.pVtab = (sqlite3_vtab*)pRtree;
-  pCsr->pReadAux = pStmt;
-
-  /* The following will only fail if the previous sqlite3_step() call failed,
-  ** in which case the error has already been caught. This statement never
-  ** encounters an error within an sqlite3_column_xxx() function, as it
-  ** calls sqlite3_column_value(), which does not use malloc(). So it is safe
-  ** to ignore the error code here.  */
-  sqlite3_reset(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--;
-  if( pRtree->nCursor==0 && pRtree->inWrTrans==0 ){
-    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 || *prScore<RTREE_ZERO ){
-      *prScore = pInfo->rScore;
-    }
-  }
-  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( FOUR_BYTE_ALIGNED(pCellData) );
-  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( FOUR_BYTE_ALIGNED(pCellData) );
-  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; ii<nCell; ii++){
-    if( nodeGetRowid(pRtree, pNode, ii)==iRowid ){
-      *piIndex = ii;
-      return SQLITE_OK;
-    }
-  }
-  RTREE_IS_CORRUPT(pRtree);
-  return SQLITE_CORRUPT_VTAB;
-}
-
-/*
-** Return the index of the cell containing a pointer to node pNode
-** in its parent. If pNode is the root node, return -1.
-*/
-static int nodeParentIndex(Rtree *pRtree, RtreeNode *pNode, int *piIndex){
-  RtreeNode *pParent = pNode->pParent;
-  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->rScore<pB->rScore ) return -1;
-  if( pA->rScore>pB->rScore ) return +1;
-  if( pA->iLevel<pB->iLevel ) 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( i<j );
-  p->aPoint[i] = p->aPoint[j];
-  p->aPoint[j] = t;
-  i++; j++;
-  if( i<RTREE_CACHE_SZ ){
-    if( j>=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(ii<RTREE_CACHE_SZ) ){
-        assert( pCur->aNode[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( idx<RTREE_CACHE_SZ ){
-    printf(" %p\n", pCur->aNode[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; ii<pCur->nPoint; 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( n<RTREE_CACHE_SZ-1 ){
-      p->aNode[1] = p->aNode[n+1];
-      p->aNode[n+1] = 0;
-    }
-    i = 0;
-    while( (j = i*2+1)<n ){
-      k = j+1;
-      if( k<n && rtreeSearchPointCompare(&p->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->iCell<nCell ){
-      sqlite3_rtree_dbl rScore = (sqlite3_rtree_dbl)-1;
-      eWithin = FULLY_WITHIN;
-      for(ii=0; ii<nConstraint; ii++){
-        RtreeConstraint *pConstraint = pCur->aConstraint + 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; ii<pCur->nPoint; 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( rScore<RTREE_ZERO ) rScore = RTREE_ZERO;
-      p = rtreeSearchPointNew(pCur, rScore, x.iLevel);
-      if( p==0 ) return SQLITE_NOMEM;
-      p->eWithin = (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) ){
-    if( p->iCell>=NCELL(pNode) ){
-      rc = SQLITE_ABORT;
-    }else{
-      *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( p->iCell>=NCELL(pNode) ) return SQLITE_ABORT;
-  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;
-}
-
-SQLITE_PRIVATE int sqlite3IntFloatCompare(i64,double);
-
-/*
-** 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
-         && 0==sqlite3IntFloatCompare(iRowid,sqlite3_value_double(argv[0])))
-    ){
-      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; ii<argc; ii++){
-          RtreeConstraint *p = &pCsr->aConstraint[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 ){
-            sqlite3_int64 iVal = sqlite3_value_int64(argv[ii]);
-#ifdef SQLITE_RTREE_INT_ONLY
-            p->u.rValue = iVal;
-#else
-            p->u.rValue = (double)iVal;
-            if( iVal>=((sqlite3_int64)1)<<48
-             || iVal<=-(((sqlite3_int64)1)<<48)
-            ){
-              if( p->op==RTREE_LT ) p->op = RTREE_LE;
-              if( p->op==RTREE_GT ) p->op = RTREE_GE;
-            }
-#endif
-          }else if( 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; ii<pIdxInfo->nConstraint; ii++){
-    if( pIdxInfo->aConstraint[ii].op==SQLITE_INDEX_CONSTRAINT_MATCH ){
-      bMatch = 1;
-    }
-  }
-
-  assert( pIdxInfo->idxStr==0 );
-  for(ii=0; ii<pIdxInfo->nConstraint && 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; jj<ii; jj++){
-        pIdxInfo->aConstraintUsage[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;
-      u8 doOmit = 1;
-      switch( p->op ){
-        case SQLITE_INDEX_CONSTRAINT_EQ:    op = RTREE_EQ;    doOmit = 0; break;
-        case SQLITE_INDEX_CONSTRAINT_GT:    op = RTREE_GT;    doOmit = 0; break;
-        case SQLITE_INDEX_CONSTRAINT_LE:    op = RTREE_LE;    break;
-        case SQLITE_INDEX_CONSTRAINT_LT:    op = RTREE_LT;    doOmit = 0; 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 = doOmit;
-      }
-    }
-  }
-
-  pIdxInfo->idxNum = 2;
-  pIdxInfo->needToFreeIdxStr = 1;
-  if( iIdx>0 ){
-    pIdxInfo->idxStr = sqlite3_malloc( iIdx+1 );
-    if( pIdxInfo->idxStr==0 ){
-      return SQLITE_NOMEM;
-    }
-    memcpy(pIdxInfo->idxStr, zIdxStr, iIdx+1);
-  }
-
-  nRow = pRtree->nRowEst >> (iIdx/2);
-  pIdxInfo->estimatedCost = (double)6.0 * (double)nRow;
-  pIdxInfo->estimatedRows = nRow;
-
-  return rc;
-}
-
-/*
-** Return the N-dimensional volume 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( ii<pRtree->nDim2 );
-  }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( ii<pRtree->nDim2 );
-  }
-}
-
-/*
-** 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;
-  if( pRtree->eCoordType==RTREE_COORD_INT32 ){
-    for(ii=0; ii<pRtree->nDim2; ii+=2){
-      RtreeCoord *a1 = &p1->aCoord[ii];
-      RtreeCoord *a2 = &p2->aCoord[ii];
-      if( a2[0].i<a1[0].i || a2[1].i>a1[1].i ) return 0;
-    }
-  }else{
-    for(ii=0; ii<pRtree->nDim2; ii+=2){
-      RtreeCoord *a1 = &p1->aCoord[ii];
-      RtreeCoord *a2 = &p2->aCoord[ii];
-      if( a2[0].f<a1[0].f || a2[1].f>a1[1].f ) return 0;
-    }
-  }
-  return 1;
-}
-
-static RtreeDValue cellOverlap(
-  Rtree *pRtree,
-  RtreeCell *p,
-  RtreeCell *aCell,
-  int nCell
-){
-  int ii;
-  RtreeDValue overlap = RTREE_ZERO;
-  for(ii=0; ii<nCell; ii++){
-    int jj;
-    RtreeDValue o = (RtreeDValue)1;
-    for(jj=0; jj<pRtree->nDim2; 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( x2<x1 ){
-        o = (RtreeDValue)0;
-        break;
-      }else{
-        o = o * (x2-x1);
-      }
-    }
-    overlap += o;
-  }
-  return overlap;
-}
-
-
-/*
-** This function implements the ChooseLeaf algorithm from Gutman[84].
-** ChooseSubTree in r*tree terminology.
-*/
-static int ChooseLeaf(
-  Rtree *pRtree,               /* Rtree table */
-  RtreeCell *pCell,            /* Cell to insert into rtree */
-  int iHeight,                 /* Height of sub-tree rooted at pCell */
-  RtreeNode **ppLeaf           /* OUT: Selected leaf page */
-){
-  int rc;
-  int ii;
-  RtreeNode *pNode = 0;
-  rc = nodeAcquire(pRtree, 1, 0, &pNode);
-
-  for(ii=0; rc==SQLITE_OK && ii<(pRtree->iDepth-iHeight); ii++){
-    int iCell;
-    sqlite3_int64 iBest = 0;
-    int bFound = 0;
-    RtreeDValue fMinGrowth = RTREE_ZERO;
-    RtreeDValue fMinArea = RTREE_ZERO;
-    int nCell = NCELL(pNode);
-    RtreeNode *pChild = 0;
-
-    /* First check to see if there is are any cells in pNode that completely
-    ** contains pCell.  If two or more cells in pNode completely contain pCell
-    ** then pick the smallest.
-    */
-    for(iCell=0; iCell<nCell; iCell++){
-      RtreeCell cell;
-      nodeGetCell(pRtree, pNode, iCell, &cell);
-      if( cellContains(pRtree, &cell, pCell) ){
-        RtreeDValue area = cellArea(pRtree, &cell);
-        if( bFound==0 || area<fMinArea ){
-          iBest = cell.iRowid;
-          fMinArea = area;
-          bFound = 1;
-        }
-      }
-    }
-    if( !bFound ){
-      /* No cells of pNode will completely contain pCell.  So pick the
-      ** cell of pNode that grows by the least amount when pCell is added.
-      ** Break ties by selecting the smaller cell.
-      */
-      for(iCell=0; iCell<nCell; iCell++){
-        RtreeCell cell;
-        RtreeDValue growth;
-        RtreeDValue area;
-        nodeGetCell(pRtree, pNode, iCell, &cell);
-        area = cellArea(pRtree, &cell);
-        cellUnion(pRtree, &cell, pCell);
-        growth = cellArea(pRtree, &cell)-area;
-        if( iCell==0
-         || growth<fMinGrowth
-         || (growth==fMinGrowth && area<fMinArea)
-        ){
-          fMinGrowth = growth;
-          fMinArea = area;
-          iBest = cell.iRowid;
-        }
-      }
-    }
-
-    rc = nodeAcquire(pRtree, iBest, pNode, &pChild);
-    nodeRelease(pRtree, pNode);
-    pNode = pChild;
-  }
-
-  *ppLeaf = pNode;
-  return rc;
-}
-
-/*
-** A cell with the same content as pCell has just been inserted into
-** the node pNode. This function updates the bounding box cells in
-** all ancestor elements.
-*/
-static int AdjustTree(
-  Rtree *pRtree,                    /* Rtree table */
-  RtreeNode *pNode,                 /* Adjust ancestry of this node. */
-  RtreeCell *pCell                  /* This cell was just inserted */
-){
-  RtreeNode *p = pNode;
-  int cnt = 0;
-  int rc;
-  while( p->pParent ){
-    RtreeNode *pParent = p->pParent;
-    RtreeCell cell;
-    int iCell;
-
-    cnt++;
-    if( 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 <rtree>_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 <rtree>_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, aCell 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 dimension iDim of the cells in aCell. The
-** minimum value of dimension iDim is considered first, the
-** maximum used to break ties.
-**
-** The aSpare array is used as temporary working space by the
-** sorting algorithm.
-*/
-static void SortByDimension(
-  Rtree *pRtree,
-  int *aIdx,
-  int nIdx,
-  int iDim,
-  RtreeCell *aCell,
-  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];
-
-    SortByDimension(pRtree, aLeft, nLeft, iDim, aCell, aSpare);
-    SortByDimension(pRtree, aRight, nRight, iDim, aCell, aSpare);
-
-    memcpy(aSpare, aLeft, sizeof(int)*nLeft);
-    aLeft = aSpare;
-    while( iLeft<nLeft || iRight<nRight ){
-      RtreeDValue xleft1 = DCOORD(aCell[aLeft[iLeft]].aCoord[iDim*2]);
-      RtreeDValue xleft2 = DCOORD(aCell[aLeft[iLeft]].aCoord[iDim*2+1]);
-      RtreeDValue xright1 = DCOORD(aCell[aRight[iRight]].aCoord[iDim*2]);
-      RtreeDValue xright2 = DCOORD(aCell[aRight[iRight]].aCoord[iDim*2+1]);
-      if( (iLeft!=nLeft) && ((iRight==nRight)
-       || (xleft1<xright1)
-       || (xleft1==xright1 && xleft2<xright2)
-      )){
-        aIdx[iLeft+iRight] = aLeft[iLeft];
-        iLeft++;
-      }else{
-        aIdx[iLeft+iRight] = aRight[iRight];
-        iRight++;
-      }
-    }
-
-#if 0
-    /* Check that the sort worked */
-    {
-      int jj;
-      for(jj=1; jj<nIdx; jj++){
-        RtreeDValue xleft1 = aCell[aIdx[jj-1]].aCoord[iDim*2];
-        RtreeDValue xleft2 = aCell[aIdx[jj-1]].aCoord[iDim*2+1];
-        RtreeDValue xright1 = aCell[aIdx[jj]].aCoord[iDim*2];
-        RtreeDValue xright2 = aCell[aIdx[jj]].aCoord[iDim*2+1];
-        assert( xleft1<=xright1 && (xleft1<xright1 || xleft2<=xright2) );
-      }
-    }
-#endif
-  }
-}
-
-/*
-** Implementation of the R*-tree variant of SplitNode from Beckman[1990].
-*/
-static int splitNodeStartree(
-  Rtree *pRtree,
-  RtreeCell *aCell,
-  int nCell,
-  RtreeNode *pLeft,
-  RtreeNode *pRight,
-  RtreeCell *pBboxLeft,
-  RtreeCell *pBboxRight
-){
-  int **aaSorted;
-  int *aSpare;
-  int ii;
-
-  int iBestDim = 0;
-  int iBestSplit = 0;
-  RtreeDValue fBestMargin = RTREE_ZERO;
-
-  sqlite3_int64 nByte = (pRtree->nDim+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; ii<pRtree->nDim; ii++){
-    int jj;
-    aaSorted[ii] = &((int *)&aaSorted[pRtree->nDim])[ii*nCell];
-    for(jj=0; jj<nCell; jj++){
-      aaSorted[ii][jj] = jj;
-    }
-    SortByDimension(pRtree, aaSorted[ii], nCell, ii, aCell, aSpare);
-  }
-
-  for(ii=0; ii<pRtree->nDim; 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( kk<nLeft ){
-          cellUnion(pRtree, &left, &aCell[aaSorted[ii][kk]]);
-        }else{
-          cellUnion(pRtree, &right, &aCell[aaSorted[ii][kk]]);
-        }
-      }
-      margin += cellMargin(pRtree, &left);
-      margin += cellMargin(pRtree, &right);
-      overlap = cellOverlap(pRtree, &left, &right, 1);
-      area = cellArea(pRtree, &left) + cellArea(pRtree, &right);
-      if( (nLeft==RTREE_MINCELLS(pRtree))
-       || (overlap<fBestOverlap)
-       || (overlap==fBestOverlap && area<fBestArea)
-      ){
-        iBestLeft = nLeft;
-        fBestOverlap = overlap;
-        fBestArea = area;
-      }
-    }
-
-    if( ii==0 || margin<fBestMargin ){
-      iBestDim = ii;
-      fBestMargin = margin;
-      iBestSplit = iBestLeft;
-    }
-  }
-
-  memcpy(pBboxLeft, &aCell[aaSorted[iBestDim][0]], sizeof(RtreeCell));
-  memcpy(pBboxRight, &aCell[aaSorted[iBestDim][iBestSplit]], sizeof(RtreeCell));
-  for(ii=0; ii<nCell; ii++){
-    RtreeNode *pTarget = (ii<iBestSplit)?pLeft:pRight;
-    RtreeCell *pBbox = (ii<iBestSplit)?pBboxLeft:pBboxRight;
-    RtreeCell *pCell = &aCell[aaSorted[iBestDim][ii]];
-    nodeInsertCell(pRtree, pTarget, pCell);
-    cellUnion(pRtree, pBbox, pCell);
-  }
-
-  sqlite3_free(aaSorted);
-  return SQLITE_OK;
-}
-
-
-static int updateMapping(
-  Rtree *pRtree,
-  i64 iRowid,
-  RtreeNode *pNode,
-  int iHeight
-){
-  int (*xSetMapping)(Rtree *, sqlite3_int64, sqlite3_int64);
-  xSetMapping = ((iHeight==0)?rowidWrite:parentWrite);
-  if( iHeight>0 ){
-    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; i<nCell; i++){
-    nodeGetCell(pRtree, pNode, i, &aCell[i]);
-  }
-  nodeZero(pRtree, pNode);
-  memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
-  nCell++;
-
-  if( pNode->iNode==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; i<NCELL(pRight); i++){
-    i64 iRowid = nodeGetRowid(pRtree, pRight, i);
-    rc = updateMapping(pRtree, iRowid, pRight, iHeight);
-    if( iRowid==pCell->iRowid ){
-      newCellIsRight = 1;
-    }
-    if( rc!=SQLITE_OK ){
-      goto splitnode_out;
-    }
-  }
-  if( pNode->iNode==1 ){
-    for(i=0; i<NCELL(pLeft); i++){
-      i64 iRowid = nodeGetRowid(pRtree, pLeft, i);
-      rc = updateMapping(pRtree, iRowid, pLeft, iHeight);
-      if( rc!=SQLITE_OK ){
-        goto splitnode_out;
-      }
-    }
-  }else if( newCellIsRight==0 ){
-    rc = updateMapping(pRtree, pCell->iRowid, pLeft, iHeight);
-  }
-
-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; ii<nCell; ii++){
-      RtreeCell cell;
-      nodeGetCell(pRtree, pNode, ii, &cell);
-      cellUnion(pRtree, &box, &cell);
-    }
-    box.iRowid = pNode->iNode;
-    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)<RTREE_MINCELLS(pRtree) ){
-      rc = removeNode(pRtree, pNode, iHeight);
-    }else{
-      rc = fixBoundingBox(pRtree, pNode);
-    }
-  }
-
-  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) ){
-    rc = SplitNode(pRtree, pNode, pCell, iHeight);
-  }else{
-    rc = AdjustTree(pRtree, pNode, pCell);
-    if( 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 && ii<nCell; ii++){
-    RtreeNode *pInsert;
-    RtreeCell cell;
-    nodeGetCell(pRtree, pNode, ii, &cell);
-
-    /* Find a node to store this cell in. pNode->iNode 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 <rtree>_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( f<d ){
-    f = (float)(d*(d<0 ? RNDTOWARDS : RNDAWAY));
-  }
-  return f;
-}
-#endif /* !defined(SQLITE_RTREE_INT_ONLY) */
-
-/*
-** A constraint has failed while inserting a row into an rtree table.
-** Assuming no OOM error occurs, this function sets the error message
-** (at pRtree->base.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; ii<nn; ii+=2){
-        cell.aCoord[ii].f = rtreeValueDown(aData[ii+3]);
-        cell.aCoord[ii+1].f = rtreeValueUp(aData[ii+4]);
-        if( cell.aCoord[ii].f>cell.aCoord[ii+1].f ){
-          rc = rtreeConstraintError(pRtree, ii+1);
-          goto constraint;
-        }
-      }
-    }else
-#endif
-    {
-      for(ii=0; ii<nn; ii+=2){
-        cell.aCoord[ii].i = sqlite3_value_int(aData[ii+3]);
-        cell.aCoord[ii+1].i = sqlite3_value_int(aData[ii+4]);
-        if( cell.aCoord[ii].i>cell.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;
-      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; jj<pRtree->nAux; 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 = 1;
-  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;
-}
-static int rtreeRollback(sqlite3_vtab *pVtab){
-  return rtreeEndTransaction(pVtab);
-}
-
-/*
-** 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 <tablename>;    -- 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; i<sizeof(azName)/sizeof(azName[0]); i++){
-    if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
-  }
-  return 0;
-}
-
-/* Forward declaration */
-static int rtreeIntegrity(sqlite3_vtab*, const char*, const char*, int, char**);
-
-static sqlite3_module rtreeModule = {
-  4,                          /* iVersion */
-  rtreeCreate,                /* xCreate - create a table */
-  rtreeConnect,               /* xConnect - connect to an existing table */
-  rtreeBestIndex,             /* xBestIndex - Determine search strategy */
-  rtreeDisconnect,            /* xDisconnect - Disconnect from a table */
-  rtreeDestroy,               /* xDestroy - Drop a table */
-  rtreeOpen,                  /* xOpen - open a cursor */
-  rtreeClose,                 /* xClose - close a cursor */
-  rtreeFilter,                /* xFilter - configure scan constraints */
-  rtreeNext,                  /* xNext - advance a cursor */
-  rtreeEof,                   /* xEof */
-  rtreeColumn,                /* xColumn - read data */
-  rtreeRowid,                 /* xRowid - read data */
-  rtreeUpdate,                /* xUpdate - write data */
-  rtreeBeginTransaction,      /* xBegin - begin transaction */
-  rtreeEndTransaction,        /* xSync - sync transaction */
-  rtreeEndTransaction,        /* xCommit - commit transaction */
-  rtreeRollback,              /* xRollback - rollback transaction */
-  0,                          /* xFindFunction - function overloading */
-  rtreeRename,                /* xRename - rename the table */
-  rtreeSavepoint,             /* xSavepoint */
-  0,                          /* xRelease */
-  0,                          /* xRollbackTo */
-  rtreeShadowName,            /* xShadowName */
-  rtreeIntegrity              /* xIntegrity */
-};
-
-static int rtreeSqlInit(
-  Rtree *pRtree,
-  sqlite3 *db,
-  const char *zDb,
-  const char *zPrefix,
-  int isCreate
-){
-  int rc = SQLITE_OK;
-
-  #define N_STATEMENT 8
-  static const char *azSql[N_STATEMENT] = {
-    /* Write the xxx_node table */
-    "INSERT OR REPLACE INTO '%q'.'%q_node' VALUES(?1, ?2)",
-    "DELETE FROM '%q'.'%q_node' WHERE nodeno = ?1",
-
-    /* Read and write the xxx_rowid table */
-    "SELECT nodeno FROM '%q'.'%q_rowid' WHERE rowid = ?1",
-    "INSERT OR REPLACE INTO '%q'.'%q_rowid' VALUES(?1, ?2)",
-    "DELETE FROM '%q'.'%q_rowid' WHERE rowid = ?1",
-
-    /* Read and write the xxx_parent table */
-    "SELECT parentnode FROM '%q'.'%q_parent' WHERE nodeno = ?1",
-    "INSERT OR REPLACE INTO '%q'.'%q_parent' VALUES(?1, ?2)",
-    "DELETE FROM '%q'.'%q_parent' WHERE nodeno = ?1"
-  };
-  sqlite3_stmt **appStmt[N_STATEMENT];
-  int i;
-  const int f = SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB;
-
-  pRtree->db = 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; ii<pRtree->nAux; 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; i<N_STATEMENT && rc==SQLITE_OK; i++){
-    char *zSql;
-    const char *zFormat;
-    if( i!=3 || pRtree->nAux==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 && rc!=SQLITE_NOMEM ){
-    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; ii<pRtree->nAux; ii++){
-        if( ii ) sqlite3_str_append(p, ",", 1);
-#ifdef SQLITE_ENABLE_GEOPOLY
-        if( ii<pRtree->nAuxNotNull ){
-          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)<pRtree->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);
-  sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS);
-
-
-  /* Allocate the sqlite3_vtab structure */
-  nDb = (int)strlen(argv[1]);
-  nName = (int)strlen(argv[2]);
-  pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName*2+8);
-  if( !pRtree ){
-    return SQLITE_NOMEM;
-  }
-  memset(pRtree, 0, sizeof(Rtree)+nDb+nName*2+8);
-  pRtree->nBusy = 1;
-  pRtree->base.pModule = &rtreeModule;
-  pRtree->zDb = (char *)&pRtree[1];
-  pRtree->zName = &pRtree->zDb[nDb+1];
-  pRtree->zNodeName = &pRtree->zName[nName+1];
-  pRtree->eCoordType = (u8)eCoordType;
-  memcpy(pRtree->zDb, argv[1], nDb);
-  memcpy(pRtree->zName, argv[2], nName);
-  memcpy(pRtree->zNodeName, argv[2], nName);
-  memcpy(&pRtree->zNodeName[nName], "_node", 6);
-
-
-  /* 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; ii<argc; ii++){
-    const char *zArg = argv[ii];
-    if( zArg[0]=='+' ){
-      pRtree->nAux++;
-      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( ii<argc ){
-    *pzErr = sqlite3_mprintf("%s", aErrMsg[4]);
-    rc = SQLITE_ERROR;
-  }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
-    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
-  }
-  sqlite3_free(zSql);
-  if( rc ) goto rtreeInit_fail;
-  pRtree->nDim = 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
-** <num-dimension>*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( nData<4+NCELL(&node)*tree.nBytesPerCell ) return;
-
-  pOut = sqlite3_str_new(0);
-  for(ii=0; ii<NCELL(&node); ii++){
-    RtreeCell cell;
-    int jj;
-
-    nodeGetCell(&tree, &node, ii, &cell);
-    if( ii>0 ) sqlite3_str_append(pOut, " ", 1);
-    sqlite3_str_appendf(pOut, "{%lld", cell.iRowid);
-    for(jj=0; jj<tree.nDim2; jj++){
-#ifndef SQLITE_RTREE_INT_ONLY
-      sqlite3_str_appendf(pOut, " %g", (double)cell.aCoord[jj].f);
-#else
-      sqlite3_str_appendf(pOut, " %d", cell.aCoord[jj].i);
-#endif
-    }
-    sqlite3_str_append(pOut, "}", 1);
-  }
-  errCode = sqlite3_str_errcode(pOut);
-  sqlite3_result_error_code(ctx, errCode);
-  sqlite3_result_text(ctx, sqlite3_str_finish(pOut), -1, sqlite3_free);
-}
-
-/* This routine implements an SQL function that returns the "depth" parameter
-** from the front of a blob that is an r-tree node.  For example:
-**
-**     SELECT rtreedepth(data) FROM rt_node WHERE nodeno=1;
-**
-** The depth value is 0 for all nodes other than the root node, and the root
-** node always has nodeno=1, so the example above is the primary use for this
-** routine.  This routine is intended for testing and analysis only.
-*/
-static void rtreedepth(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
-  UNUSED_PARAMETER(nArg);
-  if( sqlite3_value_type(apArg[0])!=SQLITE_BLOB
-   || sqlite3_value_bytes(apArg[0])<2
-
-  ){
-    sqlite3_result_error(ctx, "Invalid argument to rtreedepth()", -1);
-  }else{
-    u8 *zBlob = (u8 *)sqlite3_value_blob(apArg[0]);
-    if( zBlob ){
-      sqlite3_result_int(ctx, readInt16(zBlob));
-    }else{
-      sqlite3_result_error_nomem(ctx);
-    }
-  }
-}
-
-/*
-** Context object passed between the various routines that make up the
-** implementation of integrity-check function rtreecheck().
-*/
-typedef struct RtreeCheck RtreeCheck;
-struct RtreeCheck {
-  sqlite3 *db;                    /* Database handle */
-  const char *zDb;                /* Database containing rtree table */
-  const char *zTab;               /* Name of rtree table */
-  int bInt;                       /* True for rtree_i32 table */
-  int nDim;                       /* Number of dimensions for this rtree tbl */
-  sqlite3_stmt *pGetNode;         /* Statement used to retrieve nodes */
-  sqlite3_stmt *aCheckMapping[2]; /* Statements to query %_parent/%_rowid */
-  int nLeaf;                      /* Number of leaf cells in table */
-  int nNonLeaf;                   /* Number of non-leaf cells in table */
-  int rc;                         /* Return code */
-  char *zReport;                  /* Message to report */
-  int nErr;                       /* Number of lines in zReport */
-};
-
-#define RTREE_CHECK_MAX_ERROR 100
-
-/*
-** Reset SQL statement pStmt. If the sqlite3_reset() call returns an error,
-** and RtreeCheck.rc==SQLITE_OK, set RtreeCheck.rc to the error code.
-*/
-static void rtreeCheckReset(RtreeCheck *pCheck, sqlite3_stmt *pStmt){
-  int rc = sqlite3_reset(pStmt);
-  if( pCheck->rc==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 accumulated in pCheck.
-*/
-static void rtreeCheckAppendMsg(RtreeCheck *pCheck, const char *zFmt, ...){
-  va_list ap;
-  va_start(ap, zFmt);
-  if( pCheck->rc==SQLITE_OK && pCheck->nErr<RTREE_CHECK_MAX_ERROR ){
-    char *z = sqlite3_vmprintf(zFmt, ap);
-    if( z==0 ){
-      pCheck->rc = 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; i<pCheck->nDim; 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.i<p1.i : c1.f<p1.f)
-       || (pCheck->bInt ? 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; i<nCell; i++){
-          u8 *pCell = &aNode[4 + i*(8 + pCheck->nDim*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 nAux = 0;                   /* Number of extra columns. */
-
-  /* Initialize the context object */
-  memset(&check, 0, sizeof(check));
-  check.db = db;
-  check.zDb = zDb;
-  check.zTab = zTab;
-
-  /* Find the number of auxiliary columns */
-  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]);
-
-  *pzReport = check.zReport;
-  return check.rc;
-}
-
-/*
-** Implementation of the xIntegrity method for Rtree.
-*/
-static int rtreeIntegrity(
-  sqlite3_vtab *pVtab,   /* The virtual table to check */
-  const char *zSchema,   /* Schema in which the virtual table lives */
-  const char *zName,     /* Name of the virtual table */
-  int isQuick,           /* True for a quick_check */
-  char **pzErr           /* Write results here */
-){
-  Rtree *pRtree = (Rtree*)pVtab;
-  int rc;
-  assert( pzErr!=0 && *pzErr==0 );
-  UNUSED_PARAMETER(zSchema);
-  UNUSED_PARAMETER(zName);
-  UNUSED_PARAMETER(isQuick);
-  rc = rtreeCheckTable(pRtree->db, pRtree->zDb, pRtree->zName, pzErr);
-  if( rc==SQLITE_OK && *pzErr ){
-    *pzErr = sqlite3_mprintf("In RTree %s.%s:\n%z",
-                 pRtree->zDb, pRtree->zName, *pzErr);
-    if( (*pzErr)==0 ) rc = SQLITE_NOMEM;
-  }
-  return rc;
-}
-
-/*
-** Usage:
-**
-**   rtreecheck(<rtree-table>);
-**   rtreecheck(<database>, <rtree-table>);
-**
-** 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 <stdlib.h> */
-
-/* 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 <ctype.h>  /* 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);
-     *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; ii<nVertex; ii++){
-            geopolySwab32((unsigned char*)&GeoX(p,ii));
-            geopolySwab32((unsigned char*)&GeoY(p,ii));
-          }
-          p->hdr[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; i<p->nVertex; 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 <polyline>.
-** Additional arguments are added as attributes to the <polyline>.
-*/
-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, "<polyline points=");
-    for(i=0; i<p->nVertex; i++){
-      sqlite3_str_appendf(x, "%c%g,%g", cSep, GeoX(p,i), GeoY(p,i));
-      cSep = ' ';
-    }
-    sqlite3_str_appendf(x, " %g,%g'", GeoX(p,0), GeoY(p,0));
-    for(i=1; i<argc; i++){
-      const char *z = (const char*)sqlite3_value_text(argv[i]);
-      if( z && z[0] ){
-        sqlite3_str_appendf(x, " %s", z);
-      }
-    }
-    sqlite3_str_appendf(x, "></polyline>");
-    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; ii<p->nVertex; 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; ii<p->nVertex-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; ii<jj; ii++, jj--){
-        GeoCoord t = GeoX(p,ii);
-        GeoX(p,ii) = GeoX(p,jj);
-        GeoX(p,jj) = t;
-        t = GeoY(p,ii);
-        GeoY(p,ii) = GeoY(p,jj);
-        GeoY(p,jj) = t;
-      }
-    }
-    sqlite3_result_blob(context, p->hdr,
-       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; i<n; i++){
-    double rAngle = 2.0*GEOPOLY_PI*i/n;
-    GeoX(p,i) = x - r*geopolySine(rAngle-0.5*GEOPOLY_PI);
-    GeoY(p,i) = y + r*geopolySine(rAngle);
-  }
-  sqlite3_result_blob(context, p->hdr, 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; ii<p->nVertex; ii++){
-      double r = GeoX(p,ii);
-      if( r<mnX ) mnX = (float)r;
-      else if( r>mxX ) mxX = (float)r;
-      r = GeoY(p,ii);
-      if( r<mnY ) mnY = (float)r;
-      else if( r>mxY ) 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*)&ii;
-      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 segment
-**
-**    +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( x1<x2 ){
-    if( x0<=x1 || x0>x2 ) return 0;
-  }else if( x1>x2 ){
-    if( x0<=x2 || x0>x1 ) return 0;
-  }else{
-    /* Vertical line segment */
-    if( x0!=x1 ) return 0;
-    if( y0<y1 && y0<y2 ) return 0;
-    if( y0>y1 && y0>y2 ) return 0;
-    return 2;
-  }
-  y = y1 + (y2-y1)*(x0-x1)/(x2-x1);
-  if( y0==y ) return 2;
-  if( y0<y ) return 1;
-  return 0;
-}
-
-/*
-** SQL function:    geopoly_contains_point(P,X,Y)
-**
-** Return +2 if point X,Y is within polygon P.
-** Return +1 if point X,Y is on the polygon boundary.
-** Return 0 if point X,Y is outside the polygon
-*/
-static void geopolyContainsPointFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0);
-  double x0 = sqlite3_value_double(argv[1]);
-  double y0 = sqlite3_value_double(argv[2]);
-  int v = 0;
-  int cnt = 0;
-  int ii;
-  (void)argc;
-
-  if( p1==0 ) return;
-  for(ii=0; ii<p1->nVertex-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 algorithm. */
-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; i<nEvent; i++){
-    p = &aEvent[i];
-    p->pNext = 0;
-    for(j=0; j<mx && a[j]; j++){
-      p = geopolyEventMerge(a[j], p);
-      a[j] = 0;
-    }
-    a[j] = p;
-    if( j>=mx ) mx = j+1;
-  }
-  p = 0;
-  for(i=0; i<mx; i++){
-    p = geopolyEventMerge(a[i], p);
-  }
-  return p;
-}
-
-/*
-** Merge two lists of sorted segments by Y, and then by C.
-*/
-static GeoSegment *geopolySegmentMerge(GeoSegment *pLeft, GeoSegment *pRight){
-  GeoSegment head, *pLast;
-  head.pNext = 0;
-  pLast = &head;
-  while( pRight && pLeft ){
-    double r = pRight->y - 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 && a[i]; i++){
-      p = geopolySegmentMerge(a[i], p);
-      a[i] = 0;
-    }
-    a[i] = p;
-    if( i>=mx ) mx = i+1;
-  }
-  p = 0;
-  for(i=0; i<mx; i++){
-    p = geopolySegmentMerge(a[i], p);
-  }
-  return p;
-}
-
-/*
-** Determine the overlap between two polygons
-*/
-static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2){
-  sqlite3_int64 nVertex = p1->nVertex + 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);
-  sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS);
-
-  /* Allocate the sqlite3_vtab structure */
-  nDb = strlen(argv[1]);
-  nName = strlen(argv[2]);
-  pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName*2+8);
-  if( !pRtree ){
-    return SQLITE_NOMEM;
-  }
-  memset(pRtree, 0, sizeof(Rtree)+nDb+nName*2+8);
-  pRtree->nBusy = 1;
-  pRtree->base.pModule = &rtreeModule;
-  pRtree->zDb = (char *)&pRtree[1];
-  pRtree->zName = &pRtree->zDb[nDb+1];
-  pRtree->zNodeName = &pRtree->zName[nName+1];
-  pRtree->eCoordType = RTREE_COORD_REAL32;
-  pRtree->nDim = 2;
-  pRtree->nDim2 = 4;
-  memcpy(pRtree->zDb, argv[1], nDb);
-  memcpy(pRtree->zName, argv[2], nName);
-  memcpy(pRtree->zNodeName, argv[2], nName);
-  memcpy(&pRtree->zNodeName[nName], "_node", 6);
-
-
-  /* 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; ii<argc; ii++){
-    pRtree->nAux++;
-    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; ii<pIdxInfo->nConstraint; 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;
-      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; jj<nData-2; jj++){
-      nChange++;
-      sqlite3_bind_value(pUp, jj+2, aData[jj+2]);
-    }
-    if( nChange ){
-      sqlite3_step(pUp);
-      rc = sqlite3_reset(pUp);
-    }
-  }
-
-geopoly_update_end:
-  rtreeRelease(pRtree);
-  return rc;
-}
-
-/*
-** Report that geopoly_overlap() is an overloaded function suitable
-** for use in xBestIndex.
-*/
-static int geopolyFindFunction(
-  sqlite3_vtab *pVtab,
-  int nArg,
-  const char *zName,
-  void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
-  void **ppArg
-){
-  (void)pVtab;
-  (void)nArg;
-  if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){
-    *pxFunc = geopolyOverlapFunc;
-    *ppArg = 0;
-    return SQLITE_INDEX_CONSTRAINT_FUNCTION;
-  }
-  if( sqlite3_stricmp(zName, "geopoly_within")==0 ){
-    *pxFunc = geopolyWithinFunc;
-    *ppArg = 0;
-    return SQLITE_INDEX_CONSTRAINT_FUNCTION+1;
-  }
-  return 0;
-}
-
-
-static sqlite3_module geopolyModule = {
-  3,                          /* iVersion */
-  geopolyCreate,              /* xCreate - create a table */
-  geopolyConnect,             /* xConnect - connect to an existing table */
-  geopolyBestIndex,           /* xBestIndex - Determine search strategy */
-  rtreeDisconnect,            /* xDisconnect - Disconnect from a table */
-  rtreeDestroy,               /* xDestroy - Drop a table */
-  rtreeOpen,                  /* xOpen - open a cursor */
-  rtreeClose,                 /* xClose - close a cursor */
-  geopolyFilter,              /* xFilter - configure scan constraints */
-  rtreeNext,                  /* xNext - advance a cursor */
-  rtreeEof,                   /* xEof */
-  geopolyColumn,              /* xColumn - read data */
-  rtreeRowid,                 /* xRowid - read data */
-  geopolyUpdate,              /* xUpdate - write data */
-  rtreeBeginTransaction,      /* xBegin - begin transaction */
-  rtreeEndTransaction,        /* xSync - sync transaction */
-  rtreeEndTransaction,        /* xCommit - commit transaction */
-  rtreeEndTransaction,        /* xRollback - rollback transaction */
-  geopolyFindFunction,        /* xFindFunction - function overloading */
-  rtreeRename,                /* xRename - rename the table */
-  rtreeSavepoint,             /* xSavepoint */
-  0,                          /* xRelease */
-  0,                          /* xRollbackTo */
-  rtreeShadowName,            /* xShadowName */
-  rtreeIntegrity              /* xIntegrity */
-};
-
-static int sqlite3_geopoly_init(sqlite3 *db){
-  int rc = SQLITE_OK;
-  static const struct {
-    void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
-    signed char nArg;
-    unsigned char bPure;
-    const char *zName;
-  } aFunc[] = {
-     { geopolyAreaFunc,          1, 1,    "geopoly_area"             },
-     { geopolyBlobFunc,          1, 1,    "geopoly_blob"             },
-     { geopolyJsonFunc,          1, 1,    "geopoly_json"             },
-     { geopolySvgFunc,          -1, 1,    "geopoly_svg"              },
-     { geopolyWithinFunc,        2, 1,    "geopoly_within"           },
-     { geopolyContainsPointFunc, 3, 1,    "geopoly_contains_point"   },
-     { geopolyOverlapFunc,       2, 1,    "geopoly_overlap"          },
-     { geopolyDebugFunc,         1, 0,    "geopoly_debug"            },
-     { geopolyBBoxFunc,          1, 1,    "geopoly_bbox"             },
-     { geopolyXformFunc,         7, 1,    "geopoly_xform"            },
-     { geopolyRegularFunc,       4, 1,    "geopoly_regular"          },
-     { geopolyCcwFunc,           1, 1,    "geopoly_ccw"              },
-  };
-  static const struct {
-    void (*xStep)(sqlite3_context*,int,sqlite3_value**);
-    void (*xFinal)(sqlite3_context*);
-    const char *zName;
-  } aAgg[] = {
-     { geopolyBBoxStep, geopolyBBoxFinal, "geopoly_group_bbox"    },
-  };
-  unsigned int i;
-  for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){
-    int enc;
-    if( aFunc[i].bPure ){
-      enc = SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS;
-    }else{
-      enc = SQLITE_UTF8|SQLITE_DIRECTONLY;
-    }
-    rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
-                                 enc, 0,
-                                 aFunc[i].xFunc, 0, 0);
-  }
-  for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){
-    rc = sqlite3_create_function(db, aAgg[i].zName, 1,
-              SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS, 0,
-              0, aAgg[i].xStep, aAgg[i].xFinal);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_create_module_v2(db, "geopoly", &geopolyModule, 0, 0);
-  }
-  return rc;
-}
-
-/************** End of geopoly.c *********************************************/
-/************** Continuing where we left off in rtree.c **********************/
-#endif
-
-/*
-** Register the r-tree module with database handle db. This creates the
-** virtual table module "rtree" and the debugging/analysis scalar
-** function "rtreenode".
-*/
-SQLITE_PRIVATE int sqlite3RtreeInit(sqlite3 *db){
-  const int utf8 = SQLITE_UTF8;
-  int rc;
-
-  rc = sqlite3_create_function(db, "rtreenode", 2, utf8, 0, rtreenode, 0, 0);
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_create_function(db, "rtreedepth", 1, utf8, 0,rtreedepth, 0, 0);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_create_function(db, "rtreecheck", -1, utf8, 0,rtreecheck, 0,0);
-  }
-  if( rc==SQLITE_OK ){
-#ifdef SQLITE_RTREE_INT_ONLY
-    void *c = (void *)RTREE_COORD_INT32;
-#else
-    void *c = (void *)RTREE_COORD_REAL32;
-#endif
-    rc = sqlite3_create_module_v2(db, "rtree", &rtreeModule, c, 0);
-  }
-  if( rc==SQLITE_OK ){
-    void *c = (void *)RTREE_COORD_INT32;
-    rc = sqlite3_create_module_v2(db, "rtree_i32", &rtreeModule, c, 0);
-  }
-#ifdef SQLITE_ENABLE_GEOPOLY
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_geopoly_init(db);
-  }
-#endif
-
-  return rc;
-}
-
-/*
-** This routine deletes the RtreeGeomCallback object that was attached
-** one of the SQL functions create by sqlite3_rtree_geometry_callback()
-** or sqlite3_rtree_query_callback().  In other words, this routine is the
-** destructor for an RtreeGeomCallback objecct.  This routine is called when
-** the corresponding SQL function is deleted.
-*/
-static void rtreeFreeCallback(void *p){
-  RtreeGeomCallback *pInfo = (RtreeGeomCallback*)p;
-  if( pInfo->xDestructor ) 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; i<p->nParam; 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 = SZ_RTREEMATCHARG(nArg) + 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; i<nArg; i++){
-      pBlob->apSqlParam[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
-  );
-}
-
-#ifndef 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 <unicode/utypes.h>
-#include <unicode/uregex.h>
-#include <unicode/ustring.h>
-#include <unicode/ucol.h>
-
-/* #include <assert.h> */
-
-#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(<locale>, <collation-name>);
-**
-** Where <locale> is a string containing an ICU locale identifier (i.e.
-** "en_AU", "tr_TR" etc.) and <collation-name> 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 || nArg==3);
-  (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);
-  if(nArg==3){
-    const char *zOption = (const char*)sqlite3_value_text(apArg[2]);
-    static const struct {
-       const char *zName;
-       UColAttributeValue val;
-    } aStrength[] = {
-      {  "PRIMARY",      UCOL_PRIMARY           },
-      {  "SECONDARY",    UCOL_SECONDARY         },
-      {  "TERTIARY",     UCOL_TERTIARY          },
-      {  "DEFAULT",      UCOL_DEFAULT_STRENGTH  },
-      {  "QUARTERNARY",  UCOL_QUATERNARY        },
-      {  "IDENTICAL",    UCOL_IDENTICAL         },
-    };
-    unsigned int i;
-    for(i=0; i<sizeof(aStrength)/sizeof(aStrength[0]); i++){
-      if( sqlite3_stricmp(zOption,aStrength[i].zName)==0 ){
-        ucol_setStrength(pUCollator, aStrength[i].val);
-        break;
-      }
-    }
-    if( i>=sizeof(aStrength)/sizeof(aStrength[0]) ){
-      sqlite3_str *pStr = sqlite3_str_new(sqlite3_context_db_handle(p));
-      sqlite3_str_appendf(pStr,
-         "unknown collation strength \"%s\" - should be one of:",
-         zOption);
-      for(i=0; i<sizeof(aStrength)/sizeof(aStrength[0]); i++){
-         sqlite3_str_appendf(pStr, " %s", aStrength[i].zName);
-      }
-      sqlite3_result_error(p, sqlite3_str_value(pStr), -1);
-      sqlite3_free(sqlite3_str_finish(pStr));
-      return;
-    }
-  }
-  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},
-    {"icu_load_collation",3,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;
-}
-
-#ifndef 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 <assert.h> */
-/* #include <string.h> */
-/* #include "fts3_tokenizer.h" */
-
-#include <unicode/ubrk.h>
-/* #include <unicode/ucol.h> */
-/* #include <unicode/ustring.h> */
-#include <unicode/utf16.h>
-
-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( iInput<nInput ){
-      U8_NEXT(zInput, iInput, nInput, c);
-    }else{
-      c = 0;
-    }
-  }
-
-  pCsr->pIter = 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( iStart<iEnd ){
-      int iWhite = iStart;
-      U16_NEXT(pCsr->aChar, 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 "<database>-oal" instead of "<database>-wal".
-**     Because regular SQLite clients do not look for file named
-**     "<database>-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 "<database>-oal" file is moved to the equivalent "<database>-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 <assert.h> */
-/* #include <string.h> */
-/* #include <stdio.h> */
-
-/* #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 referred 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_<target name>" 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_<target> naming scheme.
-**
-** Instead of the plain data_<target> naming scheme, RBU database tables
-** may also be named data<integer>_<target>, where <integer> 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 <integer> 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 "<database>-vacuum", where <database>
-** 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 refer 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 application 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;
-typedef sqlite3_uint64 u64;
-#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;
-};
-
-#ifndef UNUSED_PARAMETER
-/*
-** 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)
-#endif
-
-/*
-** 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 */
-  sqlite3_int64 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 -= (int)(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( (u64)ofst+(u64)cnt > (u64)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 );
-  UNUSED_PARAMETER(argc);
-
-  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; i<pIter->nTblCol; 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;
-          pIter->zDataTbl = 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]_<name>
-**
-** where <name> is any sequence of 1 or more characters, <name> 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; i<sizeof(aStmt)/sizeof(aStmt[0]); i++){
-      rbuFinalize(p, aStmt[i]);
-    }
-  }
-}
-
-/*
-** This is a helper function for rbuObjIterCacheTableInfo(). It populates
-** the pIter->abIndexed[] 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 && i<nCol; i++){
-      const char *zName = (const char*)sqlite3_column_name(pStmt, i);
-      if( sqlite3_strnicmp("rbu_", zName, 4) ){
-        char *zCopy = rbuStrndup(zName, &p->rc);
-        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; i<pIter->nTblCol; 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; i<pIter->nTblCol; 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; i<pIter->nTblCol; 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( i<pIter->nTblCol );
-        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; iCol<pIter->nCol; 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 = <idxname>" 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( i<pIter->nTblCol );
-          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; i<pIter->nTblCol; 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; i<pIter->nTblCol; 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; i<pIter->nTblCol; 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; i<pIter->nTblCol; 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; i<nBind; i++){
-      zRet[i*2] = '?';
-      zRet[i*2+1] = (i+1==nBind) ? '\0' : ',';
-    }
-  }
-  return zRet;
-}
-
-/*
-** The iterator currently points to a table (not index) of type
-** RBU_PK_WITHOUT_ROWID. This function creates the PRIMARY KEY
-** declaration for the corresponding imposter table. For example,
-** if the iterator points to a table created as:
-**
-**   CREATE TABLE t1(a, b, c, PRIMARY KEY(b, a DESC)) WITHOUT ROWID
-**
-** this function returns:
-**
-**   PRIMARY KEY("b", "a" DESC)
-*/
-static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
-  char *z = 0;
-  assert( pIter->zIdx==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 = <pk-index> */
-
-    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 && iCol<pIter->nTblCol; 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 && i<nVal; i++){
-    rc = sqlite3_bind_value(p->objiter.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_realloc64(
-                pIter->aIdxCol, nIdxAlloc*sizeof(RbuSpan) + 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 = (int)(&zSql[i] - pIter->aIdxCol[iIdxCol].zSpan);
-              pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
-              i++;
-              break;
-            }
-          }else if( c==',' && nParen==1 ){
-            int nSpan = (int)(&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);
-  }
-#else
-  UNUSED_PARAMETER2(zBase,z);
-#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)(((u64)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<<WAL_LOCK_WRITE)|(1<<WAL_LOCK_CKPT)|(1<<WAL_LOCK_READ0);
-  u32 iFrame;
-
-  if( pRbu->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<iFrame ) pRbu->iMaxFrame = iFrame;
-  pRbu->aFrame[pRbu->nFrame].iWalFrame = iFrame;
-  pRbu->aFrame[pRbu->nFrame].iDbPage = 0;
-  pRbu->nFrame++;
-  return SQLITE_OK;
-}
-
-/*
-** Called when a page of data is written to offset iOff of the database
-** file while the rbu handle is in capture mode. Record the page number
-** of the page being written in the aFrame[] array.
-*/
-static int rbuCaptureDbWrite(sqlite3rbu *pRbu, i64 iOff){
-  pRbu->aFrame[pRbu->nFrame-1].iDbPage = (u32)(iOff / pRbu->pgsz) + 1;
-  return SQLITE_OK;
-}
-
-/*
-** This is called as part of an incremental checkpoint operation. Copy
-** a single frame of data from the wal file into the database file, as
-** indicated by the RbuFrame object.
-*/
-static void rbuCheckpointFrame(sqlite3rbu *p, RbuFrame *pFrame){
-  sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal;
-  sqlite3_file *pDb = p->pTargetFd->pReal;
-  i64 iOff;
-
-  assert( p->rc==SQLITE_OK );
-  iOff = (i64)(pFrame->iWalFrame-1) * (p->pgsz + 24) + 32 + 24;
-  p->rc = pWal->pMethods->xRead(pWal, p->aBuf, p->pgsz, iOff);
-  if( p->rc ) return;
-
-  iOff = (i64)(pFrame->iDbPage-1) * p->pgsz;
-  p->rc = pDb->pMethods->xWrite(pDb, p->aBuf, p->pgsz, iOff);
-}
-
-/*
-** This value is copied from the definition of ZIPVFS_CTRL_FILE_POINTER
-** in zipvfs.h.
-*/
-#define RBU_ZIPVFS_CTRL_FILE_POINTER 230439
-
-/*
-** Take an EXCLUSIVE lock on the database file. Return SQLITE_OK if
-** successful, or an SQLite error code otherwise.
-*/
-static int rbuLockDatabase(sqlite3 *db){
-  int rc = SQLITE_OK;
-  sqlite3_file *fd = 0;
-
-  sqlite3_file_control(db, "main", RBU_ZIPVFS_CTRL_FILE_POINTER, &fd);
-  if( fd ){
-    sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, &fd);
-    rc = fd->pMethods->xLock(fd, SQLITE_LOCK_SHARED);
-    if( rc==SQLITE_OK ){
-      rc = fd->pMethods->xUnlock(fd, SQLITE_LOCK_NONE);
-    }
-    sqlite3_file_control(db, "main", RBU_ZIPVFS_CTRL_FILE_POINTER, &fd);
-  }else{
-    sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, &fd);
-  }
-
-  if( rc==SQLITE_OK && fd->pMethods ){
-    rc = fd->pMethods->xLock(fd, SQLITE_LOCK_SHARED);
-    if( rc==SQLITE_OK ){
-      rc = fd->pMethods->xLock(fd, SQLITE_LOCK_EXCLUSIVE);
-    }
-  }
-  return rc;
-}
-
-/*
-** Return true if the database handle passed as the only argument
-** was opened with the rbu_exclusive_checkpoint=1 URI parameter
-** specified. Or false otherwise.
-*/
-static int rbuExclusiveCheckpoint(sqlite3 *db){
-  const char *zUri = sqlite3_db_filename(db, 0);
-  return sqlite3_uri_boolean(zUri, RBU_EXCLUSIVE_CHECKPOINT, 0);
-}
-
-#if defined(_WIN32_WCE)
-static LPWSTR rbuWinUtf8ToUnicode(const char *zFilename){
-  int nChar;
-  LPWSTR zWideFilename;
-
-  nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
-  if( nChar==0 ){
-    return 0;
-  }
-  zWideFilename = sqlite3_malloc64( nChar*sizeof(zWideFilename[0]) );
-  if( zWideFilename==0 ){
-    return 0;
-  }
-  memset(zWideFilename, 0, nChar*sizeof(zWideFilename[0]));
-  nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename,
-                                nChar);
-  if( nChar==0 ){
-    sqlite3_free(zWideFilename);
-    zWideFilename = 0;
-  }
-  return zWideFilename;
-}
-#endif
-
-/*
-** The RBU handle is currently in RBU_STAGE_OAL state, with a SHARED lock
-** on the database file. This proc moves the *-oal file to the *-wal path,
-** then reopens the database file (this time in vanilla, non-oal, WAL mode).
-** If an error occurs, leave an error code and error message in the rbu
-** handle.
-*/
-static void rbuMoveOalFile(sqlite3rbu *p){
-  const char *zBase = sqlite3_db_filename(p->dbMain, "main");
-  const char *zMove = zBase;
-  char *zOal;
-  char *zWal;
-
-  if( rbuIsVacuum(p) ){
-    zMove = sqlite3_db_filename(p->dbRbu, "main");
-  }
-  zOal = sqlite3_mprintf("%s-oal", zMove);
-  zWal = sqlite3_mprintf("%s-wal", zMove);
-
-  assert( p->eStage==RBU_STAGE_MOVE );
-  assert( p->rc==SQLITE_OK && p->zErrmsg==0 );
-  if( zWal==0 || zOal==0 ){
-    p->rc = SQLITE_NOMEM;
-  }else{
-    /* Move the *-oal file to *-wal. At this point connection p->db is
-    ** holding a SHARED lock on the target database file (because it is
-    ** in WAL mode). So no other connection may be writing the db.
-    **
-    ** In order to ensure that there are no database readers, an EXCLUSIVE
-    ** lock is obtained here before the *-oal is moved to *-wal.
-    */
-    sqlite3 *dbMain = 0;
-    rbuFileSuffix3(zBase, zWal);
-    rbuFileSuffix3(zBase, zOal);
-
-    /* Re-open the databases. */
-    rbuObjIterFinalize(&p->objiter);
-    sqlite3_close(p->dbRbu);
-    sqlite3_close(p->dbMain);
-    p->dbMain = 0;
-    p->dbRbu = 0;
-
-    dbMain = rbuOpenDbhandle(p, p->zTarget, 1);
-    if( dbMain ){
-      assert( p->rc==SQLITE_OK );
-      p->rc = rbuLockDatabase(dbMain);
-    }
-
-    if( p->rc==SQLITE_OK ){
-      p->rc = p->xRename(p->pRenameArg, zOal, zWal);
-    }
-
-    if( p->rc!=SQLITE_OK
-     || rbuIsVacuum(p)
-     || rbuExclusiveCheckpoint(dbMain)==0
-    ){
-      sqlite3_close(dbMain);
-      dbMain = 0;
-    }
-
-    if( p->rc==SQLITE_OK ){
-      rbuOpenDatabase(p, dbMain, 0);
-      rbuSetupCheckpoint(p, 0);
-    }
-  }
-
-  sqlite3_free(zWal);
-  sqlite3_free(zOal);
-}
-
-/*
-** The SELECT statement iterating through the keys for the current object
-** (p->objiter.pSelect) currently points to a valid row. This function
-** determines the type of operation requested by this row and returns
-** one of the following values to indicate the result:
-**
-**     * RBU_INSERT
-**     * RBU_DELETE
-**     * RBU_IDX_DELETE
-**     * RBU_UPDATE
-**
-** If RBU_UPDATE is returned, then output variable *pzMask is set to
-** point to the text value indicating the columns to update.
-**
-** If the rbu_control field contains an invalid value, an error code and
-** message are left in the RBU handle and zero returned.
-*/
-static int rbuStepType(sqlite3rbu *p, const char **pzMask){
-  int iCol = p->objiter.nCol;     /* Index of rbu_control column */
-  int res = 0;                    /* Return value */
-
-  switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
-    case SQLITE_INTEGER: {
-      int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
-      switch( iVal ){
-        case 0: res = RBU_INSERT;     break;
-        case 1: res = RBU_DELETE;     break;
-        case 2: res = RBU_REPLACE;    break;
-        case 3: res = RBU_IDX_DELETE; break;
-        case 4: res = RBU_IDX_INSERT; break;
-      }
-      break;
-    }
-
-    case SQLITE_TEXT: {
-      const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
-      if( z==0 ){
-        p->rc = SQLITE_NOMEM;
-      }else{
-        *pzMask = (const char*)z;
-      }
-      res = RBU_UPDATE;
-
-      break;
-    }
-
-    default:
-      break;
-  }
-
-  if( res==0 ){
-    rbuBadControlError(p);
-  }
-  return res;
-}
-
-#ifdef SQLITE_DEBUG
-/*
-** Assert that column iCol of statement pStmt is named zName.
-*/
-static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
-  const char *zCol = sqlite3_column_name(pStmt, iCol);
-  assert( 0==sqlite3_stricmp(zName, zCol) );
-}
-#else
-# define assertColumnName(x,y,z)
-#endif
-
-/*
-** Argument eType must be one of RBU_INSERT, RBU_DELETE, RBU_IDX_INSERT or
-** RBU_IDX_DELETE. This function performs the work of a single
-** sqlite3rbu_step() call for the type of operation specified by eType.
-*/
-static void rbuStepOneOp(sqlite3rbu *p, int eType){
-  RbuObjIter *pIter = &p->objiter;
-  sqlite3_value *pVal;
-  sqlite3_stmt *pWriter;
-  int i;
-
-  assert( p->rc==SQLITE_OK );
-  assert( eType!=RBU_DELETE || pIter->zIdx==0 );
-  assert( eType==RBU_DELETE || eType==RBU_IDX_DELETE
-       || eType==RBU_INSERT || eType==RBU_IDX_INSERT
-  );
-
-  /* If this is a delete, decrement nPhaseOneStep by nIndex. If the DELETE
-  ** statement below does actually delete a row, nPhaseOneStep will be
-  ** incremented by the same amount when SQL function rbu_tmp_insert()
-  ** is invoked by the trigger.  */
-  if( eType==RBU_DELETE ){
-    p->nPhaseOneStep -= p->objiter.nIndex;
-  }
-
-  if( eType==RBU_IDX_DELETE || eType==RBU_DELETE ){
-    pWriter = pIter->pDelete;
-  }else{
-    pWriter = pIter->pInsert;
-  }
-
-  for(i=0; i<pIter->nCol; i++){
-    /* If this is an INSERT into a table b-tree and the table has an
-    ** explicit INTEGER PRIMARY KEY, check that this is not an attempt
-    ** to write a NULL into the IPK column. That is not permitted.  */
-    if( eType==RBU_INSERT
-     && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i]
-     && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
-    ){
-      p->rc = SQLITE_MISMATCH;
-      p->zErrmsg = sqlite3_mprintf("datatype mismatch");
-      return;
-    }
-
-    if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
-      continue;
-    }
-
-    pVal = sqlite3_column_value(pIter->pSelect, i);
-    p->rc = sqlite3_bind_value(pWriter, i+1, pVal);
-    if( p->rc ) return;
-  }
-  if( pIter->zIdx==0 ){
-    if( pIter->eType==RBU_PK_VTAB
-     || pIter->eType==RBU_PK_NONE
-     || (pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p))
-    ){
-      /* For a virtual table, or a table with no primary key, the
-      ** SELECT statement is:
-      **
-      **   SELECT <cols>, rbu_control, rbu_rowid FROM ....
-      **
-      ** Hence column_value(pIter->nCol+1).
-      */
-      assertColumnName(pIter->pSelect, pIter->nCol+1,
-          rbuIsVacuum(p) ? "rowid" : "rbu_rowid"
-      );
-      pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
-      p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
-    }
-  }
-  if( p->rc==SQLITE_OK ){
-    sqlite3_step(pWriter);
-    p->rc = resetAndCollectError(pWriter, &p->zErrmsg);
-  }
-}
-
-/*
-** This function does the work for an sqlite3rbu_step() call.
-**
-** The object-iterator (p->objiter) currently points to a valid object,
-** and the input cursor (p->objiter.pSelect) currently points to a valid
-** input row. Perform whatever processing is required and return.
-**
-** If no  error occurs, SQLITE_OK is returned. Otherwise, an error code
-** and message is left in the RBU handle and a copy of the error code
-** returned.
-*/
-static int rbuStep(sqlite3rbu *p){
-  RbuObjIter *pIter = &p->objiter;
-  const char *zMask = 0;
-  int eType = rbuStepType(p, &zMask);
-
-  if( eType ){
-    assert( eType==RBU_INSERT     || eType==RBU_DELETE
-         || eType==RBU_REPLACE    || eType==RBU_IDX_DELETE
-         || eType==RBU_IDX_INSERT || eType==RBU_UPDATE
-    );
-    assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
-
-    if( pIter->zIdx==0 && (eType==RBU_IDX_DELETE || eType==RBU_IDX_INSERT) ){
-      rbuBadControlError(p);
-    }
-    else if( eType==RBU_REPLACE ){
-      if( pIter->zIdx==0 ){
-        p->nPhaseOneStep += p->objiter.nIndex;
-        rbuStepOneOp(p, RBU_DELETE);
-      }
-      if( p->rc==SQLITE_OK ) rbuStepOneOp(p, RBU_INSERT);
-    }
-    else if( eType!=RBU_UPDATE ){
-      rbuStepOneOp(p, eType);
-    }
-    else{
-      sqlite3_value *pVal;
-      sqlite3_stmt *pUpdate = 0;
-      assert( eType==RBU_UPDATE );
-      p->nPhaseOneStep -= p->objiter.nIndex;
-      rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
-      if( pUpdate ){
-        int i;
-        for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
-          char c = zMask[pIter->aiSrcOrder[i]];
-          pVal = sqlite3_column_value(pIter->pSelect, i);
-          if( pIter->abTblPk[i] || c!='.' ){
-            p->rc = sqlite3_bind_value(pUpdate, i+1, pVal);
-          }
-        }
-        if( p->rc==SQLITE_OK
-         && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
-        ){
-          /* Bind the rbu_rowid value to column _rowid_ */
-          assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
-          pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
-          p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
-        }
-        if( p->rc==SQLITE_OK ){
-          sqlite3_step(pUpdate);
-          p->rc = resetAndCollectError(pUpdate, &p->zErrmsg);
-        }
-      }
-    }
-  }
-  return p->rc;
-}
-
-/*
-** Increment the schema cookie of the main database opened by p->dbMain.
-**
-** Or, if this is an RBU vacuum, set the schema cookie of the main db
-** opened by p->dbMain to one more than the schema cookie of the main
-** db opened by p->dbRbu.
-*/
-static void rbuIncrSchemaCookie(sqlite3rbu *p){
-  if( p->rc==SQLITE_OK ){
-    sqlite3 *dbread = (rbuIsVacuum(p) ? p->dbRbu : p->dbMain);
-    int iCookie = 1000000;
-    sqlite3_stmt *pStmt;
-
-    p->rc = prepareAndCollectError(dbread, &pStmt, &p->zErrmsg,
-        "PRAGMA schema_version"
-    );
-    if( p->rc==SQLITE_OK ){
-      /* Coverage: it may be that this sqlite3_step() cannot fail. There
-      ** is already a transaction open, so the prepared statement cannot
-      ** throw an SQLITE_SCHEMA exception. The only database page the
-      ** statement reads is page 1, which is guaranteed to be in the cache.
-      ** And no memory allocations are required.  */
-      if( SQLITE_ROW==sqlite3_step(pStmt) ){
-        iCookie = sqlite3_column_int(pStmt, 0);
-      }
-      rbuFinalize(p, pStmt);
-    }
-    if( p->rc==SQLITE_OK ){
-      rbuMPrintfExec(p, p->dbMain, "PRAGMA schema_version = %d", iCookie+1);
-    }
-  }
-}
-
-/*
-** Update the contents of the rbu_state table within the rbu database. The
-** value stored in the RBU_STATE_STAGE column is eStage. All other values
-** are determined by inspecting the rbu handle passed as the first argument.
-*/
-static void rbuSaveState(sqlite3rbu *p, int eStage){
-  if( p->rc==SQLITE_OK || p->rc==SQLITE_DONE ){
-    sqlite3_stmt *pInsert = 0;
-    rbu_file *pFd = (rbuIsVacuum(p) ? p->pRbuFd : p->pTargetFd);
-    int rc;
-
-    assert( p->zErrmsg==0 );
-    rc = prepareFreeAndCollectError(p->dbRbu, &pInsert, &p->zErrmsg,
-        sqlite3_mprintf(
-          "INSERT OR REPLACE INTO %s.rbu_state(k, v) VALUES "
-          "(%d, %d), "
-          "(%d, %Q), "
-          "(%d, %Q), "
-          "(%d, %d), "
-          "(%d, %lld), "
-          "(%d, %lld), "
-          "(%d, %lld), "
-          "(%d, %lld), "
-          "(%d, %lld), "
-          "(%d, %Q)  ",
-          p->zStateDb,
-          RBU_STATE_STAGE, eStage,
-          RBU_STATE_TBL, p->objiter.zTbl,
-          RBU_STATE_IDX, p->objiter.zIdx,
-          RBU_STATE_ROW, p->nStep,
-          RBU_STATE_PROGRESS, p->nProgress,
-          RBU_STATE_CKPT, p->iWalCksum,
-          RBU_STATE_COOKIE, (i64)pFd->iCookie,
-          RBU_STATE_OALSZ, p->iOalSz,
-          RBU_STATE_PHASEONESTEP, p->nPhaseOneStep,
-          RBU_STATE_DATATBL, p->objiter.zDataTbl
-      )
-    );
-    assert( pInsert==0 || rc==SQLITE_OK );
-
-    if( rc==SQLITE_OK ){
-      sqlite3_step(pInsert);
-      rc = sqlite3_finalize(pInsert);
-    }
-    if( rc!=SQLITE_OK ) p->rc = rc;
-  }
-}
-
-
-/*
-** The second argument passed to this function is the name of a PRAGMA
-** setting - "page_size", "auto_vacuum", "user_version" or "application_id".
-** This function executes the following on sqlite3rbu.dbRbu:
-**
-**   "PRAGMA main.$zPragma"
-**
-** where $zPragma is the string passed as the second argument, then
-** on sqlite3rbu.dbMain:
-**
-**   "PRAGMA main.$zPragma = $val"
-**
-** where $val is the value returned by the first PRAGMA invocation.
-**
-** In short, it copies the value  of the specified PRAGMA setting from
-** dbRbu to dbMain.
-*/
-static void rbuCopyPragma(sqlite3rbu *p, const char *zPragma){
-  if( p->rc==SQLITE_OK ){
-    sqlite3_stmt *pPragma = 0;
-    p->rc = prepareFreeAndCollectError(p->dbRbu, &pPragma, &p->zErrmsg,
-        sqlite3_mprintf("PRAGMA main.%s", zPragma)
-    );
-    if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPragma) ){
-      p->rc = rbuMPrintfExec(p, p->dbMain, "PRAGMA main.%s = %d",
-          zPragma, sqlite3_column_int(pPragma, 0)
-      );
-    }
-    rbuFinalize(p, pPragma);
-  }
-}
-
-/*
-** The RBU handle passed as the only argument has just been opened and
-** the state database is empty. If this RBU handle was opened for an
-** RBU vacuum operation, create the schema in the target db.
-*/
-static void rbuCreateTargetSchema(sqlite3rbu *p){
-  sqlite3_stmt *pSql = 0;
-  sqlite3_stmt *pInsert = 0;
-
-  assert( rbuIsVacuum(p) );
-  p->rc = sqlite3_exec(p->dbMain, "PRAGMA writable_schema=1", 0,0, &p->zErrmsg);
-  if( p->rc==SQLITE_OK ){
-    p->rc = prepareAndCollectError(p->dbRbu, &pSql, &p->zErrmsg,
-      "SELECT sql FROM sqlite_schema WHERE sql!='' AND rootpage!=0"
-      " AND name!='sqlite_sequence' "
-      " ORDER BY type DESC"
-    );
-  }
-
-  while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
-    const char *zSql = (const char*)sqlite3_column_text(pSql, 0);
-    p->rc = sqlite3_exec(p->dbMain, zSql, 0, 0, &p->zErrmsg);
-  }
-  rbuFinalize(p, pSql);
-  if( p->rc!=SQLITE_OK ) return;
-
-  if( p->rc==SQLITE_OK ){
-    p->rc = prepareAndCollectError(p->dbRbu, &pSql, &p->zErrmsg,
-        "SELECT * FROM sqlite_schema WHERE rootpage=0 OR rootpage IS NULL"
-    );
-  }
-
-  if( p->rc==SQLITE_OK ){
-    p->rc = prepareAndCollectError(p->dbMain, &pInsert, &p->zErrmsg,
-        "INSERT INTO sqlite_schema VALUES(?,?,?,?,?)"
-    );
-  }
-
-  while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
-    int i;
-    for(i=0; i<5; i++){
-      sqlite3_bind_value(pInsert, i+1, sqlite3_column_value(pSql, i));
-    }
-    sqlite3_step(pInsert);
-    p->rc = sqlite3_reset(pInsert);
-  }
-  if( p->rc==SQLITE_OK ){
-    p->rc = sqlite3_exec(p->dbMain, "PRAGMA writable_schema=0",0,0,&p->zErrmsg);
-  }
-
-  rbuFinalize(p, pSql);
-  rbuFinalize(p, pInsert);
-}
-
-/*
-** Step the RBU object.
-*/
-SQLITE_API int sqlite3rbu_step(sqlite3rbu *p){
-  if( p ){
-    switch( p->eStage ){
-      case RBU_STAGE_OAL: {
-        RbuObjIter *pIter = &p->objiter;
-
-        /* If this is an RBU vacuum operation and the state table was empty
-        ** when this handle was opened, create the target database schema. */
-        if( rbuIsVacuum(p) && p->nProgress==0 && p->rc==SQLITE_OK ){
-          rbuCreateTargetSchema(p);
-          rbuCopyPragma(p, "user_version");
-          rbuCopyPragma(p, "application_id");
-        }
-
-        while( p->rc==SQLITE_OK && pIter->zTbl ){
-
-          if( pIter->bCleanup ){
-            /* Clean up the rbu_tmp_xxx table for the previous table. It
-            ** cannot be dropped as there are currently active SQL statements.
-            ** But the contents can be deleted.  */
-            if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
-              rbuMPrintfExec(p, p->dbRbu,
-                  "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zDataTbl
-              );
-            }
-          }else{
-            rbuObjIterPrepareAll(p, pIter, 0);
-
-            /* Advance to the next row to process. */
-            if( p->rc==SQLITE_OK ){
-              int rc = sqlite3_step(pIter->pSelect);
-              if( rc==SQLITE_ROW ){
-                p->nProgress++;
-                p->nStep++;
-                return rbuStep(p);
-              }
-              p->rc = sqlite3_reset(pIter->pSelect);
-              p->nStep = 0;
-            }
-          }
-
-          rbuObjIterNext(p, pIter);
-        }
-
-        if( p->rc==SQLITE_OK ){
-          assert( pIter->zTbl==0 );
-          rbuSaveState(p, RBU_STAGE_MOVE);
-          rbuIncrSchemaCookie(p);
-          if( p->rc==SQLITE_OK ){
-            p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
-          }
-          if( p->rc==SQLITE_OK ){
-            p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
-          }
-          p->eStage = RBU_STAGE_MOVE;
-        }
-        break;
-      }
-
-      case RBU_STAGE_MOVE: {
-        if( p->rc==SQLITE_OK ){
-          rbuMoveOalFile(p);
-          p->nProgress++;
-        }
-        break;
-      }
-
-      case RBU_STAGE_CKPT: {
-        if( p->rc==SQLITE_OK ){
-          if( p->nStep>=p->nFrame ){
-            sqlite3_file *pDb = p->pTargetFd->pReal;
-
-            /* Sync the db file */
-            p->rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
-
-            /* Update nBackfill */
-            if( p->rc==SQLITE_OK ){
-              void volatile *ptr;
-              p->rc = pDb->pMethods->xShmMap(pDb, 0, 32*1024, 0, &ptr);
-              if( p->rc==SQLITE_OK ){
-                ((u32 volatile*)ptr)[24] = p->iMaxFrame;
-              }
-            }
-
-            if( p->rc==SQLITE_OK ){
-              p->eStage = RBU_STAGE_DONE;
-              p->rc = SQLITE_DONE;
-            }
-          }else{
-            /* At one point the following block copied a single frame from the
-            ** wal file to the database file. So that one call to sqlite3rbu_step()
-            ** checkpointed a single frame.
-            **
-            ** However, if the sector-size is larger than the page-size, and the
-            ** application calls sqlite3rbu_savestate() or close() immediately
-            ** after this step, then rbu_step() again, then a power failure occurs,
-            ** then the database page written here may be damaged. Work around
-            ** this by checkpointing frames until the next page in the aFrame[]
-            ** lies on a different disk sector to the current one. */
-            u32 iSector;
-            do{
-              RbuFrame *pFrame = &p->aFrame[p->nStep];
-              iSector = (pFrame->iDbPage-1) / p->nPagePerSector;
-              rbuCheckpointFrame(p, pFrame);
-              p->nStep++;
-            }while( p->nStep<p->nFrame
-                 && iSector==((p->aFrame[p->nStep].iDbPage-1) / p->nPagePerSector)
-                 && p->rc==SQLITE_OK
-            );
-          }
-          p->nProgress++;
-        }
-        break;
-      }
-
-      default:
-        break;
-    }
-    return p->rc;
-  }else{
-    return SQLITE_NOMEM;
-  }
-}
-
-/*
-** Compare strings z1 and z2, returning 0 if they are identical, or non-zero
-** otherwise. Either or both argument may be NULL. Two NULL values are
-** considered equal, and NULL is considered distinct from all other values.
-*/
-static int rbuStrCompare(const char *z1, const char *z2){
-  if( z1==0 && z2==0 ) return 0;
-  if( z1==0 || z2==0 ) return 1;
-  return (sqlite3_stricmp(z1, z2)!=0);
-}
-
-/*
-** This function is called as part of sqlite3rbu_open() when initializing
-** an rbu handle in OAL stage. If the rbu update has not started (i.e.
-** the rbu_state table was empty) it is a no-op. Otherwise, it arranges
-** things so that the next call to sqlite3rbu_step() continues on from
-** where the previous rbu handle left off.
-**
-** If an error occurs, an error code and error message are left in the
-** rbu handle passed as the first argument.
-*/
-static void rbuSetupOal(sqlite3rbu *p, RbuState *pState){
-  assert( p->rc==SQLITE_OK );
-  if( pState->zTbl ){
-    RbuObjIter *pIter = &p->objiter;
-    int rc = SQLITE_OK;
-
-    while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
-       || rbuStrCompare(pIter->zIdx, pState->zIdx)
-       || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl))
-       || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl))
-    )){
-      rc = rbuObjIterNext(p, pIter);
-    }
-
-    if( rc==SQLITE_OK && !pIter->zTbl ){
-      rc = SQLITE_ERROR;
-      p->zErrmsg = sqlite3_mprintf("rbu_state mismatch error");
-    }
-
-    if( rc==SQLITE_OK ){
-      p->nStep = pState->nRow;
-      rc = rbuObjIterPrepareAll(p, &p->objiter, p->nStep);
-    }
-
-    p->rc = rc;
-  }
-}
-
-/*
-** If there is a "*-oal" file in the file-system corresponding to the
-** target database in the file-system, delete it. If an error occurs,
-** leave an error code and error message in the rbu handle.
-*/
-static void rbuDeleteOalFile(sqlite3rbu *p){
-  char *zOal = rbuMPrintf(p, "%s-oal", p->zTarget);
-  if( zOal ){
-    sqlite3_vfs *pVfs = 0;
-    sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_VFS_POINTER, &pVfs);
-    assert( pVfs && p->rc==SQLITE_OK && p->zErrmsg==0 );
-    pVfs->xDelete(pVfs, zOal, 0);
-    sqlite3_free(zOal);
-  }
-}
-
-/*
-** Allocate a private rbu VFS for the rbu handle passed as the only
-** argument. This VFS will be used unless the call to sqlite3rbu_open()
-** specified a URI with a vfs=? option in place of a target database
-** file name.
-*/
-static void rbuCreateVfs(sqlite3rbu *p){
-  int rnd;
-  char zRnd[64];
-
-  assert( p->rc==SQLITE_OK );
-  sqlite3_randomness(sizeof(int), (void*)&rnd);
-  sqlite3_snprintf(sizeof(zRnd), zRnd, "rbu_vfs_%d", rnd);
-  p->rc = sqlite3rbu_create_vfs(zRnd, 0);
-  if( p->rc==SQLITE_OK ){
-    sqlite3_vfs *pVfs = sqlite3_vfs_find(zRnd);
-    assert( pVfs );
-    p->zVfsName = pVfs->zName;
-    ((rbu_vfs*)pVfs)->pRbu = p;
-  }
-}
-
-/*
-** Destroy the private VFS created for the rbu handle passed as the only
-** argument by an earlier call to rbuCreateVfs().
-*/
-static void rbuDeleteVfs(sqlite3rbu *p){
-  if( p->zVfsName ){
-    sqlite3rbu_destroy_vfs(p->zVfsName);
-    p->zVfsName = 0;
-  }
-}
-
-/*
-** This user-defined SQL function is invoked with a single argument - the
-** name of a table expected to appear in the target database. It returns
-** the number of auxilliary indexes on the table.
-*/
-static void rbuIndexCntFunc(
-  sqlite3_context *pCtx,
-  int nVal,
-  sqlite3_value **apVal
-){
-  sqlite3rbu *p = (sqlite3rbu*)sqlite3_user_data(pCtx);
-  sqlite3_stmt *pStmt = 0;
-  char *zErrmsg = 0;
-  int rc;
-  sqlite3 *db = (rbuIsVacuum(p) ? p->dbRbu : p->dbMain);
-
-  assert( nVal==1 );
-  UNUSED_PARAMETER(nVal);
-
-  rc = prepareFreeAndCollectError(db, &pStmt, &zErrmsg,
-      sqlite3_mprintf("SELECT count(*) FROM sqlite_schema "
-        "WHERE type='index' AND tbl_name = %Q", sqlite3_value_text(apVal[0]))
-  );
-  if( rc!=SQLITE_OK ){
-    sqlite3_result_error(pCtx, zErrmsg, -1);
-  }else{
-    int nIndex = 0;
-    if( SQLITE_ROW==sqlite3_step(pStmt) ){
-      nIndex = sqlite3_column_int(pStmt, 0);
-    }
-    rc = sqlite3_finalize(pStmt);
-    if( rc==SQLITE_OK ){
-      sqlite3_result_int(pCtx, nIndex);
-    }else{
-      sqlite3_result_error(pCtx, sqlite3_errmsg(db), -1);
-    }
-  }
-
-  sqlite3_free(zErrmsg);
-}
-
-/*
-** If the RBU database contains the rbu_count table, use it to initialize
-** the sqlite3rbu.nPhaseOneStep variable. The schema of the rbu_count table
-** is assumed to contain the same columns as:
-**
-**   CREATE TABLE rbu_count(tbl TEXT PRIMARY KEY, cnt INTEGER) WITHOUT ROWID;
-**
-** There should be one row in the table for each data_xxx table in the
-** database. The 'tbl' column should contain the name of a data_xxx table,
-** and the cnt column the number of rows it contains.
-**
-** sqlite3rbu.nPhaseOneStep is initialized to the sum of (1 + nIndex) * cnt
-** for all rows in the rbu_count table, where nIndex is the number of
-** indexes on the corresponding target database table.
-*/
-static void rbuInitPhaseOneSteps(sqlite3rbu *p){
-  if( p->rc==SQLITE_OK ){
-    sqlite3_stmt *pStmt = 0;
-    int bExists = 0;                /* True if rbu_count exists */
-
-    p->nPhaseOneStep = -1;
-
-    p->rc = sqlite3_create_function(p->dbRbu,
-        "rbu_index_cnt", 1, SQLITE_UTF8, (void*)p, rbuIndexCntFunc, 0, 0
-    );
-
-    /* Check for the rbu_count table. If it does not exist, or if an error
-    ** occurs, nPhaseOneStep will be left set to -1. */
-    if( p->rc==SQLITE_OK ){
-      p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
-          "SELECT 1 FROM sqlite_schema WHERE tbl_name = 'rbu_count'"
-      );
-    }
-    if( p->rc==SQLITE_OK ){
-      if( SQLITE_ROW==sqlite3_step(pStmt) ){
-        bExists = 1;
-      }
-      p->rc = sqlite3_finalize(pStmt);
-    }
-
-    if( p->rc==SQLITE_OK && bExists ){
-      p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
-          "SELECT sum(cnt * (1 + rbu_index_cnt(rbu_target_name(tbl))))"
-          "FROM rbu_count"
-      );
-      if( p->rc==SQLITE_OK ){
-        if( SQLITE_ROW==sqlite3_step(pStmt) ){
-          p->nPhaseOneStep = sqlite3_column_int64(pStmt, 0);
-        }
-        p->rc = sqlite3_finalize(pStmt);
-      }
-    }
-  }
-}
-
-
-static sqlite3rbu *openRbuHandle(
-  const char *zTarget,
-  const char *zRbu,
-  const char *zState
-){
-  sqlite3rbu *p;
-  size_t nTarget = zTarget ? strlen(zTarget) : 0;
-  size_t nRbu = strlen(zRbu);
-  size_t nByte = sizeof(sqlite3rbu) + nTarget+1 + nRbu+1;
-
-  p = (sqlite3rbu*)sqlite3_malloc64(nByte);
-  if( p ){
-    RbuState *pState = 0;
-
-    /* Create the custom VFS. */
-    memset(p, 0, sizeof(sqlite3rbu));
-    sqlite3rbu_rename_handler(p, 0, 0);
-    rbuCreateVfs(p);
-
-    /* Open the target, RBU and state databases */
-    if( p->rc==SQLITE_OK ){
-      char *pCsr = (char*)&p[1];
-      int bRetry = 0;
-      if( zTarget ){
-        p->zTarget = pCsr;
-        memcpy(p->zTarget, zTarget, nTarget+1);
-        pCsr += nTarget+1;
-      }
-      p->zRbu = pCsr;
-      memcpy(p->zRbu, zRbu, nRbu+1);
-      pCsr += nRbu+1;
-      if( zState ){
-        p->zState = rbuMPrintf(p, "%s", zState);
-      }
-
-      /* If the first attempt to open the database file fails and the bRetry
-      ** flag it set, this means that the db was not opened because it seemed
-      ** to be a wal-mode db. But, this may have happened due to an earlier
-      ** RBU vacuum operation leaving an old wal file in the directory.
-      ** If this is the case, it will have been checkpointed and deleted
-      ** when the handle was closed and a second attempt to open the
-      ** database may succeed.  */
-      rbuOpenDatabase(p, 0, &bRetry);
-      if( bRetry ){
-        rbuOpenDatabase(p, 0, 0);
-      }
-    }
-
-    if( p->rc==SQLITE_OK ){
-      pState = rbuLoadState(p);
-      assert( pState || p->rc!=SQLITE_OK );
-      if( p->rc==SQLITE_OK ){
-
-        if( pState->eStage==0 ){
-          rbuDeleteOalFile(p);
-          rbuInitPhaseOneSteps(p);
-          p->eStage = RBU_STAGE_OAL;
-        }else{
-          p->eStage = pState->eStage;
-          p->nPhaseOneStep = pState->nPhaseOneStep;
-        }
-        p->nProgress = pState->nProgress;
-        p->iOalSz = pState->iOalSz;
-      }
-    }
-    assert( p->rc!=SQLITE_OK || p->eStage!=0 );
-
-    if( p->rc==SQLITE_OK && p->pTargetFd->pWalFd ){
-      if( p->eStage==RBU_STAGE_OAL ){
-        p->rc = SQLITE_ERROR;
-        p->zErrmsg = sqlite3_mprintf("cannot update wal mode database");
-      }else if( p->eStage==RBU_STAGE_MOVE ){
-        p->eStage = RBU_STAGE_CKPT;
-        p->nStep = 0;
-      }
-    }
-
-    if( p->rc==SQLITE_OK
-     && (p->eStage==RBU_STAGE_OAL || p->eStage==RBU_STAGE_MOVE)
-     && pState->eStage!=0
-    ){
-      rbu_file *pFd = (rbuIsVacuum(p) ? p->pRbuFd : p->pTargetFd);
-      if( pFd->iCookie!=pState->iCookie ){
-        /* At this point (pTargetFd->iCookie) contains the value of the
-        ** change-counter cookie (the thing that gets incremented when a
-        ** transaction is committed in rollback mode) currently stored on
-        ** page 1 of the database file. */
-        p->rc = SQLITE_BUSY;
-        p->zErrmsg = sqlite3_mprintf("database modified during rbu %s",
-            (rbuIsVacuum(p) ? "vacuum" : "update")
-        );
-      }
-    }
-
-    if( p->rc==SQLITE_OK ){
-      if( p->eStage==RBU_STAGE_OAL ){
-        sqlite3 *db = p->dbMain;
-        p->rc = sqlite3_exec(p->dbRbu, "BEGIN", 0, 0, &p->zErrmsg);
-
-        /* Point the object iterator at the first object */
-        if( p->rc==SQLITE_OK ){
-          p->rc = rbuObjIterFirst(p, &p->objiter);
-        }
-
-        /* If the RBU database contains no data_xxx tables, declare the RBU
-        ** update finished.  */
-        if( p->rc==SQLITE_OK && p->objiter.zTbl==0 ){
-          p->rc = SQLITE_DONE;
-          p->eStage = RBU_STAGE_DONE;
-        }else{
-          if( p->rc==SQLITE_OK && pState->eStage==0 && rbuIsVacuum(p) ){
-            rbuCopyPragma(p, "page_size");
-            rbuCopyPragma(p, "auto_vacuum");
-          }
-
-          /* Open transactions both databases. The *-oal file is opened or
-          ** created at this point. */
-          if( p->rc==SQLITE_OK ){
-            p->rc = sqlite3_exec(db, "BEGIN IMMEDIATE", 0, 0, &p->zErrmsg);
-          }
-
-          /* Check if the main database is a zipvfs db. If it is, set the upper
-          ** level pager to use "journal_mode=off". This prevents it from
-          ** generating a large journal using a temp file.  */
-          if( p->rc==SQLITE_OK ){
-            int frc = sqlite3_file_control(db, "main", SQLITE_FCNTL_ZIPVFS, 0);
-            if( frc==SQLITE_OK ){
-              p->rc = sqlite3_exec(
-                db, "PRAGMA journal_mode=off",0,0,&p->zErrmsg);
-            }
-          }
-
-          if( p->rc==SQLITE_OK ){
-            rbuSetupOal(p, pState);
-          }
-        }
-      }else if( p->eStage==RBU_STAGE_MOVE ){
-        /* no-op */
-      }else if( p->eStage==RBU_STAGE_CKPT ){
-        if( !rbuIsVacuum(p) && rbuExclusiveCheckpoint(p->dbMain) ){
-          /* If the rbu_exclusive_checkpoint=1 URI parameter was specified
-          ** and an incremental checkpoint is being resumed, attempt an
-          ** exclusive lock on the db file. If this fails, so be it.  */
-          p->eStage = RBU_STAGE_DONE;
-          rbuLockDatabase(p->dbMain);
-          p->eStage = RBU_STAGE_CKPT;
-        }
-        rbuSetupCheckpoint(p, pState);
-      }else if( p->eStage==RBU_STAGE_DONE ){
-        p->rc = SQLITE_DONE;
-      }else{
-        p->rc = SQLITE_CORRUPT;
-      }
-    }
-
-    rbuFreeState(pState);
-  }
-
-  return p;
-}
-
-/*
-** Allocate and return an RBU handle with all fields zeroed except for the
-** error code, which is set to SQLITE_MISUSE.
-*/
-static sqlite3rbu *rbuMisuseError(void){
-  sqlite3rbu *pRet;
-  pRet = sqlite3_malloc64(sizeof(sqlite3rbu));
-  if( pRet ){
-    memset(pRet, 0, sizeof(sqlite3rbu));
-    pRet->rc = SQLITE_MISUSE;
-  }
-  return pRet;
-}
-
-/*
-** Open and return a new RBU handle.
-*/
-SQLITE_API sqlite3rbu *sqlite3rbu_open(
-  const char *zTarget,
-  const char *zRbu,
-  const char *zState
-){
-  if( zTarget==0 || zRbu==0 ){ return rbuMisuseError(); }
-  return openRbuHandle(zTarget, zRbu, zState);
-}
-
-/*
-** Open a handle to begin or resume an RBU VACUUM operation.
-*/
-SQLITE_API sqlite3rbu *sqlite3rbu_vacuum(
-  const char *zTarget,
-  const char *zState
-){
-  if( zTarget==0 ){ return rbuMisuseError(); }
-  if( zState ){
-    size_t n = strlen(zState);
-    if( n>=7 && 0==memcmp("-vactmp", &zState[n-7], 7) ){
-      return rbuMisuseError();
-    }
-  }
-  /* TODO: Check that both arguments are non-NULL */
-  return openRbuHandle(0, zTarget, zState);
-}
-
-/*
-** Return the database handle used by pRbu.
-*/
-SQLITE_API sqlite3 *sqlite3rbu_db(sqlite3rbu *pRbu, int bRbu){
-  sqlite3 *db = 0;
-  if( pRbu ){
-    db = (bRbu ? pRbu->dbRbu : pRbu->dbMain);
-  }
-  return db;
-}
-
-
-/*
-** If the error code currently stored in the RBU handle is SQLITE_CONSTRAINT,
-** then edit any error message string so as to remove all occurrences of
-** the pattern "rbu_imp_[0-9]*".
-*/
-static void rbuEditErrmsg(sqlite3rbu *p){
-  if( p->rc==SQLITE_CONSTRAINT && p->zErrmsg ){
-    unsigned int i;
-    size_t nErrmsg = strlen(p->zErrmsg);
-    for(i=0; i<(nErrmsg-8); i++){
-      if( memcmp(&p->zErrmsg[i], "rbu_imp_", 8)==0 ){
-        int nDel = 8;
-        while( p->zErrmsg[i+nDel]>='0' && p->zErrmsg[i+nDel]<='9' ) nDel++;
-        memmove(&p->zErrmsg[i], &p->zErrmsg[i+nDel], nErrmsg + 1 - i - nDel);
-        nErrmsg -= nDel;
-      }
-    }
-  }
-}
-
-/*
-** Close the RBU handle.
-*/
-SQLITE_API int sqlite3rbu_close(sqlite3rbu *p, char **pzErrmsg){
-  int rc;
-  if( p ){
-
-    /* Commit the transaction to the *-oal file. */
-    if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
-      p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
-    }
-
-    /* Sync the db file if currently doing an incremental checkpoint */
-    if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
-      sqlite3_file *pDb = p->pTargetFd->pReal;
-      p->rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
-    }
-
-    rbuSaveState(p, p->eStage);
-
-    if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
-      p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
-    }
-
-    /* Close any open statement handles. */
-    rbuObjIterFinalize(&p->objiter);
-
-    /* If this is an RBU vacuum handle and the vacuum has either finished
-    ** successfully or encountered an error, delete the contents of the
-    ** state table. This causes the next call to sqlite3rbu_vacuum()
-    ** specifying the current target and state databases to start a new
-    ** vacuum from scratch.  */
-    if( rbuIsVacuum(p) && p->rc!=SQLITE_OK && p->dbRbu ){
-      int rc2 = sqlite3_exec(p->dbRbu, "DELETE FROM stat.rbu_state", 0, 0, 0);
-      if( p->rc==SQLITE_DONE && rc2!=SQLITE_OK ) p->rc = rc2;
-    }
-
-    /* Close the open database handle and VFS object. */
-    sqlite3_close(p->dbRbu);
-    sqlite3_close(p->dbMain);
-    assert( p->szTemp==0 );
-    rbuDeleteVfs(p);
-    sqlite3_free(p->aBuf);
-    sqlite3_free(p->aFrame);
-
-    rbuEditErrmsg(p);
-    rc = p->rc;
-    if( pzErrmsg ){
-      *pzErrmsg = p->zErrmsg;
-    }else{
-      sqlite3_free(p->zErrmsg);
-    }
-    sqlite3_free(p->zState);
-    sqlite3_free(p);
-  }else{
-    rc = SQLITE_NOMEM;
-    *pzErrmsg = 0;
-  }
-  return rc;
-}
-
-/*
-** 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){
-  return pRbu->nProgress;
-}
-
-/*
-** Return permyriadage progress indications for the two main stages of
-** an RBU update.
-*/
-SQLITE_API void sqlite3rbu_bp_progress(sqlite3rbu *p, int *pnOne, int *pnTwo){
-  const int MAX_PROGRESS = 10000;
-  switch( p->eStage ){
-    case RBU_STAGE_OAL:
-      if( p->nPhaseOneStep>0 ){
-        *pnOne = (int)(MAX_PROGRESS * (i64)p->nProgress/(i64)p->nPhaseOneStep);
-      }else{
-        *pnOne = -1;
-      }
-      *pnTwo = 0;
-      break;
-
-    case RBU_STAGE_MOVE:
-      *pnOne = MAX_PROGRESS;
-      *pnTwo = 0;
-      break;
-
-    case RBU_STAGE_CKPT:
-      *pnOne = MAX_PROGRESS;
-      *pnTwo = (int)(MAX_PROGRESS * (i64)p->nStep / (i64)p->nFrame);
-      break;
-
-    case RBU_STAGE_DONE:
-      *pnOne = MAX_PROGRESS;
-      *pnTwo = MAX_PROGRESS;
-      break;
-
-    default:
-      assert( 0 );
-  }
-}
-
-/*
-** Return the current state of the RBU vacuum or update operation.
-*/
-SQLITE_API int sqlite3rbu_state(sqlite3rbu *p){
-  int aRes[] = {
-    0, SQLITE_RBU_STATE_OAL, SQLITE_RBU_STATE_MOVE,
-    0, SQLITE_RBU_STATE_CHECKPOINT, SQLITE_RBU_STATE_DONE
-  };
-
-  assert( RBU_STAGE_OAL==1 );
-  assert( RBU_STAGE_MOVE==2 );
-  assert( RBU_STAGE_CKPT==4 );
-  assert( RBU_STAGE_DONE==5 );
-  assert( aRes[RBU_STAGE_OAL]==SQLITE_RBU_STATE_OAL );
-  assert( aRes[RBU_STAGE_MOVE]==SQLITE_RBU_STATE_MOVE );
-  assert( aRes[RBU_STAGE_CKPT]==SQLITE_RBU_STATE_CHECKPOINT );
-  assert( aRes[RBU_STAGE_DONE]==SQLITE_RBU_STATE_DONE );
-
-  if( p->rc!=SQLITE_OK && p->rc!=SQLITE_DONE ){
-    return SQLITE_RBU_STATE_ERROR;
-  }else{
-    assert( p->rc!=SQLITE_DONE || p->eStage==RBU_STAGE_DONE );
-    assert( p->eStage==RBU_STAGE_OAL
-         || p->eStage==RBU_STAGE_MOVE
-         || p->eStage==RBU_STAGE_CKPT
-         || p->eStage==RBU_STAGE_DONE
-    );
-    return aRes[p->eStage];
-  }
-}
-
-SQLITE_API int sqlite3rbu_savestate(sqlite3rbu *p){
-  int rc = p->rc;
-  if( rc==SQLITE_DONE ) return SQLITE_OK;
-
-  assert( p->eStage>=RBU_STAGE_OAL && p->eStage<=RBU_STAGE_DONE );
-  if( p->eStage==RBU_STAGE_OAL ){
-    assert( rc!=SQLITE_DONE );
-    if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, 0);
-  }
-
-  /* Sync the db file */
-  if( rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
-    sqlite3_file *pDb = p->pTargetFd->pReal;
-    rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
-  }
-
-  p->rc = rc;
-  rbuSaveState(p, p->eStage);
-  rc = p->rc;
-
-  if( p->eStage==RBU_STAGE_OAL ){
-    assert( rc!=SQLITE_DONE );
-    if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0);
-    if( rc==SQLITE_OK ){
-      const char *zBegin = rbuIsVacuum(p) ? "BEGIN" : "BEGIN IMMEDIATE";
-      rc = sqlite3_exec(p->dbRbu, zBegin, 0, 0, 0);
-    }
-    if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "BEGIN IMMEDIATE", 0, 0,0);
-  }
-
-  p->rc = rc;
-  return rc;
-}
-
-/*
-** Default xRename callback for RBU.
-*/
-static int xDefaultRename(void *pArg, const char *zOld, const char *zNew){
-  int rc = SQLITE_OK;
-  UNUSED_PARAMETER(pArg);
-#if defined(_WIN32_WCE)
-  {
-    LPWSTR zWideOld;
-    LPWSTR zWideNew;
-
-    zWideOld = rbuWinUtf8ToUnicode(zOld);
-    if( zWideOld ){
-      zWideNew = rbuWinUtf8ToUnicode(zNew);
-      if( zWideNew ){
-        if( MoveFileW(zWideOld, zWideNew) ){
-          rc = SQLITE_OK;
-        }else{
-          rc = SQLITE_IOERR;
-        }
-        sqlite3_free(zWideNew);
-      }else{
-        rc = SQLITE_IOERR_NOMEM;
-      }
-      sqlite3_free(zWideOld);
-    }else{
-      rc = SQLITE_IOERR_NOMEM;
-    }
-  }
-#else
-  rc = rename(zOld, zNew) ? SQLITE_IOERR : SQLITE_OK;
-#endif
-  return rc;
-}
-
-SQLITE_API void sqlite3rbu_rename_handler(
-  sqlite3rbu *pRbu,
-  void *pArg,
-  int (*xRename)(void *pArg, const char *zOld, const char *zNew)
-){
-  if( xRename ){
-    pRbu->xRename = xRename;
-    pRbu->pRenameArg = pArg;
-  }else{
-    pRbu->xRename = xDefaultRename;
-    pRbu->pRenameArg = 0;
-  }
-}
-
-/**************************************************************************
-** Beginning of RBU VFS shim methods. The VFS shim modifies the behaviour
-** of a standard VFS in the following ways:
-**
-** 1. Whenever the first page of a main database file is read or
-**    written, the value of the change-counter cookie is stored in
-**    rbu_file.iCookie. Similarly, the value of the "write-version"
-**    database header field is stored in rbu_file.iWriteVer. This ensures
-**    that the values are always trustworthy within an open transaction.
-**
-** 2. Whenever an SQLITE_OPEN_WAL file is opened, the (rbu_file.pWalFd)
-**    member variable of the associated database file descriptor is set
-**    to point to the new file. A mutex protected linked list of all main
-**    db fds opened using a particular RBU VFS is maintained at
-**    rbu_vfs.pMain to facilitate this.
-**
-** 3. Using a new file-control "SQLITE_FCNTL_RBU", a main db rbu_file
-**    object can be marked as the target database of an RBU update. This
-**    turns on the following extra special behaviour:
-**
-** 3a. If xAccess() is called to check if there exists a *-wal file
-**     associated with an RBU target database currently in RBU_STAGE_OAL
-**     stage (preparing the *-oal file), the following special handling
-**     applies:
-**
-**      * if the *-wal file does exist, return SQLITE_CANTOPEN. An RBU
-**        target database may not be in wal mode already.
-**
-**      * if the *-wal file does not exist, set the output parameter to
-**        non-zero (to tell SQLite that it does exist) anyway.
-**
-**     Then, when xOpen() is called to open the *-wal file associated with
-**     the RBU target in RBU_STAGE_OAL stage, instead of opening the *-wal
-**     file, the rbu vfs opens the corresponding *-oal file instead.
-**
-** 3b. The *-shm pages returned by xShmMap() for a target db file in
-**     RBU_STAGE_OAL mode are actually stored in heap memory. This is to
-**     avoid creating a *-shm file on disk. Additionally, xShmLock() calls
-**     are no-ops on target database files in RBU_STAGE_OAL mode. This is
-**     because assert() statements in some VFS implementations fail if
-**     xShmLock() is called before xShmMap().
-**
-** 3c. If an EXCLUSIVE lock is attempted on a target database file in any
-**     mode except RBU_STAGE_DONE (all work completed and checkpointed), it
-**     fails with an SQLITE_BUSY error. This is to stop RBU connections
-**     from automatically checkpointing a *-wal (or *-oal) file from within
-**     sqlite3_close().
-**
-** 3d. In RBU_STAGE_CAPTURE mode, all xRead() calls on the wal file, and
-**     all xWrite() calls on the target database file perform no IO.
-**     Instead the frame and page numbers that would be read and written
-**     are recorded. Additionally, successful attempts to obtain exclusive
-**     xShmLock() WRITER, CHECKPOINTER and READ0 locks on the target
-**     database file are recorded. xShmLock() calls to unlock the same
-**     locks are no-ops (so that once obtained, these locks are never
-**     relinquished). Finally, calls to xSync() on the target database
-**     file fail with SQLITE_NOTICE errors.
-*/
-
-static void rbuUnlockShm(rbu_file *p){
-  assert( p->openFlags & SQLITE_OPEN_MAIN_DB );
-  if( p->pRbu ){
-    int (*xShmLock)(sqlite3_file*,int,int,int) = p->pReal->pMethods->xShmLock;
-    int i;
-    for(i=0; i<SQLITE_SHM_NLOCK;i++){
-      if( (1<<i) & p->pRbu->mLock ){
-        xShmLock(p->pReal, i, 1, SQLITE_SHM_UNLOCK|SQLITE_SHM_EXCLUSIVE);
-      }
-    }
-    p->pRbu->mLock = 0;
-  }
-}
-
-/*
-*/
-static int rbuUpdateTempSize(rbu_file *pFd, sqlite3_int64 nNew){
-  sqlite3rbu *pRbu = pFd->pRbu;
-  i64 nDiff = nNew - pFd->sz;
-  pRbu->szTemp += nDiff;
-  pFd->sz = nNew;
-  assert( pRbu->szTemp>=0 );
-  if( pRbu->szTempLimit && pRbu->szTemp>pRbu->szTempLimit ) return SQLITE_FULL;
-  return SQLITE_OK;
-}
-
-/*
-** Add an item to the main-db lists, if it is not already present.
-**
-** There are two main-db lists. One for all file descriptors, and one
-** for all file descriptors with rbu_file.pDb!=0. If the argument has
-** rbu_file.pDb!=0, then it is assumed to already be present on the
-** main list and is only added to the pDb!=0 list.
-*/
-static void rbuMainlistAdd(rbu_file *p){
-  rbu_vfs *pRbuVfs = p->pRbuVfs;
-  rbu_file *pIter;
-  assert( (p->openFlags & SQLITE_OPEN_MAIN_DB) );
-  sqlite3_mutex_enter(pRbuVfs->mutex);
-  if( p->pRbu==0 ){
-    for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext);
-    p->pMainNext = pRbuVfs->pMain;
-    pRbuVfs->pMain = p;
-  }else{
-    for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){}
-    if( pIter==0 ){
-      p->pMainRbuNext = pRbuVfs->pMainRbu;
-      pRbuVfs->pMainRbu = p;
-    }
-  }
-  sqlite3_mutex_leave(pRbuVfs->mutex);
-}
-
-/*
-** Remove an item from the main-db lists.
-*/
-static void rbuMainlistRemove(rbu_file *p){
-  rbu_file **pp;
-  sqlite3_mutex_enter(p->pRbuVfs->mutex);
-  for(pp=&p->pRbuVfs->pMain; *pp && *pp!=p; pp=&((*pp)->pMainNext)){}
-  if( *pp ) *pp = p->pMainNext;
-  p->pMainNext = 0;
-  for(pp=&p->pRbuVfs->pMainRbu; *pp && *pp!=p; pp=&((*pp)->pMainRbuNext)){}
-  if( *pp ) *pp = p->pMainRbuNext;
-  p->pMainRbuNext = 0;
-  sqlite3_mutex_leave(p->pRbuVfs->mutex);
-}
-
-/*
-** Given that zWal points to a buffer containing a wal file name passed to
-** either the xOpen() or xAccess() VFS method, search the main-db list for
-** a file-handle opened by the same database connection on the corresponding
-** database file.
-**
-** If parameter bRbu is true, only search for file-descriptors with
-** rbu_file.pDb!=0.
-*/
-static rbu_file *rbuFindMaindb(rbu_vfs *pRbuVfs, const char *zWal, int bRbu){
-  rbu_file *pDb;
-  sqlite3_mutex_enter(pRbuVfs->mutex);
-  if( bRbu ){
-    for(pDb=pRbuVfs->pMainRbu; pDb && pDb->zWal!=zWal; pDb=pDb->pMainRbuNext){}
-  }else{
-    for(pDb=pRbuVfs->pMain; pDb && pDb->zWal!=zWal; pDb=pDb->pMainNext){}
-  }
-  sqlite3_mutex_leave(pRbuVfs->mutex);
-  return pDb;
-}
-
-/*
-** Close an rbu file.
-*/
-static int rbuVfsClose(sqlite3_file *pFile){
-  rbu_file *p = (rbu_file*)pFile;
-  int rc;
-  int i;
-
-  /* Free the contents of the apShm[] array. And the array itself. */
-  for(i=0; i<p->nShm; i++){
-    sqlite3_free(p->apShm[i]);
-  }
-  sqlite3_free(p->apShm);
-  p->apShm = 0;
-  sqlite3_free(p->zDel);
-
-  if( p->openFlags & SQLITE_OPEN_MAIN_DB ){
-    const sqlite3_io_methods *pMeth = p->pReal->pMethods;
-    rbuMainlistRemove(p);
-    rbuUnlockShm(p);
-    if( pMeth->iVersion>1 && pMeth->xShmUnmap ){
-      pMeth->xShmUnmap(p->pReal, 0);
-    }
-  }
-  else if( (p->openFlags & SQLITE_OPEN_DELETEONCLOSE) && p->pRbu ){
-    rbuUpdateTempSize(p, 0);
-  }
-  assert( p->pMainNext==0 && p->pRbuVfs->pMain!=p );
-
-  /* Close the underlying file handle */
-  rc = p->pReal->pMethods->xClose(p->pReal);
-  return rc;
-}
-
-
-/*
-** Read and return an unsigned 32-bit big-endian integer from the buffer
-** passed as the only argument.
-*/
-static u32 rbuGetU32(u8 *aBuf){
-  return ((u32)aBuf[0] << 24)
-       + ((u32)aBuf[1] << 16)
-       + ((u32)aBuf[2] <<  8)
-       + ((u32)aBuf[3]);
-}
-
-/*
-** Write an unsigned 32-bit value in big-endian format to the supplied
-** buffer.
-*/
-static void rbuPutU32(u8 *aBuf, u32 iVal){
-  aBuf[0] = (iVal >> 24) & 0xFF;
-  aBuf[1] = (iVal >> 16) & 0xFF;
-  aBuf[2] = (iVal >>  8) & 0xFF;
-  aBuf[3] = (iVal >>  0) & 0xFF;
-}
-
-static void rbuPutU16(u8 *aBuf, u16 iVal){
-  aBuf[0] = (iVal >>  8) & 0xFF;
-  aBuf[1] = (iVal >>  0) & 0xFF;
-}
-
-/*
-** Read data from an rbuVfs-file.
-*/
-static int rbuVfsRead(
-  sqlite3_file *pFile,
-  void *zBuf,
-  int iAmt,
-  sqlite_int64 iOfst
-){
-  rbu_file *p = (rbu_file*)pFile;
-  sqlite3rbu *pRbu = p->pRbu;
-  int rc;
-
-  if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
-    assert( p->openFlags & SQLITE_OPEN_WAL );
-    rc = rbuCaptureWalRead(p->pRbu, iOfst, iAmt);
-  }else{
-    if( pRbu && pRbu->eStage==RBU_STAGE_OAL
-     && (p->openFlags & SQLITE_OPEN_WAL)
-     && iOfst>=pRbu->iOalSz
-    ){
-      rc = SQLITE_OK;
-      memset(zBuf, 0, iAmt);
-    }else{
-      rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
-#if 1
-      /* If this is being called to read the first page of the target
-      ** database as part of an rbu vacuum operation, synthesize the
-      ** contents of the first page if it does not yet exist. Otherwise,
-      ** SQLite will not check for a *-wal file.  */
-      if( pRbu && rbuIsVacuum(pRbu)
-          && rc==SQLITE_IOERR_SHORT_READ && iOfst==0
-          && (p->openFlags & SQLITE_OPEN_MAIN_DB)
-          && pRbu->rc==SQLITE_OK
-      ){
-        sqlite3_file *pFd = (sqlite3_file*)pRbu->pRbuFd;
-        rc = pFd->pMethods->xRead(pFd, zBuf, iAmt, iOfst);
-        if( rc==SQLITE_OK ){
-          u8 *aBuf = (u8*)zBuf;
-          u32 iRoot = rbuGetU32(&aBuf[52]) ? 1 : 0;
-          rbuPutU32(&aBuf[52], iRoot);      /* largest root page number */
-          rbuPutU32(&aBuf[36], 0);          /* number of free pages */
-          rbuPutU32(&aBuf[32], 0);          /* first page on free list trunk */
-          rbuPutU32(&aBuf[28], 1);          /* size of db file in pages */
-          rbuPutU32(&aBuf[24], pRbu->pRbuFd->iCookie+1);  /* Change counter */
-
-          if( iAmt>100 ){
-            memset(&aBuf[100], 0, iAmt-100);
-            rbuPutU16(&aBuf[105], iAmt & 0xFFFF);
-            aBuf[100] = 0x0D;
-          }
-        }
-      }
-#endif
-    }
-    if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
-      /* These look like magic numbers. But they are stable, as they are part
-       ** of the definition of the SQLite file format, which may not change. */
-      u8 *pBuf = (u8*)zBuf;
-      p->iCookie = rbuGetU32(&pBuf[24]);
-      p->iWriteVer = pBuf[19];
-    }
-  }
-  return rc;
-}
-
-/*
-** Write data to an rbuVfs-file.
-*/
-static int rbuVfsWrite(
-  sqlite3_file *pFile,
-  const void *zBuf,
-  int iAmt,
-  sqlite_int64 iOfst
-){
-  rbu_file *p = (rbu_file*)pFile;
-  sqlite3rbu *pRbu = p->pRbu;
-  int rc;
-
-  if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
-    assert( p->openFlags & SQLITE_OPEN_MAIN_DB );
-    rc = rbuCaptureDbWrite(p->pRbu, iOfst);
-  }else{
-    if( pRbu ){
-      if( pRbu->eStage==RBU_STAGE_OAL
-       && (p->openFlags & SQLITE_OPEN_WAL)
-       && iOfst>=pRbu->iOalSz
-      ){
-        pRbu->iOalSz = iAmt + iOfst;
-      }else if( p->openFlags & SQLITE_OPEN_DELETEONCLOSE ){
-        i64 szNew = iAmt+iOfst;
-        if( szNew>p->sz ){
-          rc = rbuUpdateTempSize(p, szNew);
-          if( rc!=SQLITE_OK ) return rc;
-        }
-      }
-    }
-    rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst);
-    if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
-      /* These look like magic numbers. But they are stable, as they are part
-      ** of the definition of the SQLite file format, which may not change. */
-      u8 *pBuf = (u8*)zBuf;
-      p->iCookie = rbuGetU32(&pBuf[24]);
-      p->iWriteVer = pBuf[19];
-    }
-  }
-  return rc;
-}
-
-/*
-** Truncate an rbuVfs-file.
-*/
-static int rbuVfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
-  rbu_file *p = (rbu_file*)pFile;
-  if( (p->openFlags & SQLITE_OPEN_DELETEONCLOSE) && p->pRbu ){
-    int rc = rbuUpdateTempSize(p, size);
-    if( rc!=SQLITE_OK ) return rc;
-  }
-  return p->pReal->pMethods->xTruncate(p->pReal, size);
-}
-
-/*
-** Sync an rbuVfs-file.
-*/
-static int rbuVfsSync(sqlite3_file *pFile, int flags){
-  rbu_file *p = (rbu_file *)pFile;
-  if( p->pRbu && p->pRbu->eStage==RBU_STAGE_CAPTURE ){
-    if( p->openFlags & SQLITE_OPEN_MAIN_DB ){
-      return SQLITE_NOTICE_RBU;
-    }
-    return SQLITE_OK;
-  }
-  return p->pReal->pMethods->xSync(p->pReal, flags);
-}
-
-/*
-** Return the current file-size of an rbuVfs-file.
-*/
-static int rbuVfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
-  rbu_file *p = (rbu_file *)pFile;
-  int rc;
-  rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
-
-  /* If this is an RBU vacuum operation and this is the target database,
-  ** pretend that it has at least one page. Otherwise, SQLite will not
-  ** check for the existence of a *-wal file. rbuVfsRead() contains
-  ** similar logic.  */
-  if( rc==SQLITE_OK && *pSize==0
-   && p->pRbu && rbuIsVacuum(p->pRbu)
-   && (p->openFlags & SQLITE_OPEN_MAIN_DB)
-  ){
-    *pSize = 1024;
-  }
-  return rc;
-}
-
-/*
-** Lock an rbuVfs-file.
-*/
-static int rbuVfsLock(sqlite3_file *pFile, int eLock){
-  rbu_file *p = (rbu_file*)pFile;
-  sqlite3rbu *pRbu = p->pRbu;
-  int rc = SQLITE_OK;
-
-  assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( eLock==SQLITE_LOCK_EXCLUSIVE
-   && (p->bNolock || (pRbu && pRbu->eStage!=RBU_STAGE_DONE))
-  ){
-    /* Do not allow EXCLUSIVE locks. Preventing SQLite from taking this
-    ** prevents it from checkpointing the database from sqlite3_close(). */
-    rc = SQLITE_BUSY;
-  }else{
-    rc = p->pReal->pMethods->xLock(p->pReal, eLock);
-  }
-
-  return rc;
-}
-
-/*
-** Unlock an rbuVfs-file.
-*/
-static int rbuVfsUnlock(sqlite3_file *pFile, int eLock){
-  rbu_file *p = (rbu_file *)pFile;
-  return p->pReal->pMethods->xUnlock(p->pReal, eLock);
-}
-
-/*
-** Check if another file-handle holds a RESERVED lock on an rbuVfs-file.
-*/
-static int rbuVfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
-  rbu_file *p = (rbu_file *)pFile;
-  return p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
-}
-
-/*
-** File control method. For custom operations on an rbuVfs-file.
-*/
-static int rbuVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
-  rbu_file *p = (rbu_file *)pFile;
-  int (*xControl)(sqlite3_file*,int,void*) = p->pReal->pMethods->xFileControl;
-  int rc;
-
-  assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB)
-       || p->openFlags & (SQLITE_OPEN_TRANSIENT_DB|SQLITE_OPEN_TEMP_JOURNAL)
-  );
-  if( op==SQLITE_FCNTL_RBU ){
-    sqlite3rbu *pRbu = (sqlite3rbu*)pArg;
-
-    /* First try to find another RBU vfs lower down in the vfs stack. If
-    ** one is found, this vfs will operate in pass-through mode. The lower
-    ** level vfs will do the special RBU handling.  */
-    rc = xControl(p->pReal, op, pArg);
-
-    if( rc==SQLITE_NOTFOUND ){
-      /* Now search for a zipvfs instance lower down in the VFS stack. If
-      ** one is found, this is an error.  */
-      void *dummy = 0;
-      rc = xControl(p->pReal, SQLITE_FCNTL_ZIPVFS, &dummy);
-      if( rc==SQLITE_OK ){
-        rc = SQLITE_ERROR;
-        pRbu->zErrmsg = sqlite3_mprintf("rbu/zipvfs setup error");
-      }else if( rc==SQLITE_NOTFOUND ){
-        pRbu->pTargetFd = p;
-        p->pRbu = pRbu;
-        rbuMainlistAdd(p);
-        if( p->pWalFd ) p->pWalFd->pRbu = pRbu;
-        rc = SQLITE_OK;
-      }
-    }
-    return rc;
-  }
-  else if( op==SQLITE_FCNTL_RBUCNT ){
-    sqlite3rbu *pRbu = (sqlite3rbu*)pArg;
-    pRbu->nRbu++;
-    pRbu->pRbuFd = p;
-    p->bNolock = 1;
-  }
-
-  rc = xControl(p->pReal, op, pArg);
-  if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){
-    rbu_vfs *pRbuVfs = p->pRbuVfs;
-    char *zIn = *(char**)pArg;
-    char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
-    *(char**)pArg = zOut;
-    if( zOut==0 ) rc = SQLITE_NOMEM;
-  }
-
-  return rc;
-}
-
-/*
-** Return the sector-size in bytes for an rbuVfs-file.
-*/
-static int rbuVfsSectorSize(sqlite3_file *pFile){
-  rbu_file *p = (rbu_file *)pFile;
-  return p->pReal->pMethods->xSectorSize(p->pReal);
-}
-
-/*
-** Return the device characteristic flags supported by an rbuVfs-file.
-*/
-static int rbuVfsDeviceCharacteristics(sqlite3_file *pFile){
-  rbu_file *p = (rbu_file *)pFile;
-  return p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
-}
-
-/*
-** Take or release a shared-memory lock.
-*/
-static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
-  rbu_file *p = (rbu_file*)pFile;
-  sqlite3rbu *pRbu = p->pRbu;
-  int rc = SQLITE_OK;
-
-#ifdef SQLITE_AMALGAMATION
-    assert( WAL_CKPT_LOCK==1 );
-#endif
-
-  assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( pRbu && (
-       pRbu->eStage==RBU_STAGE_OAL
-    || pRbu->eStage==RBU_STAGE_MOVE
-    || pRbu->eStage==RBU_STAGE_DONE
-  )){
-    /* Prevent SQLite from taking a shm-lock on the target file when it
-    ** is supplying heap memory to the upper layer in place of *-shm
-    ** segments. */
-    if( ofst==WAL_LOCK_CKPT && n==1 ) rc = SQLITE_BUSY;
-  }else{
-    int bCapture = 0;
-    if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
-      bCapture = 1;
-    }
-    if( bCapture==0 || 0==(flags & SQLITE_SHM_UNLOCK) ){
-      rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
-      if( bCapture && rc==SQLITE_OK ){
-        pRbu->mLock |= ((1<<n) - 1) << ofst;
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Obtain a pointer to a mapping of a single 32KiB page of the *-shm file.
-*/
-static int rbuVfsShmMap(
-  sqlite3_file *pFile,
-  int iRegion,
-  int szRegion,
-  int isWrite,
-  void volatile **pp
-){
-  rbu_file *p = (rbu_file*)pFile;
-  int rc = SQLITE_OK;
-  int eStage = (p->pRbu ? p->pRbu->eStage : 0);
-
-  /* If not in RBU_STAGE_OAL, allow this call to pass through. Or, if this
-  ** rbu is in the RBU_STAGE_OAL state, use heap memory for *-shm space
-  ** instead of a file on disk.  */
-  assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( eStage==RBU_STAGE_OAL ){
-    sqlite3_int64 nByte = (iRegion+1) * sizeof(char*);
-    char **apNew = (char**)sqlite3_realloc64(p->apShm, nByte);
-
-    /* This is an RBU connection that uses its own heap memory for the
-    ** pages of the *-shm file. Since no other process can have run
-    ** recovery, the connection must request *-shm pages in order
-    ** from start to finish.  */
-    assert( iRegion==p->nShm );
-    if( apNew==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      memset(&apNew[p->nShm], 0, sizeof(char*) * (1 + iRegion - p->nShm));
-      p->apShm = apNew;
-      p->nShm = iRegion+1;
-    }
-
-    if( rc==SQLITE_OK ){
-      char *pNew = (char*)sqlite3_malloc64(szRegion);
-      if( pNew==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        memset(pNew, 0, szRegion);
-        p->apShm[iRegion] = pNew;
-      }
-    }
-
-    if( rc==SQLITE_OK ){
-      *pp = p->apShm[iRegion];
-    }else{
-      *pp = 0;
-    }
-  }else{
-    assert( p->apShm==0 );
-    rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
-  }
-
-  return rc;
-}
-
-/*
-** Memory barrier.
-*/
-static void rbuVfsShmBarrier(sqlite3_file *pFile){
-  rbu_file *p = (rbu_file *)pFile;
-  p->pReal->pMethods->xShmBarrier(p->pReal);
-}
-
-/*
-** The xShmUnmap method.
-*/
-static int rbuVfsShmUnmap(sqlite3_file *pFile, int delFlag){
-  rbu_file *p = (rbu_file*)pFile;
-  int rc = SQLITE_OK;
-  int eStage = (p->pRbu ? p->pRbu->eStage : 0);
-
-  assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( eStage==RBU_STAGE_OAL || eStage==RBU_STAGE_MOVE ){
-    /* no-op */
-  }else{
-    /* Release the checkpointer and writer locks */
-    rbuUnlockShm(p);
-    rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
-  }
-  return rc;
-}
-
-/*
-** Open an rbu file handle.
-*/
-static int rbuVfsOpen(
-  sqlite3_vfs *pVfs,
-  const char *zName,
-  sqlite3_file *pFile,
-  int flags,
-  int *pOutFlags
-){
-  static sqlite3_io_methods rbuvfs_io_methods = {
-    2,                            /* iVersion */
-    rbuVfsClose,                  /* xClose */
-    rbuVfsRead,                   /* xRead */
-    rbuVfsWrite,                  /* xWrite */
-    rbuVfsTruncate,               /* xTruncate */
-    rbuVfsSync,                   /* xSync */
-    rbuVfsFileSize,               /* xFileSize */
-    rbuVfsLock,                   /* xLock */
-    rbuVfsUnlock,                 /* xUnlock */
-    rbuVfsCheckReservedLock,      /* xCheckReservedLock */
-    rbuVfsFileControl,            /* xFileControl */
-    rbuVfsSectorSize,             /* xSectorSize */
-    rbuVfsDeviceCharacteristics,  /* xDeviceCharacteristics */
-    rbuVfsShmMap,                 /* xShmMap */
-    rbuVfsShmLock,                /* xShmLock */
-    rbuVfsShmBarrier,             /* xShmBarrier */
-    rbuVfsShmUnmap,               /* xShmUnmap */
-    0, 0                          /* xFetch, xUnfetch */
-  };
-  static sqlite3_io_methods rbuvfs_io_methods1 = {
-    1,                            /* iVersion */
-    rbuVfsClose,                  /* xClose */
-    rbuVfsRead,                   /* xRead */
-    rbuVfsWrite,                  /* xWrite */
-    rbuVfsTruncate,               /* xTruncate */
-    rbuVfsSync,                   /* xSync */
-    rbuVfsFileSize,               /* xFileSize */
-    rbuVfsLock,                   /* xLock */
-    rbuVfsUnlock,                 /* xUnlock */
-    rbuVfsCheckReservedLock,      /* xCheckReservedLock */
-    rbuVfsFileControl,            /* xFileControl */
-    rbuVfsSectorSize,             /* xSectorSize */
-    rbuVfsDeviceCharacteristics,  /* xDeviceCharacteristics */
-    0, 0, 0, 0, 0, 0
-  };
-
-
-
-  rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
-  sqlite3_vfs *pRealVfs = pRbuVfs->pRealVfs;
-  rbu_file *pFd = (rbu_file *)pFile;
-  int rc = SQLITE_OK;
-  const char *zOpen = zName;
-  int oflags = flags;
-
-  memset(pFd, 0, sizeof(rbu_file));
-  pFd->pReal = (sqlite3_file*)&pFd[1];
-  pFd->pRbuVfs = pRbuVfs;
-  pFd->openFlags = flags;
-  if( zName ){
-    if( flags & SQLITE_OPEN_MAIN_DB ){
-      /* A main database has just been opened. The following block sets
-      ** (pFd->zWal) to point to a buffer owned by SQLite that contains
-      ** the name of the *-wal file this db connection will use. SQLite
-      ** happens to pass a pointer to this buffer when using xAccess()
-      ** or xOpen() to operate on the *-wal file.  */
-      pFd->zWal = sqlite3_filename_wal(zName);
-    }
-    else if( flags & SQLITE_OPEN_WAL ){
-      rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0);
-      if( pDb ){
-        if( pDb->pRbu && pDb->pRbu->eStage==RBU_STAGE_OAL ){
-          /* This call is to open a *-wal file. Intead, open the *-oal. */
-          size_t nOpen;
-          if( rbuIsVacuum(pDb->pRbu) ){
-            zOpen = sqlite3_db_filename(pDb->pRbu->dbRbu, "main");
-            zOpen = sqlite3_filename_wal(zOpen);
-          }
-          nOpen = strlen(zOpen);
-          ((char*)zOpen)[nOpen-3] = 'o';
-          pFd->pRbu = pDb->pRbu;
-        }
-        pDb->pWalFd = pFd;
-      }
-    }
-  }else{
-    pFd->pRbu = pRbuVfs->pRbu;
-  }
-
-  if( oflags & SQLITE_OPEN_MAIN_DB
-   && sqlite3_uri_boolean(zName, "rbu_memory", 0)
-  ){
-    assert( oflags & SQLITE_OPEN_MAIN_DB );
-    oflags =  SQLITE_OPEN_TEMP_DB | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
-              SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
-    zOpen = 0;
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = pRealVfs->xOpen(pRealVfs, zOpen, pFd->pReal, oflags, pOutFlags);
-  }
-  if( pFd->pReal->pMethods ){
-    const sqlite3_io_methods *pMeth = pFd->pReal->pMethods;
-    /* The xOpen() operation has succeeded. Set the sqlite3_file.pMethods
-    ** pointer and, if the file is a main database file, link it into the
-    ** mutex protected linked list of all such files.  */
-    if( pMeth->iVersion<2 || pMeth->xShmLock==0 ){
-      pFile->pMethods = &rbuvfs_io_methods1;
-    }else{
-      pFile->pMethods = &rbuvfs_io_methods;
-    }
-    if( flags & SQLITE_OPEN_MAIN_DB ){
-      rbuMainlistAdd(pFd);
-    }
-  }else{
-    sqlite3_free(pFd->zDel);
-  }
-
-  return rc;
-}
-
-/*
-** Delete the file located at zPath.
-*/
-static int rbuVfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
-  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
-  return pRealVfs->xDelete(pRealVfs, zPath, dirSync);
-}
-
-/*
-** Test for access permissions. Return true if the requested permission
-** is available, or false otherwise.
-*/
-static int rbuVfsAccess(
-  sqlite3_vfs *pVfs,
-  const char *zPath,
-  int flags,
-  int *pResOut
-){
-  rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
-  sqlite3_vfs *pRealVfs = pRbuVfs->pRealVfs;
-  int rc;
-
-  rc = pRealVfs->xAccess(pRealVfs, zPath, flags, pResOut);
-
-  /* If this call is to check if a *-wal file associated with an RBU target
-  ** database connection exists, and the RBU update is in RBU_STAGE_OAL,
-  ** the following special handling is activated:
-  **
-  **   a) if the *-wal file does exist, return SQLITE_CANTOPEN. This
-  **      ensures that the RBU extension never tries to update a database
-  **      in wal mode, even if the first page of the database file has
-  **      been damaged.
-  **
-  **   b) if the *-wal file does not exist, claim that it does anyway,
-  **      causing SQLite to call xOpen() to open it. This call will also
-  **      be intercepted (see the rbuVfsOpen() function) and the *-oal
-  **      file opened instead.
-  */
-  if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
-    rbu_file *pDb = rbuFindMaindb(pRbuVfs, zPath, 1);
-    if( pDb && pDb->pRbu->eStage==RBU_STAGE_OAL ){
-      assert( pDb->pRbu );
-      if( *pResOut ){
-        rc = SQLITE_CANTOPEN;
-      }else{
-        sqlite3_int64 sz = 0;
-        rc = rbuVfsFileSize(&pDb->base, &sz);
-        *pResOut = (sz>0);
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** 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 (DEVSYM_MAX_PATHNAME+1) bytes.
-*/
-static int rbuVfsFullPathname(
-  sqlite3_vfs *pVfs,
-  const char *zPath,
-  int nOut,
-  char *zOut
-){
-  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
-  return pRealVfs->xFullPathname(pRealVfs, zPath, nOut, zOut);
-}
-
-#ifndef SQLITE_OMIT_LOAD_EXTENSION
-/*
-** Open the dynamic library located at zPath and return a handle.
-*/
-static void *rbuVfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
-  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
-  return pRealVfs->xDlOpen(pRealVfs, 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 rbuVfsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
-  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
-  pRealVfs->xDlError(pRealVfs, nByte, zErrMsg);
-}
-
-/*
-** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
-*/
-static void (*rbuVfsDlSym(
-  sqlite3_vfs *pVfs,
-  void *pArg,
-  const char *zSym
-))(void){
-  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
-  return pRealVfs->xDlSym(pRealVfs, pArg, zSym);
-}
-
-/*
-** Close the dynamic library handle pHandle.
-*/
-static void rbuVfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
-  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
-  pRealVfs->xDlClose(pRealVfs, pHandle);
-}
-#endif /* SQLITE_OMIT_LOAD_EXTENSION */
-
-/*
-** Populate the buffer pointed to by zBufOut with nByte bytes of
-** random data.
-*/
-static int rbuVfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
-  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
-  return pRealVfs->xRandomness(pRealVfs, nByte, zBufOut);
-}
-
-/*
-** Sleep for nMicro microseconds. Return the number of microseconds
-** actually slept.
-*/
-static int rbuVfsSleep(sqlite3_vfs *pVfs, int nMicro){
-  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
-  return pRealVfs->xSleep(pRealVfs, nMicro);
-}
-
-/*
-** Return the current time as a Julian Day number in *pTimeOut.
-*/
-static int rbuVfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
-  sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
-  return pRealVfs->xCurrentTime(pRealVfs, pTimeOut);
-}
-
-/*
-** No-op.
-*/
-static int rbuVfsGetLastError(sqlite3_vfs *pVfs, int a, char *b){
-  UNUSED_PARAMETER(pVfs);
-  UNUSED_PARAMETER(a);
-  UNUSED_PARAMETER(b);
-  return 0;
-}
-
-/*
-** Deregister and destroy an RBU vfs created by an earlier call to
-** sqlite3rbu_create_vfs().
-*/
-SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName){
-  sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
-  if( pVfs && pVfs->xOpen==rbuVfsOpen ){
-    sqlite3_mutex_free(((rbu_vfs*)pVfs)->mutex);
-    sqlite3_vfs_unregister(pVfs);
-    sqlite3_free(pVfs);
-  }
-}
-
-/*
-** Create an RBU VFS named zName that accesses the underlying file-system
-** via existing VFS zParent. The new object is registered as a non-default
-** VFS with SQLite before returning.
-*/
-SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
-
-  /* Template for VFS */
-  static sqlite3_vfs vfs_template = {
-    1,                            /* iVersion */
-    0,                            /* szOsFile */
-    0,                            /* mxPathname */
-    0,                            /* pNext */
-    0,                            /* zName */
-    0,                            /* pAppData */
-    rbuVfsOpen,                   /* xOpen */
-    rbuVfsDelete,                 /* xDelete */
-    rbuVfsAccess,                 /* xAccess */
-    rbuVfsFullPathname,           /* xFullPathname */
-
-#ifndef SQLITE_OMIT_LOAD_EXTENSION
-    rbuVfsDlOpen,                 /* xDlOpen */
-    rbuVfsDlError,                /* xDlError */
-    rbuVfsDlSym,                  /* xDlSym */
-    rbuVfsDlClose,                /* xDlClose */
-#else
-    0, 0, 0, 0,
-#endif
-
-    rbuVfsRandomness,             /* xRandomness */
-    rbuVfsSleep,                  /* xSleep */
-    rbuVfsCurrentTime,            /* xCurrentTime */
-    rbuVfsGetLastError,           /* xGetLastError */
-    0,                            /* xCurrentTimeInt64 (version 2) */
-    0, 0, 0                       /* Unimplemented version 3 methods */
-  };
-
-  rbu_vfs *pNew = 0;              /* Newly allocated VFS */
-  int rc = SQLITE_OK;
-  size_t nName;
-  size_t nByte;
-
-  nName = strlen(zName);
-  nByte = sizeof(rbu_vfs) + nName + 1;
-  pNew = (rbu_vfs*)sqlite3_malloc64(nByte);
-  if( pNew==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    sqlite3_vfs *pParent;           /* Parent VFS */
-    memset(pNew, 0, nByte);
-    pParent = sqlite3_vfs_find(zParent);
-    if( pParent==0 ){
-      rc = SQLITE_NOTFOUND;
-    }else{
-      char *zSpace;
-      memcpy(&pNew->base, &vfs_template, sizeof(sqlite3_vfs));
-      pNew->base.mxPathname = pParent->mxPathname;
-      pNew->base.szOsFile = sizeof(rbu_file) + pParent->szOsFile;
-      pNew->pRealVfs = pParent;
-      pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
-      memcpy(zSpace, zName, nName);
-
-      /* Allocate the mutex and register the new VFS (not as the default) */
-      pNew->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
-      if( pNew->mutex==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        rc = sqlite3_vfs_register(&pNew->base, 0);
-      }
-    }
-
-    if( rc!=SQLITE_OK ){
-      sqlite3_mutex_free(pNew->mutex);
-      sqlite3_free(pNew);
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Configure the aggregate temp file size limit for this RBU handle.
-*/
-SQLITE_API sqlite3_int64 sqlite3rbu_temp_size_limit(sqlite3rbu *pRbu, sqlite3_int64 n){
-  if( n>=0 ){
-    pRbu->szTempLimit = n;
-  }
-  return pRbu->szTempLimit;
-}
-
-SQLITE_API sqlite3_int64 sqlite3rbu_temp_size(sqlite3rbu *pRbu){
-  return pRbu->szTemp;
-}
-
-
-/**************************************************************************/
-
-#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) */
-
-/************** End of sqlite3rbu.c ******************************************/
-/************** Begin file dbstat.c ******************************************/
-/*
-** 2010 July 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 an implementation of the "dbstat" virtual table.
-**
-** The dbstat virtual table is used to extract low-level storage
-** information from an SQLite database in order to implement the
-** "sqlite3_analyzer" utility.  See the ../tool/spaceanal.tcl script
-** for an example implementation.
-**
-** Additional information is available on the "dbstat.html" page of the
-** official SQLite documentation.
-*/
-
-/* #include "sqliteInt.h"   ** Requires access to internal data structures ** */
-#if (defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)) \
-    && !defined(SQLITE_OMIT_VIRTUALTABLE)
-
-/*
-** The pager and btree modules arrange objects in memory so that there are
-** always approximately 200 bytes of addressable memory following each page
-** buffer. This way small buffer overreads caused by corrupt database pages
-** do not cause undefined behaviour. This module pads each page buffer
-** by the following number of bytes for the same purpose.
-*/
-#define DBSTAT_PAGE_PADDING_BYTES 256
-
-/*
-** Page paths:
-**
-**   The value of the 'path' column describes the path taken from the
-**   root-node of the b-tree structure to each page. The value of the
-**   root-node path is '/'.
-**
-**   The value of the path for the left-most child page of the root of
-**   a b-tree is '/000/'. (Btrees store content ordered from left to right
-**   so the pages to the left have smaller keys than the pages to the right.)
-**   The next to left-most child of the root page is
-**   '/001', and so on, each sibling page identified by a 3-digit hex
-**   value. The children of the 451st left-most sibling have paths such
-**   as '/1c2/000/, '/1c2/001/' etc.
-**
-**   Overflow pages are specified by appending a '+' character and a
-**   six-digit hexadecimal value to the path to the cell they are linked
-**   from. For example, the three overflow pages in a chain linked from
-**   the left-most cell of the 450th child of the root page are identified
-**   by the paths:
-**
-**      '/1c2/000+000000'         // First page in overflow chain
-**      '/1c2/000+000001'         // Second page in overflow chain
-**      '/1c2/000+000002'         // Third page in overflow chain
-**
-**   If the paths are sorted using the BINARY collation sequence, then
-**   the overflow pages associated with a cell will appear earlier in the
-**   sort-order than its child page:
-**
-**      '/1c2/000/'               // Left-most child of 451st child of root
-*/
-static const char zDbstatSchema[] =
-  "CREATE TABLE x("
-  " name       TEXT,"          /*  0 Name of table or index */
-  " path       TEXT,"          /*  1 Path to page from root (NULL for agg) */
-  " pageno     INTEGER,"       /*  2 Page number (page count for aggregates) */
-  " pagetype   TEXT,"          /*  3 'internal', 'leaf', 'overflow', or NULL */
-  " ncell      INTEGER,"       /*  4 Cells on page (0 for overflow) */
-  " payload    INTEGER,"       /*  5 Bytes of payload on this page */
-  " unused     INTEGER,"       /*  6 Bytes of unused space on this page */
-  " mx_payload INTEGER,"       /*  7 Largest payload size of all cells */
-  " pgoffset   INTEGER,"       /*  8 Offset of page in file (NULL for agg) */
-  " pgsize     INTEGER,"       /*  9 Size of the page (sum for aggregate) */
-  " schema     TEXT HIDDEN,"   /* 10 Database schema being analyzed */
-  " aggregate  BOOLEAN HIDDEN" /* 11 aggregate info for each table */
-  ")"
-;
-
-/* Forward reference to data structured used in this module */
-typedef struct StatTable StatTable;
-typedef struct StatCursor StatCursor;
-typedef struct StatPage StatPage;
-typedef struct StatCell StatCell;
-
-/* Size information for a single cell within a btree page */
-struct StatCell {
-  int nLocal;                     /* Bytes of local payload */
-  u32 iChildPg;                   /* Child node (or 0 if this is a leaf) */
-  int nOvfl;                      /* Entries in aOvfl[] */
-  u32 *aOvfl;                     /* Array of overflow page numbers */
-  int nLastOvfl;                  /* Bytes of payload on final overflow page */
-  int iOvfl;                      /* Iterates through aOvfl[] */
-};
-
-/* Size information for a single btree page */
-struct StatPage {
-  u32 iPgno;                      /* Page number */
-  u8 *aPg;                        /* Page buffer from sqlite3_malloc() */
-  int iCell;                      /* Current cell */
-  char *zPath;                    /* Path to this page */
-
-  /* Variables populated by statDecodePage(): */
-  u8 flags;                       /* Copy of flags byte */
-  int nCell;                      /* Number of cells on page */
-  int nUnused;                    /* Number of unused bytes on page */
-  StatCell *aCell;                /* Array of parsed cells */
-  u32 iRightChildPg;              /* Right-child page number (or 0) */
-  int nMxPayload;                 /* Largest payload of any cell on the page */
-};
-
-/* The cursor for scanning the dbstat virtual table */
-struct StatCursor {
-  sqlite3_vtab_cursor base;       /* base class.  MUST BE FIRST! */
-  sqlite3_stmt *pStmt;            /* Iterates through set of root pages */
-  u8 isEof;                       /* After pStmt has returned SQLITE_DONE */
-  u8 isAgg;                       /* Aggregate results for each table */
-  int iDb;                        /* Schema used for this query */
-
-  StatPage aPage[32];             /* Pages in path to current page */
-  int iPage;                      /* Current entry in aPage[] */
-
-  /* Values to return. */
-  u32 iPageno;                    /* Value of 'pageno' column */
-  char *zName;                    /* Value of 'name' column */
-  char *zPath;                    /* Value of 'path' column */
-  char *zPagetype;                /* Value of 'pagetype' column */
-  int nPage;                      /* Number of pages in current btree */
-  int nCell;                      /* Value of 'ncell' column */
-  int nMxPayload;                 /* Value of 'mx_payload' column */
-  i64 nUnused;                    /* Value of 'unused' column */
-  i64 nPayload;                   /* Value of 'payload' column */
-  i64 iOffset;                    /* Value of 'pgOffset' column */
-  i64 szPage;                     /* Value of 'pgSize' column */
-};
-
-/* An instance of the DBSTAT virtual table */
-struct StatTable {
-  sqlite3_vtab base;              /* base class.  MUST BE FIRST! */
-  sqlite3 *db;                    /* Database connection that owns this vtab */
-  int iDb;                        /* Index of database to analyze */
-};
-
-#ifndef get2byte
-# define get2byte(x)   ((x)[0]<<8 | (x)[1])
-#endif
-
-/*
-** Connect to or create a new DBSTAT virtual table.
-*/
-static int statConnect(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  StatTable *pTab = 0;
-  int rc = SQLITE_OK;
-  int iDb;
-  (void)pAux;
-
-  if( argc>=4 ){
-    Token nm;
-    sqlite3TokenInit(&nm, (char*)argv[3]);
-    iDb = sqlite3FindDb(db, &nm);
-    if( iDb<0 ){
-      *pzErr = sqlite3_mprintf("no such database: %s", argv[3]);
-      return SQLITE_ERROR;
-    }
-  }else{
-    iDb = 0;
-  }
-  sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY);
-  rc = sqlite3_declare_vtab(db, zDbstatSchema);
-  if( rc==SQLITE_OK ){
-    pTab = (StatTable *)sqlite3_malloc64(sizeof(StatTable));
-    if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
-  }
-
-  assert( rc==SQLITE_OK || pTab==0 );
-  if( rc==SQLITE_OK ){
-    memset(pTab, 0, sizeof(StatTable));
-    pTab->db = db;
-    pTab->iDb = iDb;
-  }
-
-  *ppVtab = (sqlite3_vtab*)pTab;
-  return rc;
-}
-
-/*
-** Disconnect from or destroy the DBSTAT virtual table.
-*/
-static int statDisconnect(sqlite3_vtab *pVtab){
-  sqlite3_free(pVtab);
-  return SQLITE_OK;
-}
-
-/*
-** Compute the best query strategy and return the result in idxNum.
-**
-**   idxNum-Bit        Meaning
-**   ----------        ----------------------------------------------
-**      0x01           There is a schema=? term in the WHERE clause
-**      0x02           There is a name=? term in the WHERE clause
-**      0x04           There is an aggregate=? term in the WHERE clause
-**      0x08           Output should be ordered by name and path
-*/
-static int statBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
-  int i;
-  int iSchema = -1;
-  int iName = -1;
-  int iAgg = -1;
-  (void)tab;
-
-  /* Look for a valid schema=? constraint.  If found, change the idxNum to
-  ** 1 and request the value of that constraint be sent to xFilter.  And
-  ** lower the cost estimate to encourage the constrained version to be
-  ** used.
-  */
-  for(i=0; i<pIdxInfo->nConstraint; i++){
-    if( pIdxInfo->aConstraint[i].op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
-    if( pIdxInfo->aConstraint[i].usable==0 ){
-      /* Force DBSTAT table should always be the right-most table in a join */
-      return SQLITE_CONSTRAINT;
-    }
-    switch( pIdxInfo->aConstraint[i].iColumn ){
-      case 0: {    /* name */
-        iName = i;
-        break;
-      }
-      case 10: {   /* schema */
-        iSchema = i;
-        break;
-      }
-      case 11: {   /* aggregate */
-        iAgg = i;
-        break;
-      }
-    }
-  }
-  i = 0;
-  if( iSchema>=0 ){
-    pIdxInfo->aConstraintUsage[iSchema].argvIndex = ++i;
-    pIdxInfo->aConstraintUsage[iSchema].omit = 1;
-    pIdxInfo->idxNum |= 0x01;
-  }
-  if( iName>=0 ){
-    pIdxInfo->aConstraintUsage[iName].argvIndex = ++i;
-    pIdxInfo->idxNum |= 0x02;
-  }
-  if( iAgg>=0 ){
-    pIdxInfo->aConstraintUsage[iAgg].argvIndex = ++i;
-    pIdxInfo->idxNum |= 0x04;
-  }
-  pIdxInfo->estimatedCost = 1.0;
-
-  /* Records are always returned in ascending order of (name, path).
-  ** If this will satisfy the client, set the orderByConsumed flag so that
-  ** SQLite does not do an external sort.
-  */
-  if( ( pIdxInfo->nOrderBy==1
-     && pIdxInfo->aOrderBy[0].iColumn==0
-     && pIdxInfo->aOrderBy[0].desc==0
-     ) ||
-      ( pIdxInfo->nOrderBy==2
-     && pIdxInfo->aOrderBy[0].iColumn==0
-     && pIdxInfo->aOrderBy[0].desc==0
-     && pIdxInfo->aOrderBy[1].iColumn==1
-     && pIdxInfo->aOrderBy[1].desc==0
-     )
-  ){
-    pIdxInfo->orderByConsumed = 1;
-    pIdxInfo->idxNum |= 0x08;
-  }
-  pIdxInfo->idxFlags |= SQLITE_INDEX_SCAN_HEX;
-
-  return SQLITE_OK;
-}
-
-/*
-** Open a new DBSTAT cursor.
-*/
-static int statOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
-  StatTable *pTab = (StatTable *)pVTab;
-  StatCursor *pCsr;
-
-  pCsr = (StatCursor *)sqlite3_malloc64(sizeof(StatCursor));
-  if( pCsr==0 ){
-    return SQLITE_NOMEM_BKPT;
-  }else{
-    memset(pCsr, 0, sizeof(StatCursor));
-    pCsr->base.pVtab = pVTab;
-    pCsr->iDb = pTab->iDb;
-  }
-
-  *ppCursor = (sqlite3_vtab_cursor *)pCsr;
-  return SQLITE_OK;
-}
-
-static void statClearCells(StatPage *p){
-  int i;
-  if( p->aCell ){
-    for(i=0; i<p->nCell; i++){
-      sqlite3_free(p->aCell[i].aOvfl);
-    }
-    sqlite3_free(p->aCell);
-  }
-  p->nCell = 0;
-  p->aCell = 0;
-}
-
-static void statClearPage(StatPage *p){
-  u8 *aPg = p->aPg;
-  statClearCells(p);
-  sqlite3_free(p->zPath);
-  memset(p, 0, sizeof(StatPage));
-  p->aPg = aPg;
-}
-
-static void statResetCsr(StatCursor *pCsr){
-  int i;
-  /* In some circumstances, specifically if an OOM has occurred, the call
-  ** to sqlite3_reset() may cause the pager to be reset (emptied). It is
-  ** important that statClearPage() is called to free any page refs before
-  ** this happens. dbsqlfuzz 9ed3e4e3816219d3509d711636c38542bf3f40b1. */
-  for(i=0; i<ArraySize(pCsr->aPage); i++){
-    statClearPage(&pCsr->aPage[i]);
-    sqlite3_free(pCsr->aPage[i].aPg);
-    pCsr->aPage[i].aPg = 0;
-  }
-  sqlite3_reset(pCsr->pStmt);
-  pCsr->iPage = 0;
-  sqlite3_free(pCsr->zPath);
-  pCsr->zPath = 0;
-  pCsr->isEof = 0;
-}
-
-/* Resize the space-used counters inside of the cursor */
-static void statResetCounts(StatCursor *pCsr){
-  pCsr->nCell = 0;
-  pCsr->nMxPayload = 0;
-  pCsr->nUnused = 0;
-  pCsr->nPayload = 0;
-  pCsr->szPage = 0;
-  pCsr->nPage = 0;
-}
-
-/*
-** Close a DBSTAT cursor.
-*/
-static int statClose(sqlite3_vtab_cursor *pCursor){
-  StatCursor *pCsr = (StatCursor *)pCursor;
-  statResetCsr(pCsr);
-  sqlite3_finalize(pCsr->pStmt);
-  sqlite3_free(pCsr);
-  return SQLITE_OK;
-}
-
-/*
-** For a single cell on a btree page, compute the number of bytes of
-** content (payload) stored on that page.  That is to say, compute the
-** number of bytes of content not found on overflow pages.
-*/
-static int getLocalPayload(
-  int nUsable,                    /* Usable bytes per page */
-  u8 flags,                       /* Page flags */
-  int nTotal                      /* Total record (payload) size */
-){
-  int nLocal;
-  int nMinLocal;
-  int nMaxLocal;
-
-  if( flags==0x0D ){              /* Table leaf node */
-    nMinLocal = (nUsable - 12) * 32 / 255 - 23;
-    nMaxLocal = nUsable - 35;
-  }else{                          /* Index interior and leaf nodes */
-    nMinLocal = (nUsable - 12) * 32 / 255 - 23;
-    nMaxLocal = (nUsable - 12) * 64 / 255 - 23;
-  }
-
-  nLocal = nMinLocal + (nTotal - nMinLocal) % (nUsable - 4);
-  if( nLocal>nMaxLocal ) nLocal = nMinLocal;
-  return nLocal;
-}
-
-/* Populate the StatPage object with information about the all
-** cells found on the page currently under analysis.
-*/
-static int statDecodePage(Btree *pBt, StatPage *p){
-  int nUnused;
-  int iOff;
-  int nHdr;
-  int isLeaf;
-  int szPage;
-
-  u8 *aData = p->aPg;
-  u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
-
-  p->flags = aHdr[0];
-  if( p->flags==0x0A || p->flags==0x0D ){
-    isLeaf = 1;
-    nHdr = 8;
-  }else if( p->flags==0x05 || p->flags==0x02 ){
-    isLeaf = 0;
-    nHdr = 12;
-  }else{
-    goto statPageIsCorrupt;
-  }
-  if( p->iPgno==1 ) nHdr += 100;
-  p->nCell = get2byte(&aHdr[3]);
-  p->nMxPayload = 0;
-  szPage = sqlite3BtreeGetPageSize(pBt);
-
-  nUnused = get2byte(&aHdr[5]) - nHdr - 2*p->nCell;
-  nUnused += (int)aHdr[7];
-  iOff = get2byte(&aHdr[1]);
-  while( iOff ){
-    int iNext;
-    if( iOff>=szPage ) goto statPageIsCorrupt;
-    nUnused += get2byte(&aData[iOff+2]);
-    iNext = get2byte(&aData[iOff]);
-    if( iNext<iOff+4 && iNext>0 ) goto statPageIsCorrupt;
-    iOff = iNext;
-  }
-  p->nUnused = nUnused;
-  p->iRightChildPg = isLeaf ? 0 : sqlite3Get4byte(&aHdr[8]);
-
-  if( p->nCell ){
-    int i;                        /* Used to iterate through cells */
-    int nUsable;                  /* Usable bytes per page */
-
-    sqlite3BtreeEnter(pBt);
-    nUsable = szPage - sqlite3BtreeGetReserveNoMutex(pBt);
-    sqlite3BtreeLeave(pBt);
-    p->aCell = sqlite3_malloc64((p->nCell+1) * sizeof(StatCell));
-    if( p->aCell==0 ) return SQLITE_NOMEM_BKPT;
-    memset(p->aCell, 0, (p->nCell+1) * sizeof(StatCell));
-
-    for(i=0; i<p->nCell; i++){
-      StatCell *pCell = &p->aCell[i];
-
-      iOff = get2byte(&aData[nHdr+i*2]);
-      if( iOff<nHdr || iOff>=szPage ) goto statPageIsCorrupt;
-      if( !isLeaf ){
-        pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);
-        iOff += 4;
-      }
-      if( p->flags==0x05 ){
-        /* A table interior node. nPayload==0. */
-      }else{
-        u32 nPayload;             /* Bytes of payload total (local+overflow) */
-        int nLocal;               /* Bytes of payload stored locally */
-        iOff += getVarint32(&aData[iOff], nPayload);
-        if( p->flags==0x0D ){
-          u64 dummy;
-          iOff += sqlite3GetVarint(&aData[iOff], &dummy);
-        }
-        if( nPayload>(u32)p->nMxPayload ) p->nMxPayload = nPayload;
-        nLocal = getLocalPayload(nUsable, p->flags, nPayload);
-        if( nLocal<0 ) goto statPageIsCorrupt;
-        pCell->nLocal = nLocal;
-        assert( nPayload>=(u32)nLocal );
-        assert( nLocal<=(nUsable-35) );
-        if( nPayload>(u32)nLocal ){
-          int j;
-          int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4);
-          if( iOff+nLocal+4>nUsable || nPayload>0x7fffffff ){
-            goto statPageIsCorrupt;
-          }
-          pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);
-          pCell->nOvfl = nOvfl;
-          pCell->aOvfl = sqlite3_malloc64(sizeof(u32)*nOvfl);
-          if( pCell->aOvfl==0 ) return SQLITE_NOMEM_BKPT;
-          pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
-          for(j=1; j<nOvfl; j++){
-            int rc;
-            u32 iPrev = pCell->aOvfl[j-1];
-            DbPage *pPg = 0;
-            rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg, 0);
-            if( rc!=SQLITE_OK ){
-              assert( pPg==0 );
-              return rc;
-            }
-            pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg));
-            sqlite3PagerUnref(pPg);
-          }
-        }
-      }
-    }
-  }
-
-  return SQLITE_OK;
-
-statPageIsCorrupt:
-  p->flags = 0;
-  statClearCells(p);
-  return SQLITE_OK;
-}
-
-/*
-** Populate the pCsr->iOffset and pCsr->szPage member variables. Based on
-** the current value of pCsr->iPageno.
-*/
-static void statSizeAndOffset(StatCursor *pCsr){
-  StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
-  Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
-  Pager *pPager = sqlite3BtreePager(pBt);
-  sqlite3_file *fd;
-  sqlite3_int64 x[2];
-
-  /* If connected to a ZIPVFS backend, find the page size and
-  ** offset from ZIPVFS.
-  */
-  fd = sqlite3PagerFile(pPager);
-  x[0] = pCsr->iPageno;
-  if( sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){
-    pCsr->iOffset = x[0];
-    pCsr->szPage += x[1];
-  }else{
-    /* Not ZIPVFS: The default page size and offset */
-    pCsr->szPage += sqlite3BtreeGetPageSize(pBt);
-    pCsr->iOffset = (i64)pCsr->szPage * (pCsr->iPageno - 1);
-  }
-}
-
-/*
-** Load a copy of the page data for page iPg into the buffer belonging
-** to page object pPg. Allocate the buffer if necessary. Return SQLITE_OK
-** if successful, or an SQLite error code otherwise.
-*/
-static int statGetPage(
-  Btree *pBt,                     /* Load page from this b-tree */
-  u32 iPg,                        /* Page number to load */
-  StatPage *pPg                   /* Load page into this object */
-){
-  int pgsz = sqlite3BtreeGetPageSize(pBt);
-  DbPage *pDbPage = 0;
-  int rc;
-
-  if( pPg->aPg==0 ){
-    pPg->aPg = (u8*)sqlite3_malloc(pgsz + DBSTAT_PAGE_PADDING_BYTES);
-    if( pPg->aPg==0 ){
-      return SQLITE_NOMEM_BKPT;
-    }
-    memset(&pPg->aPg[pgsz], 0, DBSTAT_PAGE_PADDING_BYTES);
-  }
-
-  rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPg, &pDbPage, 0);
-  if( rc==SQLITE_OK ){
-    const u8 *a = sqlite3PagerGetData(pDbPage);
-    memcpy(pPg->aPg, a, pgsz);
-    sqlite3PagerUnref(pDbPage);
-  }
-
-  return rc;
-}
-
-/*
-** Move a DBSTAT cursor to the next entry.  Normally, the next
-** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
-** the next entry is the next btree.
-*/
-static int statNext(sqlite3_vtab_cursor *pCursor){
-  int rc;
-  int nPayload;
-  char *z;
-  StatCursor *pCsr = (StatCursor *)pCursor;
-  StatTable *pTab = (StatTable *)pCursor->pVtab;
-  Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
-  Pager *pPager = sqlite3BtreePager(pBt);
-
-  sqlite3_free(pCsr->zPath);
-  pCsr->zPath = 0;
-
-statNextRestart:
-  if( pCsr->iPage<0 ){
-    /* Start measuring space on the next btree */
-    statResetCounts(pCsr);
-    rc = sqlite3_step(pCsr->pStmt);
-    if( rc==SQLITE_ROW ){
-      int nPage;
-      u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
-      sqlite3PagerPagecount(pPager, &nPage);
-      if( nPage==0 ){
-        pCsr->isEof = 1;
-        return sqlite3_reset(pCsr->pStmt);
-      }
-      rc = statGetPage(pBt, iRoot, &pCsr->aPage[0]);
-      pCsr->aPage[0].iPgno = iRoot;
-      pCsr->aPage[0].iCell = 0;
-      if( !pCsr->isAgg ){
-        pCsr->aPage[0].zPath = z = sqlite3_mprintf("/");
-        if( z==0 ) rc = SQLITE_NOMEM_BKPT;
-      }
-      pCsr->iPage = 0;
-      pCsr->nPage = 1;
-    }else{
-      pCsr->isEof = 1;
-      return sqlite3_reset(pCsr->pStmt);
-    }
-  }else{
-    /* Continue analyzing the btree previously started */
-    StatPage *p = &pCsr->aPage[pCsr->iPage];
-    if( !pCsr->isAgg ) statResetCounts(pCsr);
-    while( p->iCell<p->nCell ){
-      StatCell *pCell = &p->aCell[p->iCell];
-      while( pCell->iOvfl<pCell->nOvfl ){
-        int nUsable, iOvfl;
-        sqlite3BtreeEnter(pBt);
-        nUsable = sqlite3BtreeGetPageSize(pBt) -
-                        sqlite3BtreeGetReserveNoMutex(pBt);
-        sqlite3BtreeLeave(pBt);
-        pCsr->nPage++;
-        statSizeAndOffset(pCsr);
-        if( pCell->iOvfl<pCell->nOvfl-1 ){
-          pCsr->nPayload += nUsable - 4;
-        }else{
-          pCsr->nPayload += pCell->nLastOvfl;
-          pCsr->nUnused += nUsable - 4 - pCell->nLastOvfl;
-        }
-        iOvfl = pCell->iOvfl;
-        pCell->iOvfl++;
-        if( !pCsr->isAgg ){
-          pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
-          pCsr->iPageno = pCell->aOvfl[iOvfl];
-          pCsr->zPagetype = "overflow";
-          pCsr->zPath = z = sqlite3_mprintf(
-              "%s%.3x+%.6x", p->zPath, p->iCell, iOvfl
-          );
-          return z==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK;
-        }
-      }
-      if( p->iRightChildPg ) break;
-      p->iCell++;
-    }
-
-    if( !p->iRightChildPg || p->iCell>p->nCell ){
-      statClearPage(p);
-      pCsr->iPage--;
-      if( pCsr->isAgg && pCsr->iPage<0 ){
-        /* label-statNext-done:  When computing aggregate space usage over
-        ** an entire btree, this is the exit point from this function */
-        return SQLITE_OK;
-      }
-      goto statNextRestart; /* Tail recursion */
-    }
-    pCsr->iPage++;
-    if( pCsr->iPage>=ArraySize(pCsr->aPage) ){
-      statResetCsr(pCsr);
-      return SQLITE_CORRUPT_BKPT;
-    }
-    assert( p==&pCsr->aPage[pCsr->iPage-1] );
-
-    if( p->iCell==p->nCell ){
-      p[1].iPgno = p->iRightChildPg;
-    }else{
-      p[1].iPgno = p->aCell[p->iCell].iChildPg;
-    }
-    rc = statGetPage(pBt, p[1].iPgno, &p[1]);
-    pCsr->nPage++;
-    p[1].iCell = 0;
-    if( !pCsr->isAgg ){
-      p[1].zPath = z = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell);
-      if( z==0 ) rc = SQLITE_NOMEM_BKPT;
-    }
-    p->iCell++;
-  }
-
-
-  /* Populate the StatCursor fields with the values to be returned
-  ** by the xColumn() and xRowid() methods.
-  */
-  if( rc==SQLITE_OK ){
-    int i;
-    StatPage *p = &pCsr->aPage[pCsr->iPage];
-    pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
-    pCsr->iPageno = p->iPgno;
-
-    rc = statDecodePage(pBt, p);
-    if( rc==SQLITE_OK ){
-      statSizeAndOffset(pCsr);
-
-      switch( p->flags ){
-        case 0x05:             /* table internal */
-        case 0x02:             /* index internal */
-          pCsr->zPagetype = "internal";
-          break;
-        case 0x0D:             /* table leaf */
-        case 0x0A:             /* index leaf */
-          pCsr->zPagetype = "leaf";
-          break;
-        default:
-          pCsr->zPagetype = "corrupted";
-          break;
-      }
-      pCsr->nCell += p->nCell;
-      pCsr->nUnused += p->nUnused;
-      if( p->nMxPayload>pCsr->nMxPayload ) pCsr->nMxPayload = p->nMxPayload;
-      if( !pCsr->isAgg ){
-        pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath);
-        if( z==0 ) rc = SQLITE_NOMEM_BKPT;
-      }
-      nPayload = 0;
-      for(i=0; i<p->nCell; i++){
-        nPayload += p->aCell[i].nLocal;
-      }
-      pCsr->nPayload += nPayload;
-
-      /* If computing aggregate space usage by btree, continue with the
-      ** next page.  The loop will exit via the return at label-statNext-done
-      */
-      if( pCsr->isAgg ) goto statNextRestart;
-    }
-  }
-
-  return rc;
-}
-
-static int statEof(sqlite3_vtab_cursor *pCursor){
-  StatCursor *pCsr = (StatCursor *)pCursor;
-  return pCsr->isEof;
-}
-
-/* Initialize a cursor according to the query plan idxNum using the
-** arguments in argv[0].  See statBestIndex() for a description of the
-** meaning of the bits in idxNum.
-*/
-static int statFilter(
-  sqlite3_vtab_cursor *pCursor,
-  int idxNum, const char *idxStr,
-  int argc, sqlite3_value **argv
-){
-  StatCursor *pCsr = (StatCursor *)pCursor;
-  StatTable *pTab = (StatTable*)(pCursor->pVtab);
-  sqlite3_str *pSql;      /* Query of btrees to analyze */
-  char *zSql;             /* String value of pSql */
-  int iArg = 0;           /* Count of argv[] parameters used so far */
-  int rc = SQLITE_OK;     /* Result of this operation */
-  const char *zName = 0;  /* Only provide analysis of this table */
-  (void)argc;
-  (void)idxStr;
-
-  statResetCsr(pCsr);
-  sqlite3_finalize(pCsr->pStmt);
-  pCsr->pStmt = 0;
-  if( idxNum & 0x01 ){
-    /* schema=? constraint is present.  Get its value */
-    const char *zDbase = (const char*)sqlite3_value_text(argv[iArg++]);
-    pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
-    if( pCsr->iDb<0 ){
-      pCsr->iDb = 0;
-      pCsr->isEof = 1;
-      return SQLITE_OK;
-    }
-  }else{
-    pCsr->iDb = pTab->iDb;
-  }
-  if( idxNum & 0x02 ){
-    /* name=? constraint is present */
-    zName = (const char*)sqlite3_value_text(argv[iArg++]);
-  }
-  if( idxNum & 0x04 ){
-    /* aggregate=? constraint is present */
-    pCsr->isAgg = sqlite3_value_double(argv[iArg++])!=0.0;
-  }else{
-    pCsr->isAgg = 0;
-  }
-  pSql = sqlite3_str_new(pTab->db);
-  sqlite3_str_appendf(pSql,
-      "SELECT * FROM ("
-        "SELECT 'sqlite_schema' AS name,1 AS rootpage,'table' AS type"
-        " UNION ALL "
-        "SELECT name,rootpage,type"
-        " FROM \"%w\".sqlite_schema WHERE rootpage!=0)",
-      pTab->db->aDb[pCsr->iDb].zDbSName);
-  if( zName ){
-    sqlite3_str_appendf(pSql, "WHERE name=%Q", zName);
-  }
-  if( idxNum & 0x08 ){
-    sqlite3_str_appendf(pSql, " ORDER BY name");
-  }
-  zSql = sqlite3_str_finish(pSql);
-  if( zSql==0 ){
-    return SQLITE_NOMEM_BKPT;
-  }else{
-    rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
-    sqlite3_free(zSql);
-  }
-
-  if( rc==SQLITE_OK ){
-    pCsr->iPage = -1;
-    rc = statNext(pCursor);
-  }
-  return rc;
-}
-
-static int statColumn(
-  sqlite3_vtab_cursor *pCursor,
-  sqlite3_context *ctx,
-  int i
-){
-  StatCursor *pCsr = (StatCursor *)pCursor;
-  switch( i ){
-    case 0:            /* name */
-      sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
-      break;
-    case 1:            /* path */
-      if( !pCsr->isAgg ){
-        sqlite3_result_text(ctx, pCsr->zPath, -1, SQLITE_TRANSIENT);
-      }
-      break;
-    case 2:            /* pageno */
-      if( pCsr->isAgg ){
-        sqlite3_result_int64(ctx, pCsr->nPage);
-      }else{
-        sqlite3_result_int64(ctx, pCsr->iPageno);
-      }
-      break;
-    case 3:            /* pagetype */
-      if( !pCsr->isAgg ){
-        sqlite3_result_text(ctx, pCsr->zPagetype, -1, SQLITE_STATIC);
-      }
-      break;
-    case 4:            /* ncell */
-      sqlite3_result_int64(ctx, pCsr->nCell);
-      break;
-    case 5:            /* payload */
-      sqlite3_result_int64(ctx, pCsr->nPayload);
-      break;
-    case 6:            /* unused */
-      sqlite3_result_int64(ctx, pCsr->nUnused);
-      break;
-    case 7:            /* mx_payload */
-      sqlite3_result_int64(ctx, pCsr->nMxPayload);
-      break;
-    case 8:            /* pgoffset */
-      if( !pCsr->isAgg ){
-        sqlite3_result_int64(ctx, pCsr->iOffset);
-      }
-      break;
-    case 9:            /* pgsize */
-      sqlite3_result_int64(ctx, pCsr->szPage);
-      break;
-    case 10: {         /* schema */
-      sqlite3 *db = sqlite3_context_db_handle(ctx);
-      int iDb = pCsr->iDb;
-      sqlite3_result_text(ctx, db->aDb[iDb].zDbSName, -1, SQLITE_STATIC);
-      break;
-    }
-    default: {         /* aggregate */
-      sqlite3_result_int(ctx, pCsr->isAgg);
-      break;
-    }
-  }
-  return SQLITE_OK;
-}
-
-static int statRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
-  StatCursor *pCsr = (StatCursor *)pCursor;
-  *pRowid = pCsr->iPageno;
-  return SQLITE_OK;
-}
-
-/*
-** Invoke this routine to register the "dbstat" virtual table module
-*/
-SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3 *db){
-  static sqlite3_module dbstat_module = {
-    0,                            /* iVersion */
-    statConnect,                  /* xCreate */
-    statConnect,                  /* xConnect */
-    statBestIndex,                /* xBestIndex */
-    statDisconnect,               /* xDisconnect */
-    statDisconnect,               /* xDestroy */
-    statOpen,                     /* xOpen - open a cursor */
-    statClose,                    /* xClose - close a cursor */
-    statFilter,                   /* xFilter - configure scan constraints */
-    statNext,                     /* xNext - advance a cursor */
-    statEof,                      /* xEof - check for end of scan */
-    statColumn,                   /* xColumn - read data */
-    statRowid,                    /* 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 */
-    0                             /* xIntegrity */
-  };
-  return sqlite3_create_module(db, "dbstat", &dbstat_module, 0);
-}
-#elif defined(SQLITE_ENABLE_DBSTAT_VTAB)
-SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3 *db){ return SQLITE_OK; }
-#endif /* SQLITE_ENABLE_DBSTAT_VTAB */
-
-/************** End of dbstat.c **********************************************/
-/************** Begin file dbpage.c ******************************************/
-/*
-** 2017-10-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 an implementation of the "sqlite_dbpage" virtual table.
-**
-** The sqlite_dbpage virtual table is used to read or write whole raw
-** pages of the database file.  The pager interface is used so that
-** uncommitted changes and changes recorded in the WAL file are correctly
-** retrieved.
-**
-** Usage example:
-**
-**    SELECT data FROM sqlite_dbpage('aux1') WHERE pgno=123;
-**
-** This is an eponymous virtual table so it does not need to be created before
-** use.  The optional argument to the sqlite_dbpage() table name is the
-** schema for the database file that is to be read.  The default schema is
-** "main".
-**
-** The data field of sqlite_dbpage table can be updated.  The new
-** value must be a BLOB which is the correct page size, otherwise the
-** update fails.  INSERT operations also work, and operate as if they
-** where REPLACE.  The size of the database can be extended by INSERT-ing
-** new pages on the end.
-**
-** Rows may not be deleted.  However, doing an INSERT to page number N
-** with NULL page data causes the N-th page and all subsequent pages to be
-** deleted and the database to be truncated.
-*/
-
-/* #include "sqliteInt.h"   ** Requires access to internal data structures ** */
-#if (defined(SQLITE_ENABLE_DBPAGE_VTAB) || defined(SQLITE_TEST)) \
-    && !defined(SQLITE_OMIT_VIRTUALTABLE)
-
-typedef struct DbpageTable DbpageTable;
-typedef struct DbpageCursor DbpageCursor;
-
-struct DbpageCursor {
-  sqlite3_vtab_cursor base;       /* Base class.  Must be first */
-  Pgno pgno;                      /* Current page number */
-  Pgno mxPgno;                    /* Last page to visit on this scan */
-  Pager *pPager;                  /* Pager being read/written */
-  DbPage *pPage1;                 /* Page 1 of the database */
-  int iDb;                        /* Index of database to analyze */
-  int szPage;                     /* Size of each page in bytes */
-};
-
-struct DbpageTable {
-  sqlite3_vtab base;              /* Base class.  Must be first */
-  sqlite3 *db;                    /* The database */
-  int iDbTrunc;                   /* Database to truncate */
-  Pgno pgnoTrunc;                 /* Size to truncate to */
-};
-
-/* Columns */
-#define DBPAGE_COLUMN_PGNO    0
-#define DBPAGE_COLUMN_DATA    1
-#define DBPAGE_COLUMN_SCHEMA  2
-
-
-/*
-** Connect to or create a dbpagevfs virtual table.
-*/
-static int dbpageConnect(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  DbpageTable *pTab = 0;
-  int rc = SQLITE_OK;
-  (void)pAux;
-  (void)argc;
-  (void)argv;
-  (void)pzErr;
-
-  sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY);
-  sqlite3_vtab_config(db, SQLITE_VTAB_USES_ALL_SCHEMAS);
-  rc = sqlite3_declare_vtab(db,
-          "CREATE TABLE x(pgno INTEGER PRIMARY KEY, data BLOB, schema HIDDEN)");
-  if( rc==SQLITE_OK ){
-    pTab = (DbpageTable *)sqlite3_malloc64(sizeof(DbpageTable));
-    if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
-  }
-
-  assert( rc==SQLITE_OK || pTab==0 );
-  if( rc==SQLITE_OK ){
-    memset(pTab, 0, sizeof(DbpageTable));
-    pTab->db = db;
-  }
-
-  *ppVtab = (sqlite3_vtab*)pTab;
-  return rc;
-}
-
-/*
-** Disconnect from or destroy a dbpagevfs virtual table.
-*/
-static int dbpageDisconnect(sqlite3_vtab *pVtab){
-  sqlite3_free(pVtab);
-  return SQLITE_OK;
-}
-
-/*
-** idxNum:
-**
-**     0     schema=main, full table scan
-**     1     schema=main, pgno=?1
-**     2     schema=?1, full table scan
-**     3     schema=?1, pgno=?2
-*/
-static int dbpageBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
-  int i;
-  int iPlan = 0;
-  (void)tab;
-
-  /* If there is a schema= constraint, it must be honored.  Report a
-  ** ridiculously large estimated cost if the schema= constraint is
-  ** unavailable
-  */
-  for(i=0; i<pIdxInfo->nConstraint; i++){
-    struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[i];
-    if( p->iColumn!=DBPAGE_COLUMN_SCHEMA ) continue;
-    if( p->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
-    if( !p->usable ){
-      /* No solution. */
-      return SQLITE_CONSTRAINT;
-    }
-    iPlan = 2;
-    pIdxInfo->aConstraintUsage[i].argvIndex = 1;
-    pIdxInfo->aConstraintUsage[i].omit = 1;
-    break;
-  }
-
-  /* If we reach this point, it means that either there is no schema=
-  ** constraint (in which case we use the "main" schema) or else the
-  ** schema constraint was accepted.  Lower the estimated cost accordingly
-  */
-  pIdxInfo->estimatedCost = 1.0e6;
-
-  /* Check for constraints against pgno */
-  for(i=0; i<pIdxInfo->nConstraint; i++){
-    struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[i];
-    if( p->usable && p->iColumn<=0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ ){
-      pIdxInfo->estimatedRows = 1;
-      pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_UNIQUE;
-      pIdxInfo->estimatedCost = 1.0;
-      pIdxInfo->aConstraintUsage[i].argvIndex = iPlan ? 2 : 1;
-      pIdxInfo->aConstraintUsage[i].omit = 1;
-      iPlan |= 1;
-      break;
-    }
-  }
-  pIdxInfo->idxNum = iPlan;
-
-  if( pIdxInfo->nOrderBy>=1
-   && pIdxInfo->aOrderBy[0].iColumn<=0
-   && pIdxInfo->aOrderBy[0].desc==0
-  ){
-    pIdxInfo->orderByConsumed = 1;
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Open a new dbpagevfs cursor.
-*/
-static int dbpageOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
-  DbpageCursor *pCsr;
-
-  pCsr = (DbpageCursor *)sqlite3_malloc64(sizeof(DbpageCursor));
-  if( pCsr==0 ){
-    return SQLITE_NOMEM_BKPT;
-  }else{
-    memset(pCsr, 0, sizeof(DbpageCursor));
-    pCsr->base.pVtab = pVTab;
-    pCsr->pgno = 0;
-  }
-
-  *ppCursor = (sqlite3_vtab_cursor *)pCsr;
-  return SQLITE_OK;
-}
-
-/*
-** Close a dbpagevfs cursor.
-*/
-static int dbpageClose(sqlite3_vtab_cursor *pCursor){
-  DbpageCursor *pCsr = (DbpageCursor *)pCursor;
-  if( pCsr->pPage1 ) sqlite3PagerUnrefPageOne(pCsr->pPage1);
-  sqlite3_free(pCsr);
-  return SQLITE_OK;
-}
-
-/*
-** Move a dbpagevfs cursor to the next entry in the file.
-*/
-static int dbpageNext(sqlite3_vtab_cursor *pCursor){
-  int rc = SQLITE_OK;
-  DbpageCursor *pCsr = (DbpageCursor *)pCursor;
-  pCsr->pgno++;
-  return rc;
-}
-
-static int dbpageEof(sqlite3_vtab_cursor *pCursor){
-  DbpageCursor *pCsr = (DbpageCursor *)pCursor;
-  return pCsr->pgno > pCsr->mxPgno;
-}
-
-/*
-** idxNum:
-**
-**     0     schema=main, full table scan
-**     1     schema=main, pgno=?1
-**     2     schema=?1, full table scan
-**     3     schema=?1, pgno=?2
-**
-** idxStr is not used
-*/
-static int dbpageFilter(
-  sqlite3_vtab_cursor *pCursor,
-  int idxNum, const char *idxStr,
-  int argc, sqlite3_value **argv
-){
-  DbpageCursor *pCsr = (DbpageCursor *)pCursor;
-  DbpageTable *pTab = (DbpageTable *)pCursor->pVtab;
-  int rc;
-  sqlite3 *db = pTab->db;
-  Btree *pBt;
-
-  UNUSED_PARAMETER(idxStr);
-  UNUSED_PARAMETER(argc);
-
-  /* Default setting is no rows of result */
-  pCsr->pgno = 1;
-  pCsr->mxPgno = 0;
-
-  if( idxNum & 2 ){
-    const char *zSchema;
-    assert( argc>=1 );
-    zSchema = (const char*)sqlite3_value_text(argv[0]);
-    pCsr->iDb = sqlite3FindDbName(db, zSchema);
-    if( pCsr->iDb<0 ) return SQLITE_OK;
-  }else{
-    pCsr->iDb = 0;
-  }
-  pBt = db->aDb[pCsr->iDb].pBt;
-  if( NEVER(pBt==0) ) return SQLITE_OK;
-  pCsr->pPager = sqlite3BtreePager(pBt);
-  pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
-  pCsr->mxPgno = sqlite3BtreeLastPage(pBt);
-  if( idxNum & 1 ){
-    assert( argc>(idxNum>>1) );
-    pCsr->pgno = sqlite3_value_int(argv[idxNum>>1]);
-    if( pCsr->pgno<1 || pCsr->pgno>pCsr->mxPgno ){
-      pCsr->pgno = 1;
-      pCsr->mxPgno = 0;
-    }else{
-      pCsr->mxPgno = pCsr->pgno;
-    }
-  }else{
-    assert( pCsr->pgno==1 );
-  }
-  if( pCsr->pPage1 ) sqlite3PagerUnrefPageOne(pCsr->pPage1);
-  rc = sqlite3PagerGet(pCsr->pPager, 1, &pCsr->pPage1, 0);
-  return rc;
-}
-
-static int dbpageColumn(
-  sqlite3_vtab_cursor *pCursor,
-  sqlite3_context *ctx,
-  int i
-){
-  DbpageCursor *pCsr = (DbpageCursor *)pCursor;
-  int rc = SQLITE_OK;
-  switch( i ){
-    case 0: {           /* pgno */
-      sqlite3_result_int64(ctx, (sqlite3_int64)pCsr->pgno);
-      break;
-    }
-    case 1: {           /* data */
-      DbPage *pDbPage = 0;
-      if( pCsr->pgno==(Pgno)((PENDING_BYTE/pCsr->szPage)+1) ){
-        /* The pending byte page. Assume it is zeroed out. Attempting to
-        ** request this page from the page is an SQLITE_CORRUPT error. */
-        sqlite3_result_zeroblob(ctx, pCsr->szPage);
-      }else{
-        rc = sqlite3PagerGet(pCsr->pPager, pCsr->pgno, (DbPage**)&pDbPage, 0);
-        if( rc==SQLITE_OK ){
-          sqlite3_result_blob(ctx, sqlite3PagerGetData(pDbPage), pCsr->szPage,
-              SQLITE_TRANSIENT);
-        }
-        sqlite3PagerUnref(pDbPage);
-      }
-      break;
-    }
-    default: {          /* schema */
-      sqlite3 *db = sqlite3_context_db_handle(ctx);
-      sqlite3_result_text(ctx, db->aDb[pCsr->iDb].zDbSName, -1, SQLITE_STATIC);
-      break;
-    }
-  }
-  return rc;
-}
-
-static int dbpageRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
-  DbpageCursor *pCsr = (DbpageCursor *)pCursor;
-  *pRowid = pCsr->pgno;
-  return SQLITE_OK;
-}
-
-/*
-** Open write transactions. Since we do not know in advance which database
-** files will be written by the sqlite_dbpage virtual table, start a write
-** transaction on them all.
-**
-** Return SQLITE_OK if successful, or an SQLite error code otherwise.
-*/
-static int dbpageBeginTrans(DbpageTable *pTab){
-  sqlite3 *db = pTab->db;
-  int rc = SQLITE_OK;
-  int i;
-  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
-    Btree *pBt = db->aDb[i].pBt;
-    if( pBt ) rc = sqlite3BtreeBeginTrans(pBt, 1, 0);
-  }
-  return rc;
-}
-
-static int dbpageUpdate(
-  sqlite3_vtab *pVtab,
-  int argc,
-  sqlite3_value **argv,
-  sqlite_int64 *pRowid
-){
-  DbpageTable *pTab = (DbpageTable *)pVtab;
-  Pgno pgno;
-  DbPage *pDbPage = 0;
-  int rc = SQLITE_OK;
-  char *zErr = 0;
-  int iDb;
-  Btree *pBt;
-  Pager *pPager;
-  int szPage;
-  int isInsert;
-
-  (void)pRowid;
-  if( pTab->db->flags & SQLITE_Defensive ){
-    zErr = "read-only";
-    goto update_fail;
-  }
-  if( argc==1 ){
-    zErr = "cannot delete";
-    goto update_fail;
-  }
-  if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
-    pgno = (Pgno)sqlite3_value_int64(argv[2]);
-    isInsert = 1;
-  }else{
-    pgno = (Pgno)sqlite3_value_int64(argv[0]);
-    if( (Pgno)sqlite3_value_int(argv[1])!=pgno ){
-      zErr = "cannot insert";
-      goto update_fail;
-    }
-    isInsert = 0;
-  }
-  if( sqlite3_value_type(argv[4])==SQLITE_NULL ){
-    iDb = 0;
-  }else{
-    const char *zSchema = (const char*)sqlite3_value_text(argv[4]);
-    iDb = sqlite3FindDbName(pTab->db, zSchema);
-    if( iDb<0 ){
-      zErr = "no such schema";
-      goto update_fail;
-    }
-  }
-  pBt = pTab->db->aDb[iDb].pBt;
-  if( pgno<1 || NEVER(pBt==0) ){
-    zErr = "bad page number";
-    goto update_fail;
-  }
-  szPage = sqlite3BtreeGetPageSize(pBt);
-  if( sqlite3_value_type(argv[3])!=SQLITE_BLOB
-   || sqlite3_value_bytes(argv[3])!=szPage
-  ){
-    if( sqlite3_value_type(argv[3])==SQLITE_NULL && isInsert && pgno>1 ){
-      /* "INSERT INTO dbpage($PGNO,NULL)" causes page number $PGNO and
-      ** all subsequent pages to be deleted. */
-      pTab->iDbTrunc = iDb;
-      pTab->pgnoTrunc = pgno-1;
-      pgno = 1;
-    }else{
-      zErr = "bad page value";
-      goto update_fail;
-    }
-  }
-
-  if( dbpageBeginTrans(pTab)!=SQLITE_OK ){
-    zErr = "failed to open transaction";
-    goto update_fail;
-  }
-
-  pPager = sqlite3BtreePager(pBt);
-  rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pDbPage, 0);
-  if( rc==SQLITE_OK ){
-    const void *pData = sqlite3_value_blob(argv[3]);
-    if( (rc = sqlite3PagerWrite(pDbPage))==SQLITE_OK && pData ){
-      unsigned char *aPage = sqlite3PagerGetData(pDbPage);
-      memcpy(aPage, pData, szPage);
-      pTab->pgnoTrunc = 0;
-    }
-  }
-  if( rc!=SQLITE_OK ){
-    pTab->pgnoTrunc = 0;
-  }
-  sqlite3PagerUnref(pDbPage);
-  return rc;
-
-update_fail:
-  pTab->pgnoTrunc = 0;
-  sqlite3_free(pVtab->zErrMsg);
-  pVtab->zErrMsg = sqlite3_mprintf("%s", zErr);
-  return SQLITE_ERROR;
-}
-
-static int dbpageBegin(sqlite3_vtab *pVtab){
-  DbpageTable *pTab = (DbpageTable *)pVtab;
-  pTab->pgnoTrunc = 0;
-  return SQLITE_OK;
-}
-
-/* Invoke sqlite3PagerTruncate() as necessary, just prior to COMMIT
-*/
-static int dbpageSync(sqlite3_vtab *pVtab){
-  DbpageTable *pTab = (DbpageTable *)pVtab;
-  if( pTab->pgnoTrunc>0 ){
-    Btree *pBt = pTab->db->aDb[pTab->iDbTrunc].pBt;
-    Pager *pPager = sqlite3BtreePager(pBt);
-    sqlite3BtreeEnter(pBt);
-    if( pTab->pgnoTrunc<sqlite3BtreeLastPage(pBt) ){
-      sqlite3PagerTruncateImage(pPager, pTab->pgnoTrunc);
-    }
-    sqlite3BtreeLeave(pBt);
-  }
-  pTab->pgnoTrunc = 0;
-  return SQLITE_OK;
-}
-
-/* Cancel any pending truncate.
-*/
-static int dbpageRollbackTo(sqlite3_vtab *pVtab, int notUsed1){
-  DbpageTable *pTab = (DbpageTable *)pVtab;
-  pTab->pgnoTrunc = 0;
-  (void)notUsed1;
-  return SQLITE_OK;
-}
-
-/*
-** Invoke this routine to register the "dbpage" virtual table module
-*/
-SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3 *db){
-  static sqlite3_module dbpage_module = {
-    2,                            /* iVersion */
-    dbpageConnect,                /* xCreate */
-    dbpageConnect,                /* xConnect */
-    dbpageBestIndex,              /* xBestIndex */
-    dbpageDisconnect,             /* xDisconnect */
-    dbpageDisconnect,             /* xDestroy */
-    dbpageOpen,                   /* xOpen - open a cursor */
-    dbpageClose,                  /* xClose - close a cursor */
-    dbpageFilter,                 /* xFilter - configure scan constraints */
-    dbpageNext,                   /* xNext - advance a cursor */
-    dbpageEof,                    /* xEof - check for end of scan */
-    dbpageColumn,                 /* xColumn - read data */
-    dbpageRowid,                  /* xRowid - read data */
-    dbpageUpdate,                 /* xUpdate */
-    dbpageBegin,                  /* xBegin */
-    dbpageSync,                   /* xSync */
-    0,                            /* xCommit */
-    0,                            /* xRollback */
-    0,                            /* xFindMethod */
-    0,                            /* xRename */
-    0,                            /* xSavepoint */
-    0,                            /* xRelease */
-    dbpageRollbackTo,             /* xRollbackTo */
-    0,                            /* xShadowName */
-    0                             /* xIntegrity */
-  };
-  return sqlite3_create_module(db, "sqlite_dbpage", &dbpage_module, 0);
-}
-#elif defined(SQLITE_ENABLE_DBPAGE_VTAB)
-SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3 *db){ return SQLITE_OK; }
-#endif /* SQLITE_ENABLE_DBSTAT_VTAB */
-
-/************** End of dbpage.c **********************************************/
-/************** Begin file carray.c ******************************************/
-/*
-** 2016-06-29
-**
-** 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 table-valued-function that
-** returns the values in a C-language array.
-** Examples:
-**
-**      SELECT * FROM carray($ptr,5)
-**
-** The query above returns 5 integers contained in a C-language array
-** at the address $ptr.  $ptr is a pointer to the array of integers.
-** The pointer value must be assigned to $ptr using the
-** sqlite3_bind_pointer() interface with a pointer type of "carray".
-** For example:
-**
-**    static int aX[] = { 53, 9, 17, 2231, 4, 99 };
-**    int i = sqlite3_bind_parameter_index(pStmt, "$ptr");
-**    sqlite3_bind_pointer(pStmt, i, aX, "carray", 0);
-**
-** There is an optional third parameter to determine the datatype of
-** the C-language array.  Allowed values of the third parameter are
-** 'int32', 'int64', 'double', 'char*', 'struct iovec'.  Example:
-**
-**      SELECT * FROM carray($ptr,10,'char*');
-**
-** The default value of the third parameter is 'int32'.
-**
-** HOW IT WORKS
-**
-** The carray "function" is really a virtual table with the
-** following schema:
-**
-**     CREATE TABLE carray(
-**       value,
-**       pointer HIDDEN,
-**       count HIDDEN,
-**       ctype TEXT HIDDEN
-**     );
-**
-** If the hidden columns "pointer" and "count" are unconstrained, then
-** the virtual table has no rows.  Otherwise, the virtual table interprets
-** the integer value of "pointer" as a pointer to the array and "count"
-** as the number of elements in the array.  The virtual table steps through
-** the array, element by element.
-*/
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_CARRAY)
-/* #include "sqliteInt.h" */
-#if defined(_WIN32) || defined(__RTP__) || defined(_WRS_KERNEL)
-  struct iovec {
-    void *iov_base;
-    size_t iov_len;
-  };
-#else
-# include <sys/uio.h>
-#endif
-
-/*
-** Names of allowed datatypes
-*/
-static const char *azCarrayType[] = {
-  "int32", "int64", "double", "char*", "struct iovec"
-};
-
-/*
-** Structure used to hold the sqlite3_carray_bind() information
-*/
-typedef struct carray_bind carray_bind;
-struct carray_bind {
-  void *aData;                /* The data */
-  int nData;                  /* Number of elements */
-  int mFlags;                 /* Control flags */
-  void (*xDel)(void*);        /* Destructor for aData */
-  void *pDel;                 /* Alternative argument to xDel() */
-};
-
-
-/* carray_cursor is a subclass of sqlite3_vtab_cursor which will
-** serve as the underlying representation of a cursor that scans
-** over rows of the result
-*/
-typedef struct carray_cursor carray_cursor;
-struct carray_cursor {
-  sqlite3_vtab_cursor base;  /* Base class - must be first */
-  sqlite3_int64 iRowid;      /* The rowid */
-  void *pPtr;                /* Pointer to the array of values */
-  sqlite3_int64 iCnt;        /* Number of integers in the array */
-  unsigned char eType;       /* One of the CARRAY_type values */
-};
-
-/*
-** The carrayConnect() method is invoked to create a new
-** carray_vtab that describes the carray virtual table.
-**
-** Think of this routine as the constructor for carray_vtab objects.
-**
-** All this routine needs to do is:
-**
-**    (1) Allocate the carray_vtab object and initialize all fields.
-**
-**    (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
-**        result set of queries against carray will look like.
-*/
-static int carrayConnect(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  sqlite3_vtab *pNew;
-  int rc;
-
-/* Column numbers */
-#define CARRAY_COLUMN_VALUE   0
-#define CARRAY_COLUMN_POINTER 1
-#define CARRAY_COLUMN_COUNT   2
-#define CARRAY_COLUMN_CTYPE   3
-
-  rc = sqlite3_declare_vtab(db,
-     "CREATE TABLE x(value,pointer hidden,count hidden,ctype hidden)");
-  if( rc==SQLITE_OK ){
-    pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) );
-    if( pNew==0 ) return SQLITE_NOMEM;
-    memset(pNew, 0, sizeof(*pNew));
-  }
-  return rc;
-}
-
-/*
-** This method is the destructor for carray_cursor objects.
-*/
-static int carrayDisconnect(sqlite3_vtab *pVtab){
-  sqlite3_free(pVtab);
-  return SQLITE_OK;
-}
-
-/*
-** Constructor for a new carray_cursor object.
-*/
-static int carrayOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
-  carray_cursor *pCur;
-  pCur = sqlite3_malloc( sizeof(*pCur) );
-  if( pCur==0 ) return SQLITE_NOMEM;
-  memset(pCur, 0, sizeof(*pCur));
-  *ppCursor = &pCur->base;
-  return SQLITE_OK;
-}
-
-/*
-** Destructor for a carray_cursor.
-*/
-static int carrayClose(sqlite3_vtab_cursor *cur){
-  sqlite3_free(cur);
-  return SQLITE_OK;
-}
-
-
-/*
-** Advance a carray_cursor to its next row of output.
-*/
-static int carrayNext(sqlite3_vtab_cursor *cur){
-  carray_cursor *pCur = (carray_cursor*)cur;
-  pCur->iRowid++;
-  return SQLITE_OK;
-}
-
-/*
-** Return values of columns for the row at which the carray_cursor
-** is currently pointing.
-*/
-static int carrayColumn(
-  sqlite3_vtab_cursor *cur,   /* The cursor */
-  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */
-  int i                       /* Which column to return */
-){
-  carray_cursor *pCur = (carray_cursor*)cur;
-  sqlite3_int64 x = 0;
-  switch( i ){
-    case CARRAY_COLUMN_POINTER:   return SQLITE_OK;
-    case CARRAY_COLUMN_COUNT:     x = pCur->iCnt;   break;
-    case CARRAY_COLUMN_CTYPE: {
-      sqlite3_result_text(ctx, azCarrayType[pCur->eType], -1, SQLITE_STATIC);
-      return SQLITE_OK;
-    }
-    default: {
-      switch( pCur->eType ){
-        case CARRAY_INT32: {
-          int *p = (int*)pCur->pPtr;
-          sqlite3_result_int(ctx, p[pCur->iRowid-1]);
-          return SQLITE_OK;
-        }
-        case CARRAY_INT64: {
-          sqlite3_int64 *p = (sqlite3_int64*)pCur->pPtr;
-          sqlite3_result_int64(ctx, p[pCur->iRowid-1]);
-          return SQLITE_OK;
-        }
-        case CARRAY_DOUBLE: {
-          double *p = (double*)pCur->pPtr;
-          sqlite3_result_double(ctx, p[pCur->iRowid-1]);
-          return SQLITE_OK;
-        }
-        case CARRAY_TEXT: {
-          const char **p = (const char**)pCur->pPtr;
-          sqlite3_result_text(ctx, p[pCur->iRowid-1], -1, SQLITE_TRANSIENT);
-          return SQLITE_OK;
-        }
-        default: {
-          const struct iovec *p = (struct iovec*)pCur->pPtr;
-          assert( pCur->eType==CARRAY_BLOB );
-          sqlite3_result_blob(ctx, p[pCur->iRowid-1].iov_base,
-                              (int)p[pCur->iRowid-1].iov_len, SQLITE_TRANSIENT);
-          return SQLITE_OK;
-        }
-      }
-    }
-  }
-  sqlite3_result_int64(ctx, x);
-  return SQLITE_OK;
-}
-
-/*
-** Return the rowid for the current row.  In this implementation, the
-** rowid is the same as the output value.
-*/
-static int carrayRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
-  carray_cursor *pCur = (carray_cursor*)cur;
-  *pRowid = pCur->iRowid;
-  return SQLITE_OK;
-}
-
-/*
-** Return TRUE if the cursor has been moved off of the last
-** row of output.
-*/
-static int carrayEof(sqlite3_vtab_cursor *cur){
-  carray_cursor *pCur = (carray_cursor*)cur;
-  return pCur->iRowid>pCur->iCnt;
-}
-
-/*
-** This method is called to "rewind" the carray_cursor object back
-** to the first row of output.
-*/
-static int carrayFilter(
-  sqlite3_vtab_cursor *pVtabCursor,
-  int idxNum, const char *idxStr,
-  int argc, sqlite3_value **argv
-){
-  carray_cursor *pCur = (carray_cursor *)pVtabCursor;
-  pCur->pPtr = 0;
-  pCur->iCnt = 0;
-  switch( idxNum ){
-    case 1: {
-      carray_bind *pBind = sqlite3_value_pointer(argv[0], "carray-bind");
-      if( pBind==0 ) break;
-      pCur->pPtr = pBind->aData;
-      pCur->iCnt = pBind->nData;
-      pCur->eType = pBind->mFlags & 0x07;
-      break;
-    }
-    case 2:
-    case 3: {
-      pCur->pPtr = sqlite3_value_pointer(argv[0], "carray");
-      pCur->iCnt = pCur->pPtr ? sqlite3_value_int64(argv[1]) : 0;
-      if( idxNum<3 ){
-        pCur->eType = CARRAY_INT32;
-      }else{
-        unsigned char i;
-        const char *zType = (const char*)sqlite3_value_text(argv[2]);
-        for(i=0; i<sizeof(azCarrayType)/sizeof(azCarrayType[0]); i++){
-          if( sqlite3_stricmp(zType, azCarrayType[i])==0 ) break;
-        }
-        if( i>=sizeof(azCarrayType)/sizeof(azCarrayType[0]) ){
-          pVtabCursor->pVtab->zErrMsg = sqlite3_mprintf(
-            "unknown datatype: %Q", zType);
-          return SQLITE_ERROR;
-        }else{
-          pCur->eType = i;
-        }
-      }
-      break;
-    }
-  }
-  pCur->iRowid = 1;
-  return SQLITE_OK;
-}
-
-/*
-** SQLite will invoke this method one or more times while planning a query
-** that uses the carray virtual table.  This routine needs to create
-** a query plan for each invocation and compute an estimated cost for that
-** plan.
-**
-** In this implementation idxNum is used to represent the
-** query plan.  idxStr is unused.
-**
-** idxNum is:
-**
-**    1    If only the pointer= constraint exists.  In this case, the
-**         parameter must be bound using sqlite3_carray_bind().
-**
-**    2    if the pointer= and count= constraints exist.
-**
-**    3    if the ctype= constraint also exists.
-**
-** idxNum is 0 otherwise and carray becomes an empty table.
-*/
-static int carrayBestIndex(
-  sqlite3_vtab *tab,
-  sqlite3_index_info *pIdxInfo
-){
-  int i;                 /* Loop over constraints */
-  int ptrIdx = -1;       /* Index of the pointer= constraint, or -1 if none */
-  int cntIdx = -1;       /* Index of the count= constraint, or -1 if none */
-  int ctypeIdx = -1;     /* Index of the ctype= constraint, or -1 if none */
-  unsigned seen = 0;     /* Bitmask of == constrainted columns */
-
-  const struct sqlite3_index_constraint *pConstraint;
-  pConstraint = pIdxInfo->aConstraint;
-  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
-    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
-    if( pConstraint->iColumn>=0 ) seen |= 1 << pConstraint->iColumn;
-    if( pConstraint->usable==0 ) continue;
-    switch( pConstraint->iColumn ){
-      case CARRAY_COLUMN_POINTER:
-        ptrIdx = i;
-        break;
-      case CARRAY_COLUMN_COUNT:
-        cntIdx = i;
-        break;
-      case CARRAY_COLUMN_CTYPE:
-        ctypeIdx = i;
-        break;
-    }
-  }
-  if( ptrIdx>=0 ){
-    pIdxInfo->aConstraintUsage[ptrIdx].argvIndex = 1;
-    pIdxInfo->aConstraintUsage[ptrIdx].omit = 1;
-    pIdxInfo->estimatedCost = (double)1;
-    pIdxInfo->estimatedRows = 100;
-    pIdxInfo->idxNum = 1;
-    if( cntIdx>=0 ){
-      pIdxInfo->aConstraintUsage[cntIdx].argvIndex = 2;
-      pIdxInfo->aConstraintUsage[cntIdx].omit = 1;
-      pIdxInfo->idxNum = 2;
-      if( ctypeIdx>=0 ){
-        pIdxInfo->aConstraintUsage[ctypeIdx].argvIndex = 3;
-        pIdxInfo->aConstraintUsage[ctypeIdx].omit = 1;
-        pIdxInfo->idxNum = 3;
-      }else if( seen & (1<<CARRAY_COLUMN_CTYPE) ){
-        /* In a three-argument carray(), we need to know the value of all
-        ** three arguments */
-        return SQLITE_CONSTRAINT;
-      }
-    }else if( seen & (1<<CARRAY_COLUMN_COUNT) ){
-      /* In a two-argument carray(), we need to know the value of both
-      ** arguments */
-      return SQLITE_CONSTRAINT;
-    }
-  }else{
-    pIdxInfo->estimatedCost = (double)2147483647;
-    pIdxInfo->estimatedRows = 2147483647;
-    pIdxInfo->idxNum = 0;
-  }
-  return SQLITE_OK;
-}
-
-/*
-** This following structure defines all the methods for the
-** carray virtual table.
-*/
-static sqlite3_module carrayModule = {
-  0,                         /* iVersion */
-  0,                         /* xCreate */
-  carrayConnect,             /* xConnect */
-  carrayBestIndex,           /* xBestIndex */
-  carrayDisconnect,          /* xDisconnect */
-  0,                         /* xDestroy */
-  carrayOpen,                /* xOpen - open a cursor */
-  carrayClose,               /* xClose - close a cursor */
-  carrayFilter,              /* xFilter - configure scan constraints */
-  carrayNext,                /* xNext - advance a cursor */
-  carrayEof,                 /* xEof - check for end of scan */
-  carrayColumn,              /* xColumn - read data */
-  carrayRowid,               /* xRowid - read data */
-  0,                         /* xUpdate */
-  0,                         /* xBegin */
-  0,                         /* xSync */
-  0,                         /* xCommit */
-  0,                         /* xRollback */
-  0,                         /* xFindMethod */
-  0,                         /* xRename */
-  0,                         /* xSavepoint */
-  0,                         /* xRelease */
-  0,                         /* xRollbackTo */
-  0,                         /* xShadow */
-  0                          /* xIntegrity */
-};
-
-/*
-** Destructor for the carray_bind object
-*/
-static void carrayBindDel(void *pPtr){
-  carray_bind *p = (carray_bind*)pPtr;
-  if( p->xDel!=SQLITE_STATIC ){
-    p->xDel(p->pDel);
-  }
-  sqlite3_free(p);
-}
-
-/*
-** Invoke this interface in order to bind to the single-argument
-** version of CARRAY().
-**
-**    pStmt        The prepared statement to which to bind
-**    idx          The index of the parameter of pStmt to which to bind
-**    aData        The data to be bound
-**    nData        The number of elements in aData
-**    mFlags       One of SQLITE_CARRAY_xxxx indicating datatype of aData
-**    xDestroy     Destructor for pDestroy or aData if pDestroy==NULL.
-**    pDestroy     Invoke xDestroy on this pointer if not NULL
-**
-** The destructor is called pDestroy if pDestroy!=NULL, or against
-** aData if pDestroy==NULL.
-*/
-SQLITE_API int sqlite3_carray_bind_v2(
-  sqlite3_stmt *pStmt,
-  int idx,
-  void *aData,
-  int nData,
-  int mFlags,
-  void (*xDestroy)(void*),
-  void *pDestroy
-){
-  carray_bind *pNew = 0;
-  int i;
-  int rc = SQLITE_OK;
-
-  /* Ensure that the mFlags value is acceptable. */
-  assert( CARRAY_INT32==0 && CARRAY_INT64==1 && CARRAY_DOUBLE==2 );
-  assert( CARRAY_TEXT==3 && CARRAY_BLOB==4 );
-  if( mFlags<CARRAY_INT32 || mFlags>CARRAY_BLOB ){
-    rc = SQLITE_ERROR;
-    goto carray_bind_error;
-  }
-
-  pNew = sqlite3_malloc64(sizeof(*pNew));
-  if( pNew==0 ){
-    rc = SQLITE_NOMEM;
-    goto carray_bind_error;
-  }
-
-  pNew->nData = nData;
-  pNew->mFlags = mFlags;
-  if( xDestroy==SQLITE_TRANSIENT ){
-    sqlite3_int64 sz = nData;
-    switch( mFlags ){
-      case CARRAY_INT32:   sz *= 4;                     break;
-      case CARRAY_INT64:   sz *= 8;                     break;
-      case CARRAY_DOUBLE:  sz *= 8;                     break;
-      case CARRAY_TEXT:    sz *= sizeof(char*);         break;
-      default:             sz *= sizeof(struct iovec);  break;
-    }
-    if( mFlags==CARRAY_TEXT ){
-      for(i=0; i<nData; i++){
-        const char *z = ((char**)aData)[i];
-        if( z ) sz += strlen(z) + 1;
-      }
-    }else if( mFlags==CARRAY_BLOB ){
-      for(i=0; i<nData; i++){
-        sz += ((struct iovec*)aData)[i].iov_len;
-      }
-    }
-
-    pNew->aData = sqlite3_malloc64( sz );
-    if( pNew->aData==0 ){
-      rc = SQLITE_NOMEM;
-      goto carray_bind_error;
-    }
-
-    if( mFlags==CARRAY_TEXT ){
-      char **az = (char**)pNew->aData;
-      char *z = (char*)&az[nData];
-      for(i=0; i<nData; i++){
-        const char *zData = ((char**)aData)[i];
-        sqlite3_int64 n;
-        if( zData==0 ){
-          az[i] = 0;
-          continue;
-        }
-        az[i] = z;
-        n = strlen(zData);
-        memcpy(z, zData, n+1);
-        z += n+1;
-      }
-    }else if( mFlags==CARRAY_BLOB ){
-      struct iovec *p = (struct iovec*)pNew->aData;
-      unsigned char *z = (unsigned char*)&p[nData];
-      for(i=0; i<nData; i++){
-        size_t n = ((struct iovec*)aData)[i].iov_len;
-        p[i].iov_len = n;
-        p[i].iov_base = z;
-        z += n;
-        memcpy(p[i].iov_base, ((struct iovec*)aData)[i].iov_base, n);
-      }
-    }else{
-      memcpy(pNew->aData, aData, sz);
-    }
-    pNew->xDel = sqlite3_free;
-    pNew->pDel = pNew->aData;
-  }else{
-    pNew->aData = aData;
-    pNew->xDel = xDestroy;
-    pNew->pDel = pDestroy;
-  }
-  return sqlite3_bind_pointer(pStmt, idx, pNew, "carray-bind", carrayBindDel);
-
- carray_bind_error:
-  if( xDestroy!=SQLITE_STATIC && xDestroy!=SQLITE_TRANSIENT ){
-    xDestroy(pDestroy);
-  }
-  sqlite3_free(pNew);
-  return rc;
-}
-
-/*
-** Invoke this interface in order to bind to the single-argument
-** version of CARRAY().  Same as sqlite3_carray_bind_v2() with the
-** pDestroy parameter set to NULL.
-*/
-SQLITE_API int sqlite3_carray_bind(
-  sqlite3_stmt *pStmt,
-  int idx,
-  void *aData,
-  int nData,
-  int mFlags,
-  void (*xDestroy)(void*)
-){
-  return sqlite3_carray_bind_v2(pStmt,idx,aData,nData,mFlags,xDestroy,aData);
-}
-
-/*
-** Invoke this routine to register the carray() function.
-*/
-SQLITE_PRIVATE Module *sqlite3CarrayRegister(sqlite3 *db){
-  return sqlite3VtabCreateModule(db, "carray", &carrayModule, 0, 0);
-}
-
-#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_CARRAY) */
-
-/************** End of carray.c **********************************************/
-/************** Begin file sqlite3session.c **********************************/
-
-#if defined(SQLITE_ENABLE_SESSION) && defined(SQLITE_ENABLE_PREUPDATE_HOOK)
-/* #include "sqlite3session.h" */
-/* #include <assert.h> */
-/* #include <string.h> */
-
-#ifndef SQLITE_AMALGAMATION
-/* # include "sqliteInt.h" */
-/* # include "vdbeInt.h" */
-#endif
-
-typedef struct SessionTable SessionTable;
-typedef struct SessionChange SessionChange;
-typedef struct SessionBuffer SessionBuffer;
-typedef struct SessionInput SessionInput;
-
-/*
-** Minimum chunk size used by streaming versions of functions.
-*/
-#ifndef SESSIONS_STRM_CHUNK_SIZE
-# ifdef SQLITE_TEST
-#   define SESSIONS_STRM_CHUNK_SIZE 64
-# else
-#   define SESSIONS_STRM_CHUNK_SIZE 1024
-# endif
-#endif
-
-#define SESSIONS_ROWID "_rowid_"
-
-static int sessions_strm_chunk_size = SESSIONS_STRM_CHUNK_SIZE;
-
-typedef struct SessionHook SessionHook;
-struct SessionHook {
-  void *pCtx;
-  int (*xOld)(void*,int,sqlite3_value**);
-  int (*xNew)(void*,int,sqlite3_value**);
-  int (*xCount)(void*);
-  int (*xDepth)(void*);
-};
-
-/*
-** Session handle structure.
-*/
-struct sqlite3_session {
-  sqlite3 *db;                    /* Database handle session is attached to */
-  char *zDb;                      /* Name of database session is attached to */
-  int bEnableSize;                /* True if changeset_size() enabled */
-  int bEnable;                    /* True if currently recording */
-  int bIndirect;                  /* True if all changes are indirect */
-  int bAutoAttach;                /* True to auto-attach tables */
-  int bImplicitPK;                /* True to handle tables with implicit PK */
-  int rc;                         /* Non-zero if an error has occurred */
-  void *pFilterCtx;               /* First argument to pass to xTableFilter */
-  int (*xTableFilter)(void *pCtx, const char *zTab);
-  i64 nMalloc;                    /* Number of bytes of data allocated */
-  i64 nMaxChangesetSize;
-  sqlite3_value *pZeroBlob;       /* Value containing X'' */
-  sqlite3_session *pNext;         /* Next session object on same db. */
-  SessionTable *pTable;           /* List of attached tables */
-  SessionHook hook;               /* APIs to grab new and old data with */
-};
-
-/*
-** Instances of this structure are used to build strings or binary records.
-*/
-struct SessionBuffer {
-  u8 *aBuf;                       /* Pointer to changeset buffer */
-  int nBuf;                       /* Size of buffer aBuf */
-  int nAlloc;                     /* Size of allocation containing aBuf */
-};
-
-/*
-** An object of this type is used internally as an abstraction for
-** input data. Input data may be supplied either as a single large buffer
-** (e.g. sqlite3changeset_start()) or using a stream function (e.g.
-**  sqlite3changeset_start_strm()).
-**
-** bNoDiscard:
-**   If true, then the only time data is discarded is as a result of explicit
-**   sessionDiscardData() calls. Not within every sessionInputBuffer() call.
-*/
-struct SessionInput {
-  int bNoDiscard;                 /* If true, do not discard in InputBuffer() */
-  int iCurrent;                   /* Offset in aData[] of current change */
-  int iNext;                      /* Offset in aData[] of next change */
-  u8 *aData;                      /* Pointer to buffer containing changeset */
-  int nData;                      /* Number of bytes in aData */
-
-  SessionBuffer buf;              /* Current read buffer */
-  int (*xInput)(void*, void*, int*);        /* Input stream call (or NULL) */
-  void *pIn;                                /* First argument to xInput */
-  int bEof;                       /* Set to true after xInput finished */
-};
-
-/*
-** Structure for changeset iterators.
-*/
-struct sqlite3_changeset_iter {
-  SessionInput in;                /* Input buffer or stream */
-  SessionBuffer tblhdr;           /* Buffer to hold apValue/zTab/abPK/ */
-  int bPatchset;                  /* True if this is a patchset */
-  int bInvert;                    /* True to invert changeset */
-  int bSkipEmpty;                 /* Skip noop UPDATE changes */
-  int rc;                         /* Iterator error code */
-  sqlite3_stmt *pConflict;        /* Points to conflicting row, if any */
-  char *zTab;                     /* Current table */
-  int nCol;                       /* Number of columns in zTab */
-  int op;                         /* Current operation */
-  int bIndirect;                  /* True if current change was indirect */
-  u8 *abPK;                       /* Primary key array */
-  sqlite3_value **apValue;        /* old.* and new.* values */
-};
-
-/*
-** Each session object maintains a set of the following structures, one
-** for each table the session object is monitoring. The structures are
-** stored in a linked list starting at sqlite3_session.pTable.
-**
-** The keys of the SessionTable.aChange[] hash table are all rows that have
-** been modified in any way since the session object was attached to the
-** table.
-**
-** The data associated with each hash-table entry is a structure containing
-** a subset of the initial values that the modified row contained at the
-** start of the session. Or no initial values if the row was inserted.
-**
-** pDfltStmt:
-**   This is only used by the sqlite3changegroup_xxx() APIs, not by
-**   regular sqlite3_session objects. It is a SELECT statement that
-**   selects the default value for each table column. For example,
-**   if the table is
-**
-**      CREATE TABLE xx(a DEFAULT 1, b, c DEFAULT 'abc')
-**
-**   then this variable is the compiled version of:
-**
-**      SELECT 1, NULL, 'abc'
-*/
-struct SessionTable {
-  SessionTable *pNext;
-  char *zName;                    /* Local name of table */
-  int nCol;                       /* Number of non-hidden columns */
-  int nTotalCol;                  /* Number of columns including hidden */
-  int bStat1;                     /* True if this is sqlite_stat1 */
-  int bRowid;                     /* True if this table uses rowid for PK */
-  const char **azCol;             /* Column names */
-  const char **azDflt;            /* Default value expressions */
-  int *aiIdx;                     /* Index to pass to xNew/xOld */
-  u8 *abPK;                       /* Array of primary key flags */
-  int nEntry;                     /* Total number of entries in hash table */
-  int nChange;                    /* Size of apChange[] array */
-  SessionChange **apChange;       /* Hash table buckets */
-  sqlite3_stmt *pDfltStmt;
-};
-
-/*
-** RECORD FORMAT:
-**
-** The following record format is similar to (but not compatible with) that
-** used in SQLite database files. This format is used as part of the
-** change-set binary format, and so must be architecture independent.
-**
-** Unlike the SQLite database record format, each field is self-contained -
-** there is no separation of header and data. Each field begins with a
-** single byte describing its type, as follows:
-**
-**       0x00: Undefined value.
-**       0x01: Integer value.
-**       0x02: Real value.
-**       0x03: Text value.
-**       0x04: Blob value.
-**       0x05: SQL NULL value.
-**
-** Note that the above match the definitions of SQLITE_INTEGER, SQLITE_TEXT
-** and so on in sqlite3.h. For undefined and NULL values, the field consists
-** only of the single type byte. For other types of values, the type byte
-** is followed by:
-**
-**   Text values:
-**     A varint containing the number of bytes in the value (encoded using
-**     UTF-8). Followed by a buffer containing the UTF-8 representation
-**     of the text value. There is no nul terminator.
-**
-**   Blob values:
-**     A varint containing the number of bytes in the value, followed by
-**     a buffer containing the value itself.
-**
-**   Integer values:
-**     An 8-byte big-endian integer value.
-**
-**   Real values:
-**     An 8-byte big-endian IEEE 754-2008 real value.
-**
-** Varint values are encoded in the same way as varints in the SQLite
-** record format.
-**
-** CHANGESET FORMAT:
-**
-** A changeset is a collection of DELETE, UPDATE and INSERT operations on
-** one or more tables. Operations on a single table are grouped together,
-** but may occur in any order (i.e. deletes, updates and inserts are all
-** mixed together).
-**
-** Each group of changes begins with a table header:
-**
-**   1 byte: Constant 0x54 (capital 'T')
-**   Varint: Number of columns in the table.
-**   nCol bytes: 0x01 for PK columns, 0x00 otherwise.
-**   N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated.
-**
-** Followed by one or more changes to the table.
-**
-**   1 byte: Either SQLITE_INSERT (0x12), UPDATE (0x17) or DELETE (0x09).
-**   1 byte: The "indirect-change" flag.
-**   old.* record: (delete and update only)
-**   new.* record: (insert and update only)
-**
-** The "old.*" and "new.*" records, if present, are N field records in the
-** format described above under "RECORD FORMAT", where N is the number of
-** columns in the table. The i'th field of each record is associated with
-** the i'th column of the table, counting from left to right in the order
-** in which columns were declared in the CREATE TABLE statement.
-**
-** The new.* record that is part of each INSERT change contains the values
-** that make up the new row. Similarly, the old.* record that is part of each
-** DELETE change contains the values that made up the row that was deleted
-** from the database. In the changeset format, the records that are part
-** of INSERT or DELETE changes never contain any undefined (type byte 0x00)
-** fields.
-**
-** Within the old.* record associated with an UPDATE change, all fields
-** associated with table columns that are not PRIMARY KEY columns and are
-** not modified by the UPDATE change are set to "undefined". Other fields
-** are set to the values that made up the row before the UPDATE that the
-** change records took place. Within the new.* record, fields associated
-** with table columns modified by the UPDATE change contain the new
-** values. Fields associated with table columns that are not modified
-** are set to "undefined".
-**
-** PATCHSET FORMAT:
-**
-** A patchset is also a collection of changes. It is similar to a changeset,
-** but leaves undefined those fields that are not useful if no conflict
-** resolution is required when applying the changeset.
-**
-** Each group of changes begins with a table header:
-**
-**   1 byte: Constant 0x50 (capital 'P')
-**   Varint: Number of columns in the table.
-**   nCol bytes: 0x01 for PK columns, 0x00 otherwise.
-**   N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated.
-**
-** Followed by one or more changes to the table.
-**
-**   1 byte: Either SQLITE_INSERT (0x12), UPDATE (0x17) or DELETE (0x09).
-**   1 byte: The "indirect-change" flag.
-**   single record: (PK fields for DELETE, PK and modified fields for UPDATE,
-**                   full record for INSERT).
-**
-** As in the changeset format, each field of the single record that is part
-** of a patchset change is associated with the correspondingly positioned
-** table column, counting from left to right within the CREATE TABLE
-** statement.
-**
-** For a DELETE change, all fields within the record except those associated
-** with PRIMARY KEY columns are omitted. The PRIMARY KEY fields contain the
-** values identifying the row to delete.
-**
-** For an UPDATE change, all fields except those associated with PRIMARY KEY
-** columns and columns that are modified by the UPDATE are set to "undefined".
-** PRIMARY KEY fields contain the values identifying the table row to update,
-** and fields associated with modified columns contain the new column values.
-**
-** The records associated with INSERT changes are in the same format as for
-** changesets. It is not possible for a record associated with an INSERT
-** change to contain a field set to "undefined".
-**
-** REBASE BLOB FORMAT:
-**
-** A rebase blob may be output by sqlite3changeset_apply_v2() and its
-** streaming equivalent for use with the sqlite3_rebaser APIs to rebase
-** existing changesets. A rebase blob contains one entry for each conflict
-** resolved using either the OMIT or REPLACE strategies within the apply_v2()
-** call.
-**
-** The format used for a rebase blob is very similar to that used for
-** changesets. All entries related to a single table are grouped together.
-**
-** Each group of entries begins with a table header in changeset format:
-**
-**   1 byte: Constant 0x54 (capital 'T')
-**   Varint: Number of columns in the table.
-**   nCol bytes: 0x01 for PK columns, 0x00 otherwise.
-**   N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated.
-**
-** Followed by one or more entries associated with the table.
-**
-**   1 byte: Either SQLITE_INSERT (0x12), DELETE (0x09).
-**   1 byte: Flag. 0x01 for REPLACE, 0x00 for OMIT.
-**   record: (in the record format defined above).
-**
-** In a rebase blob, the first field is set to SQLITE_INSERT if the change
-** that caused the conflict was an INSERT or UPDATE, or to SQLITE_DELETE if
-** it was a DELETE. The second field is set to 0x01 if the conflict
-** resolution strategy was REPLACE, or 0x00 if it was OMIT.
-**
-** If the change that caused the conflict was a DELETE, then the single
-** record is a copy of the old.* record from the original changeset. If it
-** was an INSERT, then the single record is a copy of the new.* record. If
-** the conflicting change was an UPDATE, then the single record is a copy
-** of the new.* record with the PK fields filled in based on the original
-** old.* record.
-*/
-
-/*
-** For each row modified during a session, there exists a single instance of
-** this structure stored in a SessionTable.aChange[] hash table.
-*/
-struct SessionChange {
-  u8 op;                          /* One of UPDATE, DELETE, INSERT */
-  u8 bIndirect;                   /* True if this change is "indirect" */
-  u16 nRecordField;               /* Number of fields in aRecord[] */
-  int nMaxSize;                   /* Max size of eventual changeset record */
-  int nRecord;                    /* Number of bytes in buffer aRecord[] */
-  u8 *aRecord;                    /* Buffer containing old.* record */
-  SessionChange *pNext;           /* For hash-table collisions */
-};
-
-/*
-** Write a varint with value iVal into the buffer at aBuf. Return the
-** number of bytes written.
-*/
-static int sessionVarintPut(u8 *aBuf, int iVal){
-  return putVarint32(aBuf, iVal);
-}
-
-/*
-** Return the number of bytes required to store value iVal as a varint.
-*/
-static int sessionVarintLen(int iVal){
-  return sqlite3VarintLen(iVal);
-}
-
-/*
-** Read a varint value from aBuf[] into *piVal. Return the number of
-** bytes read.
-*/
-static int sessionVarintGet(const u8 *aBuf, int *piVal){
-  return getVarint32(aBuf, *piVal);
-}
-
-/*
-** Read a varint value from buffer aBuf[], size nBuf bytes, into *piVal.
-** Return the number of bytes read.
-*/
-static int sessionVarintGetSafe(const u8 *aBuf, int nBuf, int *piVal){
-  u8 aCopy[9];
-  const u8 *aRead = aBuf;
-  memset(aCopy, 0, sizeof(aCopy));
-  if( nBuf<sizeof(aCopy) ){
-    memcpy(aCopy, aBuf, nBuf);
-    aRead = aCopy;
-  }
-  return getVarint32(aRead, *piVal);
-}
-
-/* Load an unaligned and unsigned 32-bit integer */
-#define SESSION_UINT32(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
-
-/*
-** Read a 64-bit big-endian integer value from buffer aRec[]. Return
-** the value read.
-*/
-static sqlite3_int64 sessionGetI64(u8 *aRec){
-  u64 x = SESSION_UINT32(aRec);
-  u32 y = SESSION_UINT32(aRec+4);
-  x = (x<<32) + y;
-  return (sqlite3_int64)x;
-}
-
-/*
-** Write a 64-bit big-endian integer value to the buffer aBuf[].
-*/
-static void sessionPutI64(u8 *aBuf, sqlite3_int64 i){
-  aBuf[0] = (i>>56) & 0xFF;
-  aBuf[1] = (i>>48) & 0xFF;
-  aBuf[2] = (i>>40) & 0xFF;
-  aBuf[3] = (i>>32) & 0xFF;
-  aBuf[4] = (i>>24) & 0xFF;
-  aBuf[5] = (i>>16) & 0xFF;
-  aBuf[6] = (i>> 8) & 0xFF;
-  aBuf[7] = (i>> 0) & 0xFF;
-}
-
-/*
-** Write a double value to the buffer aBuf[].
-*/
-static void sessionPutDouble(u8 *aBuf, double r){
-  /* TODO: SQLite does something special to deal with mixed-endian
-  ** floating point values (e.g. ARM7). This code probably should
-  ** too.  */
-  u64 i;
-  assert( sizeof(double)==8 && sizeof(u64)==8 );
-  memcpy(&i, &r, 8);
-  sessionPutI64(aBuf, i);
-}
-
-/*
-** This function is used to serialize the contents of value pValue (see
-** comment titled "RECORD FORMAT" above).
-**
-** If it is non-NULL, the serialized form of the value is written to
-** buffer aBuf. *pnWrite is set to the number of bytes written before
-** returning. Or, if aBuf is NULL, the only thing this function does is
-** set *pnWrite.
-**
-** If no error occurs, SQLITE_OK is returned. Or, if an OOM error occurs
-** within a call to sqlite3_value_text() (may fail if the db is utf-16))
-** SQLITE_NOMEM is returned.
-*/
-static int sessionSerializeValue(
-  u8 *aBuf,                       /* If non-NULL, write serialized value here */
-  sqlite3_value *pValue,          /* Value to serialize */
-  sqlite3_int64 *pnWrite          /* IN/OUT: Increment by bytes written */
-){
-  int nByte;                      /* Size of serialized value in bytes */
-
-  if( pValue ){
-    int eType;                    /* Value type (SQLITE_NULL, TEXT etc.) */
-
-    eType = sqlite3_value_type(pValue);
-    if( aBuf ) aBuf[0] = eType;
-
-    switch( eType ){
-      case SQLITE_NULL:
-        nByte = 1;
-        break;
-
-      case SQLITE_INTEGER:
-      case SQLITE_FLOAT:
-        if( aBuf ){
-          /* TODO: SQLite does something special to deal with mixed-endian
-          ** floating point values (e.g. ARM7). This code probably should
-          ** too.  */
-          if( eType==SQLITE_INTEGER ){
-            u64 i = (u64)sqlite3_value_int64(pValue);
-            sessionPutI64(&aBuf[1], i);
-          }else{
-            double r = sqlite3_value_double(pValue);
-            sessionPutDouble(&aBuf[1], r);
-          }
-        }
-        nByte = 9;
-        break;
-
-      default: {
-        u8 *z;
-        int n;
-        int nVarint;
-
-        assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
-        if( eType==SQLITE_TEXT ){
-          z = (u8 *)sqlite3_value_text(pValue);
-        }else{
-          z = (u8 *)sqlite3_value_blob(pValue);
-        }
-        n = sqlite3_value_bytes(pValue);
-        if( z==0 && (eType!=SQLITE_BLOB || n>0) ) return SQLITE_NOMEM;
-        nVarint = sessionVarintLen(n);
-
-        if( aBuf ){
-          sessionVarintPut(&aBuf[1], n);
-          if( n>0 ) memcpy(&aBuf[nVarint + 1], z, n);
-        }
-
-        nByte = 1 + nVarint + n;
-        break;
-      }
-    }
-  }else{
-    nByte = 1;
-    if( aBuf ) aBuf[0] = '\0';
-  }
-
-  if( pnWrite ) *pnWrite += nByte;
-  return SQLITE_OK;
-}
-
-/*
-** Allocate and return a pointer to a buffer nByte bytes in size. If
-** pSession is not NULL, increase the sqlite3_session.nMalloc variable
-** by the number of bytes allocated.
-*/
-static void *sessionMalloc64(sqlite3_session *pSession, i64 nByte){
-  void *pRet = sqlite3_malloc64(nByte);
-  if( pSession ) pSession->nMalloc += sqlite3_msize(pRet);
-  return pRet;
-}
-
-/*
-** Free buffer pFree, which must have been allocated by an earlier
-** call to sessionMalloc64(). If pSession is not NULL, decrease the
-** sqlite3_session.nMalloc counter by the number of bytes freed.
-*/
-static void sessionFree(sqlite3_session *pSession, void *pFree){
-  if( pSession ) pSession->nMalloc -= sqlite3_msize(pFree);
-  sqlite3_free(pFree);
-}
-
-/*
-** This macro is used to calculate hash key values for data structures. In
-** order to use this macro, the entire data structure must be represented
-** as a series of unsigned integers. In order to calculate a hash-key value
-** for a data structure represented as three such integers, the macro may
-** then be used as follows:
-**
-**    int hash_key_value;
-**    hash_key_value = HASH_APPEND(0, <value 1>);
-**    hash_key_value = HASH_APPEND(hash_key_value, <value 2>);
-**    hash_key_value = HASH_APPEND(hash_key_value, <value 3>);
-**
-** In practice, the data structures this macro is used for are the primary
-** key values of modified rows.
-*/
-#define HASH_APPEND(hash, add) ((hash) << 3) ^ (hash) ^ (unsigned int)(add)
-
-/*
-** Append the hash of the 64-bit integer passed as the second argument to the
-** hash-key value passed as the first. Return the new hash-key value.
-*/
-static unsigned int sessionHashAppendI64(unsigned int h, i64 i){
-  h = HASH_APPEND(h, i & 0xFFFFFFFF);
-  return HASH_APPEND(h, (i>>32)&0xFFFFFFFF);
-}
-
-/*
-** Append the hash of the blob passed via the second and third arguments to
-** the hash-key value passed as the first. Return the new hash-key value.
-*/
-static unsigned int sessionHashAppendBlob(unsigned int h, int n, const u8 *z){
-  int i;
-  for(i=0; i<n; i++) h = HASH_APPEND(h, z[i]);
-  return h;
-}
-
-/*
-** Append the hash of the data type passed as the second argument to the
-** hash-key value passed as the first. Return the new hash-key value.
-*/
-static unsigned int sessionHashAppendType(unsigned int h, int eType){
-  return HASH_APPEND(h, eType);
-}
-
-/*
-** This function may only be called from within a pre-update callback.
-** It calculates a hash based on the primary key values of the old.* or
-** new.* row currently available and, assuming no error occurs, writes it to
-** *piHash before returning. If the primary key contains one or more NULL
-** values, *pbNullPK is set to true before returning.
-**
-** If an error occurs, an SQLite error code is returned and the final values
-** of *piHash asn *pbNullPK are undefined. Otherwise, SQLITE_OK is returned
-** and the output variables are set as described above.
-*/
-static int sessionPreupdateHash(
-  sqlite3_session *pSession,      /* Session object that owns pTab */
-  i64 iRowid,
-  SessionTable *pTab,             /* Session table handle */
-  int bNew,                       /* True to hash the new.* PK */
-  int *piHash,                    /* OUT: Hash value */
-  int *pbNullPK                   /* OUT: True if there are NULL values in PK */
-){
-  unsigned int h = 0;             /* Hash value to return */
-  int i;                          /* Used to iterate through columns */
-
-  assert( pTab->nTotalCol==pSession->hook.xCount(pSession->hook.pCtx) );
-  if( pTab->bRowid ){
-    h = sessionHashAppendI64(h, iRowid);
-  }else{
-    assert( *pbNullPK==0 );
-    for(i=0; i<pTab->nCol; i++){
-      if( pTab->abPK[i] ){
-        int rc;
-        int eType;
-        sqlite3_value *pVal;
-        int iIdx = pTab->aiIdx[i];
-
-        if( bNew ){
-          rc = pSession->hook.xNew(pSession->hook.pCtx, iIdx, &pVal);
-        }else{
-          rc = pSession->hook.xOld(pSession->hook.pCtx, iIdx, &pVal);
-        }
-        if( rc!=SQLITE_OK ) return rc;
-
-        eType = sqlite3_value_type(pVal);
-        h = sessionHashAppendType(h, eType);
-        if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
-          i64 iVal;
-          if( eType==SQLITE_INTEGER ){
-            iVal = sqlite3_value_int64(pVal);
-          }else{
-            double rVal = sqlite3_value_double(pVal);
-            assert( sizeof(iVal)==8 && sizeof(rVal)==8 );
-            memcpy(&iVal, &rVal, 8);
-          }
-          h = sessionHashAppendI64(h, iVal);
-        }else if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){
-          const u8 *z;
-          int n;
-          if( eType==SQLITE_TEXT ){
-            z = (const u8 *)sqlite3_value_text(pVal);
-          }else{
-            z = (const u8 *)sqlite3_value_blob(pVal);
-          }
-          n = sqlite3_value_bytes(pVal);
-          if( !z && (eType!=SQLITE_BLOB || n>0) ) return SQLITE_NOMEM;
-          h = sessionHashAppendBlob(h, n, z);
-        }else{
-          assert( eType==SQLITE_NULL );
-          assert( pTab->bStat1==0 || i!=1 );
-          *pbNullPK = 1;
-        }
-      }
-    }
-  }
-
-  *piHash = (h % pTab->nChange);
-  return SQLITE_OK;
-}
-
-/*
-** The buffer that the argument points to contains a serialized SQL value.
-** Return the number of bytes of space occupied by the value (including
-** the type byte).
-*/
-static int sessionSerialLen(const u8 *a){
-  int e;
-  int n;
-  assert( a!=0 );
-  e = *a;
-  if( e==SQLITE_INTEGER || e==SQLITE_FLOAT ) return 9;
-  if( e==SQLITE_TEXT || e==SQLITE_BLOB ){
-    return sessionVarintGet(&a[1], &n) + 1 + n;
-  }
-  return 1;
-}
-
-/*
-** Based on the primary key values stored in change aRecord, calculate a
-** hash key. Assume the has table has nBucket buckets. The hash keys
-** calculated by this function are compatible with those calculated by
-** sessionPreupdateHash().
-**
-** The bPkOnly argument is non-zero if the record at aRecord[] is from
-** a patchset DELETE. In this case the non-PK fields are omitted entirely.
-*/
-static unsigned int sessionChangeHash(
-  SessionTable *pTab,             /* Table handle */
-  int bPkOnly,                    /* Record consists of PK fields only */
-  u8 *aRecord,                    /* Change record */
-  int nBucket                     /* Assume this many buckets in hash table */
-){
-  unsigned int h = 0;             /* Value to return */
-  int i;                          /* Used to iterate through columns */
-  u8 *a = aRecord;                /* Used to iterate through change record */
-
-  for(i=0; i<pTab->nCol; i++){
-    int isPK = pTab->abPK[i];
-    if( bPkOnly && isPK==0 ) continue;
-
-    if( isPK ){
-      int eType = *a++;
-
-      assert( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT
-           || eType==SQLITE_TEXT || eType==SQLITE_BLOB
-           || eType==SQLITE_NULL || eType==0
-      );
-
-      h = sessionHashAppendType(h, eType);
-      if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
-        h = sessionHashAppendI64(h, sessionGetI64(a));
-        a += 8;
-      }else if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){
-        int n;
-        a += sessionVarintGet(a, &n);
-        h = sessionHashAppendBlob(h, n, a);
-        a += n;
-      }
-      /* It should not be possible for eType to be SQLITE_NULL or 0x00 here,
-      ** as the session module does not record changes for rows with NULL
-      ** values stored in primary key columns. But a corrupt changesets
-      ** may contain such a value.  */
-    }else{
-      a += sessionSerialLen(a);
-    }
-  }
-  return (h % nBucket);
-}
-
-/*
-** Arguments aLeft and aRight are pointers to change records for table pTab.
-** This function returns true if the two records apply to the same row (i.e.
-** have the same values stored in the primary key columns), or false
-** otherwise.
-*/
-static int sessionChangeEqual(
-  SessionTable *pTab,             /* Table used for PK definition */
-  int bLeftPkOnly,                /* True if aLeft[] contains PK fields only */
-  u8 *aLeft,                      /* Change record */
-  int bRightPkOnly,               /* True if aRight[] contains PK fields only */
-  u8 *aRight                      /* Change record */
-){
-  u8 *a1 = aLeft;                 /* Cursor to iterate through aLeft */
-  u8 *a2 = aRight;                /* Cursor to iterate through aRight */
-  int iCol;                       /* Used to iterate through table columns */
-
-  for(iCol=0; iCol<pTab->nCol; iCol++){
-    if( pTab->abPK[iCol] ){
-      int n1 = sessionSerialLen(a1);
-      int n2 = sessionSerialLen(a2);
-
-      if( n1!=n2 || memcmp(a1, a2, n1) ){
-        return 0;
-      }
-      a1 += n1;
-      a2 += n2;
-    }else{
-      if( bLeftPkOnly==0 ) a1 += sessionSerialLen(a1);
-      if( bRightPkOnly==0 ) a2 += sessionSerialLen(a2);
-    }
-  }
-
-  return 1;
-}
-
-/*
-** Arguments aLeft and aRight both point to buffers containing change
-** records with nCol columns. This function "merges" the two records into
-** a single records which is written to the buffer at *paOut. *paOut is
-** then set to point to one byte after the last byte written before
-** returning.
-**
-** The merging of records is done as follows: For each column, if the
-** aRight record contains a value for the column, copy the value from
-** their. Otherwise, if aLeft contains a value, copy it. If neither
-** record contains a value for a given column, then neither does the
-** output record.
-*/
-static void sessionMergeRecord(
-  u8 **paOut,
-  int nCol,
-  u8 *aLeft,
-  u8 *aRight
-){
-  u8 *a1 = aLeft;                 /* Cursor used to iterate through aLeft */
-  u8 *a2 = aRight;                /* Cursor used to iterate through aRight */
-  u8 *aOut = *paOut;              /* Output cursor */
-  int iCol;                       /* Used to iterate from 0 to nCol */
-
-  for(iCol=0; iCol<nCol; iCol++){
-    int n1 = sessionSerialLen(a1);
-    int n2 = sessionSerialLen(a2);
-    if( *a2 ){
-      memcpy(aOut, a2, n2);
-      aOut += n2;
-    }else{
-      memcpy(aOut, a1, n1);
-      aOut += n1;
-    }
-    a1 += n1;
-    a2 += n2;
-  }
-
-  *paOut = aOut;
-}
-
-/*
-** This is a helper function used by sessionMergeUpdate().
-**
-** When this function is called, both *paOne and *paTwo point to a value
-** within a change record. Before it returns, both have been advanced so
-** as to point to the next value in the record.
-**
-** If, when this function is called, *paTwo points to a valid value (i.e.
-** *paTwo[0] is not 0x00 - the "no value" placeholder), a copy of the *paTwo
-** pointer is returned and *pnVal is set to the number of bytes in the
-** serialized value. Otherwise, a copy of *paOne is returned and *pnVal
-** set to the number of bytes in the value at *paOne. If *paOne points
-** to the "no value" placeholder, *pnVal is set to 1. In other words:
-**
-**   if( *paTwo is valid ) return *paTwo;
-**   return *paOne;
-**
-*/
-static u8 *sessionMergeValue(
-  u8 **paOne,                     /* IN/OUT: Left-hand buffer pointer */
-  u8 **paTwo,                     /* IN/OUT: Right-hand buffer pointer */
-  int *pnVal                      /* OUT: Bytes in returned value */
-){
-  u8 *a1 = *paOne;
-  u8 *a2 = *paTwo;
-  u8 *pRet = 0;
-  int n1;
-
-  assert( a1 );
-  if( a2 ){
-    int n2 = sessionSerialLen(a2);
-    if( *a2 ){
-      *pnVal = n2;
-      pRet = a2;
-    }
-    *paTwo = &a2[n2];
-  }
-
-  n1 = sessionSerialLen(a1);
-  if( pRet==0 ){
-    *pnVal = n1;
-    pRet = a1;
-  }
-  *paOne = &a1[n1];
-
-  return pRet;
-}
-
-/*
-** This function is used by changeset_concat() to merge two UPDATE changes
-** on the same row.
-*/
-static int sessionMergeUpdate(
-  u8 **paOut,                     /* IN/OUT: Pointer to output buffer */
-  SessionTable *pTab,             /* Table change pertains to */
-  int bPatchset,                  /* True if records are patchset records */
-  u8 *aOldRecord1,                /* old.* record for first change */
-  u8 *aOldRecord2,                /* old.* record for second change */
-  u8 *aNewRecord1,                /* new.* record for first change */
-  u8 *aNewRecord2                 /* new.* record for second change */
-){
-  u8 *aOld1 = aOldRecord1;
-  u8 *aOld2 = aOldRecord2;
-  u8 *aNew1 = aNewRecord1;
-  u8 *aNew2 = aNewRecord2;
-
-  u8 *aOut = *paOut;
-  int i;
-
-  if( bPatchset==0 ){
-    int bRequired = 0;
-
-    assert( aOldRecord1 && aNewRecord1 );
-
-    /* Write the old.* vector first. */
-    for(i=0; i<pTab->nCol; i++){
-      int nOld;
-      u8 *aOld;
-      int nNew;
-      u8 *aNew;
-
-      aOld = sessionMergeValue(&aOld1, &aOld2, &nOld);
-      aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
-      if( pTab->abPK[i] || nOld!=nNew || memcmp(aOld, aNew, nNew) ){
-        if( pTab->abPK[i]==0 ) bRequired = 1;
-        memcpy(aOut, aOld, nOld);
-        aOut += nOld;
-      }else{
-        *(aOut++) = '\0';
-      }
-    }
-
-    if( !bRequired ) return 0;
-  }
-
-  /* Write the new.* vector */
-  aOld1 = aOldRecord1;
-  aOld2 = aOldRecord2;
-  aNew1 = aNewRecord1;
-  aNew2 = aNewRecord2;
-  for(i=0; i<pTab->nCol; i++){
-    int nOld;
-    u8 *aOld;
-    int nNew;
-    u8 *aNew;
-
-    aOld = sessionMergeValue(&aOld1, &aOld2, &nOld);
-    aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
-    if( bPatchset==0
-     && (pTab->abPK[i] || (nOld==nNew && 0==memcmp(aOld, aNew, nNew)))
-    ){
-      *(aOut++) = '\0';
-    }else{
-      memcpy(aOut, aNew, nNew);
-      aOut += nNew;
-    }
-  }
-
-  *paOut = aOut;
-  return 1;
-}
-
-/*
-** This function is only called from within a pre-update-hook callback.
-** It determines if the current pre-update-hook change affects the same row
-** as the change stored in argument pChange. If so, it returns true. Otherwise
-** if the pre-update-hook does not affect the same row as pChange, it returns
-** false.
-*/
-static int sessionPreupdateEqual(
-  sqlite3_session *pSession,      /* Session object that owns SessionTable */
-  i64 iRowid,                     /* Rowid value if pTab->bRowid */
-  SessionTable *pTab,             /* Table associated with change */
-  SessionChange *pChange,         /* Change to compare to */
-  int op                          /* Current pre-update operation */
-){
-  int iCol;                       /* Used to iterate through columns */
-  u8 *a = pChange->aRecord;       /* Cursor used to scan change record */
-
-  if( pTab->bRowid ){
-    if( a[0]!=SQLITE_INTEGER ) return 0;
-    return sessionGetI64(&a[1])==iRowid;
-  }
-
-  assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );
-  for(iCol=0; iCol<pTab->nCol; iCol++){
-    if( !pTab->abPK[iCol] ){
-      a += sessionSerialLen(a);
-    }else{
-      sqlite3_value *pVal;        /* Value returned by preupdate_new/old */
-      int rc;                     /* Error code from preupdate_new/old */
-      int eType = *a++;           /* Type of value from change record */
-      int iIdx = pTab->aiIdx[iCol];
-
-      /* The following calls to preupdate_new() and preupdate_old() can not
-      ** fail. This is because they cache their return values, and by the
-      ** time control flows to here they have already been called once from
-      ** within sessionPreupdateHash(). The first two asserts below verify
-      ** this (that the method has already been called). */
-      if( op==SQLITE_INSERT ){
-        /* assert( db->pPreUpdate->pNewUnpacked || db->pPreUpdate->aNew ); */
-        rc = pSession->hook.xNew(pSession->hook.pCtx, iIdx, &pVal);
-      }else{
-        /* assert( db->pPreUpdate->pUnpacked ); */
-        rc = pSession->hook.xOld(pSession->hook.pCtx, iIdx, &pVal);
-      }
-      assert( rc==SQLITE_OK );
-      (void)rc;                   /* Suppress warning about unused variable */
-      if( sqlite3_value_type(pVal)!=eType ) return 0;
-
-      /* A SessionChange object never has a NULL value in a PK column */
-      assert( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT
-           || eType==SQLITE_BLOB    || eType==SQLITE_TEXT
-      );
-
-      if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
-        i64 iVal = sessionGetI64(a);
-        a += 8;
-        if( eType==SQLITE_INTEGER ){
-          if( sqlite3_value_int64(pVal)!=iVal ) return 0;
-        }else{
-          double rVal;
-          assert( sizeof(iVal)==8 && sizeof(rVal)==8 );
-          memcpy(&rVal, &iVal, 8);
-          if( sqlite3_value_double(pVal)!=rVal ) return 0;
-        }
-      }else{
-        int n;
-        const u8 *z;
-        a += sessionVarintGet(a, &n);
-        if( sqlite3_value_bytes(pVal)!=n ) return 0;
-        if( eType==SQLITE_TEXT ){
-          z = sqlite3_value_text(pVal);
-        }else{
-          z = sqlite3_value_blob(pVal);
-        }
-        if( n>0 && memcmp(a, z, n) ) return 0;
-        a += n;
-      }
-    }
-  }
-
-  return 1;
-}
-
-/*
-** If required, grow the hash table used to store changes on table pTab
-** (part of the session pSession). If a fatal OOM error occurs, set the
-** session object to failed and return SQLITE_ERROR. Otherwise, return
-** SQLITE_OK.
-**
-** It is possible that a non-fatal OOM error occurs in this function. In
-** that case the hash-table does not grow, but SQLITE_OK is returned anyway.
-** Growing the hash table in this case is a performance optimization only,
-** it is not required for correct operation.
-*/
-static int sessionGrowHash(
-  sqlite3_session *pSession,      /* For memory accounting. May be NULL */
-  int bPatchset,
-  SessionTable *pTab
-){
-  if( pTab->nChange==0 || pTab->nEntry>=(pTab->nChange/2) ){
-    int i;
-    SessionChange **apNew;
-    sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);
-
-    apNew = (SessionChange**)sessionMalloc64(
-        pSession, sizeof(SessionChange*) * nNew
-    );
-    if( apNew==0 ){
-      if( pTab->nChange==0 ){
-        return SQLITE_ERROR;
-      }
-      return SQLITE_OK;
-    }
-    memset(apNew, 0, sizeof(SessionChange *) * nNew);
-
-    for(i=0; i<pTab->nChange; i++){
-      SessionChange *p;
-      SessionChange *pNext;
-      for(p=pTab->apChange[i]; p; p=pNext){
-        int bPkOnly = (p->op==SQLITE_DELETE && bPatchset);
-        int iHash = sessionChangeHash(pTab, bPkOnly, p->aRecord, nNew);
-        pNext = p->pNext;
-        p->pNext = apNew[iHash];
-        apNew[iHash] = p;
-      }
-    }
-
-    sessionFree(pSession, pTab->apChange);
-    pTab->nChange = nNew;
-    pTab->apChange = apNew;
-  }
-
-  return SQLITE_OK;
-}
-
-/*
-** This function queries the database for the names of the columns of table
-** zThis, in schema zDb.
-**
-** Otherwise, if they are not NULL, variable *pnCol is set to the number
-** of columns in the database table and variable *pzTab is set to point to a
-** nul-terminated copy of the table name. *pazCol (if not NULL) is set to
-** point to an array of pointers to column names. And *pabPK (again, if not
-** NULL) is set to point to an array of booleans - true if the corresponding
-** column is part of the primary key.
-**
-** For example, if the table is declared as:
-**
-**     CREATE TABLE tbl1(w, x DEFAULT 'abc', y, z, PRIMARY KEY(w, z));
-**
-** Then the five output variables are populated as follows:
-**
-**     *pnCol  = 4
-**     *pzTab  = "tbl1"
-**     *pazCol = {"w", "x", "y", "z"}
-**     *pazDflt = {NULL, 'abc', NULL, NULL}
-**     *pabPK  = {1, 0, 0, 1}
-**
-** All returned buffers are part of the same single allocation, which must
-** be freed using sqlite3_free() by the caller
-*/
-static int sessionTableInfo(
-  sqlite3_session *pSession,      /* For memory accounting. May be NULL */
-  sqlite3 *db,                    /* Database connection */
-  const char *zDb,                /* Name of attached database (e.g. "main") */
-  const char *zThis,              /* Table name */
-  int *pnCol,                     /* OUT: number of columns */
-  int *pnTotalCol,                /* OUT: number of hidden columns */
-  const char **pzTab,             /* OUT: Copy of zThis */
-  const char ***pazCol,           /* OUT: Array of column names for table */
-  const char ***pazDflt,          /* OUT: Array of default value expressions */
-  int **paiIdx,                   /* OUT: Array of xNew/xOld indexes */
-  u8 **pabPK,                     /* OUT: Array of booleans - true for PK col */
-  int *pbRowid                    /* OUT: True if only PK is a rowid */
-){
-  char *zPragma;
-  sqlite3_stmt *pStmt;
-  int rc;
-  sqlite3_int64 nByte;
-  int nDbCol = 0;
-  int nThis;
-  int i;
-  u8 *pAlloc = 0;
-  char **azCol = 0;
-  char **azDflt = 0;
-  u8 *abPK = 0;
-  int *aiIdx = 0;
-  int bRowid = 0;                 /* Set to true to use rowid as PK */
-
-  assert( pazCol && pabPK );
-
-  *pazCol = 0;
-  *pabPK = 0;
-  *pnCol = 0;
-  if( pnTotalCol ) *pnTotalCol = 0;
-  if( paiIdx ) *paiIdx = 0;
-  if( pzTab ) *pzTab = 0;
-  if( pazDflt ) *pazDflt = 0;
-
-  nThis = sqlite3Strlen30(zThis);
-  if( nThis==12 && 0==sqlite3_stricmp("sqlite_stat1", zThis) ){
-    rc = sqlite3_table_column_metadata(db, zDb, zThis, 0, 0, 0, 0, 0, 0);
-    if( rc==SQLITE_OK ){
-      /* For sqlite_stat1, pretend that (tbl,idx) is the PRIMARY KEY. */
-      zPragma = sqlite3_mprintf(
-          "SELECT 0, 'tbl',  '', 0, '', 1, 0     UNION ALL "
-          "SELECT 1, 'idx',  '', 0, '', 2, 0     UNION ALL "
-          "SELECT 2, 'stat', '', 0, '', 0, 0"
-      );
-    }else if( rc==SQLITE_ERROR ){
-      zPragma = sqlite3_mprintf("");
-    }else{
-      return rc;
-    }
-  }else{
-    zPragma = sqlite3_mprintf("PRAGMA '%q'.table_xinfo('%q')", zDb, zThis);
-  }
-  if( !zPragma ){
-    return SQLITE_NOMEM;
-  }
-
-  rc = sqlite3_prepare_v2(db, zPragma, -1, &pStmt, 0);
-  sqlite3_free(zPragma);
-  if( rc!=SQLITE_OK ){
-    return rc;
-  }
-
-  nByte = nThis + 1;
-  bRowid = (pbRowid!=0);
-  while( SQLITE_ROW==sqlite3_step(pStmt) ){
-    nByte += sqlite3_column_bytes(pStmt, 1);          /* name */
-    nByte += sqlite3_column_bytes(pStmt, 4);          /* dflt_value */
-    if( sqlite3_column_int(pStmt, 6)==0 ){            /* !hidden */
-      nDbCol++;
-    }
-    if( sqlite3_column_int(pStmt, 5) ) bRowid = 0;    /* pk */
-  }
-  if( nDbCol==0 ) bRowid = 0;
-  nDbCol += bRowid;
-  nByte += strlen(SESSIONS_ROWID);
-  rc = sqlite3_reset(pStmt);
-
-  if( rc==SQLITE_OK ){
-    nByte += nDbCol * (sizeof(const char *)*2 +sizeof(int)+sizeof(u8) + 1 + 1);
-    pAlloc = sessionMalloc64(pSession, nByte);
-    if( pAlloc==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      memset(pAlloc, 0, nByte);
-    }
-  }
-  if( rc==SQLITE_OK ){
-    azCol = (char **)pAlloc;
-    azDflt = (char**)&azCol[nDbCol];
-    aiIdx = (int*)&azDflt[nDbCol];
-    abPK = (u8 *)&aiIdx[nDbCol];
-    pAlloc = &abPK[nDbCol];
-    if( pzTab ){
-      memcpy(pAlloc, zThis, nThis+1);
-      *pzTab = (char *)pAlloc;
-      pAlloc += nThis+1;
-    }
-
-    i = 0;
-    if( bRowid ){
-      size_t nName = strlen(SESSIONS_ROWID);
-      memcpy(pAlloc, SESSIONS_ROWID, nName+1);
-      azCol[i] = (char*)pAlloc;
-      pAlloc += nName+1;
-      abPK[i] = 1;
-      aiIdx[i] = -1;
-      i++;
-    }
-    while( SQLITE_ROW==sqlite3_step(pStmt) ){
-      if( sqlite3_column_int(pStmt, 6)==0 ){            /* !hidden */
-        int nName = sqlite3_column_bytes(pStmt, 1);
-        int nDflt = sqlite3_column_bytes(pStmt, 4);
-        const unsigned char *zName = sqlite3_column_text(pStmt, 1);
-        const unsigned char *zDflt = sqlite3_column_text(pStmt, 4);
-
-        if( zName==0 ) break;
-        memcpy(pAlloc, zName, nName+1);
-        azCol[i] = (char *)pAlloc;
-        pAlloc += nName+1;
-        if( zDflt ){
-          memcpy(pAlloc, zDflt, nDflt+1);
-          azDflt[i] = (char *)pAlloc;
-          pAlloc += nDflt+1;
-        }else{
-          azDflt[i] = 0;
-        }
-        abPK[i] = sqlite3_column_int(pStmt, 5);
-        aiIdx[i] = sqlite3_column_int(pStmt, 0);
-        i++;
-      }
-      if( pnTotalCol ) (*pnTotalCol)++;
-    }
-    rc = sqlite3_reset(pStmt);
-  }
-
-  /* If successful, populate the output variables. Otherwise, zero them and
-  ** free any allocation made. An error code will be returned in this case.
-  */
-  if( rc==SQLITE_OK ){
-    *pazCol = (const char**)azCol;
-    if( pazDflt ) *pazDflt = (const char**)azDflt;
-    *pabPK = abPK;
-    *pnCol = nDbCol;
-    if( paiIdx ) *paiIdx = aiIdx;
-  }else{
-    sessionFree(pSession, azCol);
-  }
-  if( pbRowid ) *pbRowid = bRowid;
-  sqlite3_finalize(pStmt);
-  return rc;
-}
-
-/*
-** This function is called to initialize the SessionTable.nCol, azCol[]
-** abPK[] and azDflt[] members of SessionTable object pTab. If these
-** fields are already initialized, this function is a no-op.
-**
-** If an error occurs, an error code is stored in sqlite3_session.rc and
-** non-zero returned. Or, if no error occurs but the table has no primary
-** key, sqlite3_session.rc is left set to SQLITE_OK and non-zero returned to
-** indicate that updates on this table should be ignored. SessionTable.abPK
-** is set to NULL in this case.
-*/
-static int sessionInitTable(
-  sqlite3_session *pSession,      /* Optional session handle */
-  SessionTable *pTab,             /* Table object to initialize */
-  sqlite3 *db,                    /* Database handle to read schema from */
-  const char *zDb                 /* Name of db - "main", "temp" etc. */
-){
-  int rc = SQLITE_OK;
-
-  if( pTab->nCol==0 ){
-    u8 *abPK;
-    assert( pTab->azCol==0 || pTab->abPK==0 );
-    sqlite3_free(pTab->azCol);
-    pTab->abPK = 0;
-    rc = sessionTableInfo(pSession, db, zDb,
-        pTab->zName, &pTab->nCol, &pTab->nTotalCol, 0, &pTab->azCol,
-        &pTab->azDflt, &pTab->aiIdx, &abPK,
-        ((pSession==0 || pSession->bImplicitPK) ? &pTab->bRowid : 0)
-    );
-    if( rc==SQLITE_OK ){
-      int i;
-      for(i=0; i<pTab->nCol; i++){
-        if( abPK[i] ){
-          pTab->abPK = abPK;
-          break;
-        }
-      }
-      if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){
-        pTab->bStat1 = 1;
-      }
-
-      if( pSession && pSession->bEnableSize ){
-        pSession->nMaxChangesetSize += (
-          1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
-        );
-      }
-    }
-  }
-
-  if( pSession ){
-    pSession->rc = rc;
-    return (rc || pTab->abPK==0);
-  }
-  return rc;
-}
-
-/*
-** Re-initialize table object pTab.
-*/
-static int sessionReinitTable(sqlite3_session *pSession, SessionTable *pTab){
-  int nCol = 0;
-  int nTotalCol = 0;
-  const char **azCol = 0;
-  const char **azDflt = 0;
-  int *aiIdx = 0;
-  u8 *abPK = 0;
-  int bRowid = 0;
-
-  assert( pSession->rc==SQLITE_OK );
-
-  pSession->rc = sessionTableInfo(pSession, pSession->db, pSession->zDb,
-      pTab->zName, &nCol, &nTotalCol, 0, &azCol, &azDflt, &aiIdx, &abPK,
-      (pSession->bImplicitPK ? &bRowid : 0)
-  );
-  if( pSession->rc==SQLITE_OK ){
-    if( pTab->nCol>nCol || pTab->bRowid!=bRowid ){
-      pSession->rc = SQLITE_SCHEMA;
-    }else{
-      int ii;
-      int nOldCol = pTab->nCol;
-      for(ii=0; ii<nCol; ii++){
-        if( ii<pTab->nCol ){
-          if( pTab->abPK[ii]!=abPK[ii] ){
-            pSession->rc = SQLITE_SCHEMA;
-          }
-        }else if( abPK[ii] ){
-          pSession->rc = SQLITE_SCHEMA;
-        }
-      }
-
-      if( pSession->rc==SQLITE_OK ){
-        const char **a = pTab->azCol;
-        pTab->azCol = azCol;
-        pTab->nCol = nCol;
-        pTab->nTotalCol = nTotalCol;
-        pTab->azDflt = azDflt;
-        pTab->abPK = abPK;
-        pTab->aiIdx = aiIdx;
-        azCol = a;
-      }
-      if( pSession->bEnableSize ){
-        pSession->nMaxChangesetSize += (nCol - nOldCol);
-        pSession->nMaxChangesetSize += sessionVarintLen(nCol);
-        pSession->nMaxChangesetSize -= sessionVarintLen(nOldCol);
-      }
-    }
-  }
-
-  sqlite3_free((char*)azCol);
-  return pSession->rc;
-}
-
-/*
-** Session-change object (*pp) contains an old.* record with fewer than
-** nCol fields. This function updates it with the default values for
-** the missing fields.
-*/
-static void sessionUpdateOneChange(
-  sqlite3_session *pSession,      /* For memory accounting */
-  int *pRc,                       /* IN/OUT: Error code */
-  SessionChange **pp,             /* IN/OUT: Change object to update */
-  int nCol,                       /* Number of columns now in table */
-  sqlite3_stmt *pDflt             /* SELECT <default-values...> */
-){
-  SessionChange *pOld = *pp;
-
-  while( pOld->nRecordField<nCol ){
-    SessionChange *pNew = 0;
-    int nByte = 0;
-    int nIncr = 0;
-    int iField = pOld->nRecordField;
-    int eType = sqlite3_column_type(pDflt, iField);
-    switch( eType ){
-      case SQLITE_NULL:
-        nIncr = 1;
-        break;
-      case SQLITE_INTEGER:
-      case SQLITE_FLOAT:
-        nIncr = 9;
-        break;
-      default: {
-        int n = sqlite3_column_bytes(pDflt, iField);
-        nIncr = 1 + sessionVarintLen(n) + n;
-        assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
-        break;
-      }
-    }
-
-    nByte = nIncr + (sizeof(SessionChange) + pOld->nRecord);
-    pNew = sessionMalloc64(pSession, nByte);
-    if( pNew==0 ){
-      *pRc = SQLITE_NOMEM;
-      return;
-    }else{
-      memcpy(pNew, pOld, sizeof(SessionChange));
-      pNew->aRecord = (u8*)&pNew[1];
-      memcpy(pNew->aRecord, pOld->aRecord, pOld->nRecord);
-      pNew->aRecord[pNew->nRecord++] = (u8)eType;
-      switch( eType ){
-        case SQLITE_INTEGER: {
-          i64 iVal = sqlite3_column_int64(pDflt, iField);
-          sessionPutI64(&pNew->aRecord[pNew->nRecord], iVal);
-          pNew->nRecord += 8;
-          break;
-        }
-
-        case SQLITE_FLOAT: {
-          double rVal = sqlite3_column_double(pDflt, iField);
-          sessionPutDouble(&pNew->aRecord[pNew->nRecord], rVal);
-          pNew->nRecord += 8;
-          break;
-        }
-
-        case SQLITE_TEXT: {
-          int n = sqlite3_column_bytes(pDflt, iField);
-          const char *z = (const char*)sqlite3_column_text(pDflt, iField);
-          pNew->nRecord += sessionVarintPut(&pNew->aRecord[pNew->nRecord], n);
-          memcpy(&pNew->aRecord[pNew->nRecord], z, n);
-          pNew->nRecord += n;
-          break;
-        }
-
-        case SQLITE_BLOB: {
-          int n = sqlite3_column_bytes(pDflt, iField);
-          const u8 *z = (const u8*)sqlite3_column_blob(pDflt, iField);
-          pNew->nRecord += sessionVarintPut(&pNew->aRecord[pNew->nRecord], n);
-          memcpy(&pNew->aRecord[pNew->nRecord], z, n);
-          pNew->nRecord += n;
-          break;
-        }
-
-        default:
-          assert( eType==SQLITE_NULL );
-          break;
-      }
-
-      sessionFree(pSession, pOld);
-      *pp = pOld = pNew;
-      pNew->nRecordField++;
-      pNew->nMaxSize += nIncr;
-      if( pSession ){
-        pSession->nMaxChangesetSize += nIncr;
-      }
-    }
-  }
-}
-
-/*
-** Ensure that there is room in the buffer to append nByte bytes of data.
-** If not, use sqlite3_realloc() to grow the buffer so that there is.
-**
-** If successful, return zero. Otherwise, if an OOM condition is encountered,
-** set *pRc to SQLITE_NOMEM and return non-zero.
-*/
-static int sessionBufferGrow(SessionBuffer *p, i64 nByte, int *pRc){
-#define SESSION_MAX_BUFFER_SZ (0x7FFFFF00 - 1)
-  i64 nReq = p->nBuf + nByte;
-  if( *pRc==SQLITE_OK && nReq>p->nAlloc ){
-    u8 *aNew;
-    i64 nNew = p->nAlloc ? p->nAlloc : 128;
-
-    do {
-      nNew = nNew*2;
-    }while( nNew<nReq );
-
-    /* The value of SESSION_MAX_BUFFER_SZ is copied from the implementation
-    ** of sqlite3_realloc64(). Allocations greater than this size in bytes
-    ** always fail. It is used here to ensure that this routine can always
-    ** allocate up to this limit - instead of up to the largest power of
-    ** two smaller than the limit.  */
-    if( nNew>SESSION_MAX_BUFFER_SZ ){
-      nNew = SESSION_MAX_BUFFER_SZ;
-      if( nNew<nReq ){
-        *pRc = SQLITE_NOMEM;
-        return 1;
-      }
-    }
-
-    aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
-    if( 0==aNew ){
-      *pRc = SQLITE_NOMEM;
-    }else{
-      p->aBuf = aNew;
-      p->nAlloc = nNew;
-    }
-  }
-  return (*pRc!=SQLITE_OK);
-}
-
-
-/*
-** This function is a no-op if *pRc is other than SQLITE_OK when it is
-** called. Otherwise, append a string to the buffer. All bytes in the string
-** up to (but not including) the nul-terminator are written to the buffer.
-**
-** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
-** returning.
-*/
-static void sessionAppendStr(
-  SessionBuffer *p,
-  const char *zStr,
-  int *pRc
-){
-  int nStr = sqlite3Strlen30(zStr);
-  if( 0==sessionBufferGrow(p, nStr+1, pRc) ){
-    memcpy(&p->aBuf[p->nBuf], zStr, nStr);
-    p->nBuf += nStr;
-    p->aBuf[p->nBuf] = 0x00;
-  }
-}
-
-/*
-** Format a string using printf() style formatting and then append it to the
-** buffer using sessionAppendString().
-*/
-static void sessionAppendPrintf(
-  SessionBuffer *p,               /* Buffer to append to */
-  int *pRc,
-  const char *zFmt,
-  ...
-){
-  if( *pRc==SQLITE_OK ){
-    char *zApp = 0;
-    va_list ap;
-    va_start(ap, zFmt);
-    zApp = sqlite3_vmprintf(zFmt, ap);
-    if( zApp==0 ){
-      *pRc = SQLITE_NOMEM;
-    }else{
-      sessionAppendStr(p, zApp, pRc);
-    }
-    va_end(ap);
-    sqlite3_free(zApp);
-  }
-}
-
-/*
-** Prepare a statement against database handle db that SELECTs a single
-** row containing the default values for each column in table pTab. For
-** example, if pTab is declared as:
-**
-**   CREATE TABLE pTab(a PRIMARY KEY, b DEFAULT 123, c DEFAULT 'abcd');
-**
-** Then this function prepares and returns the SQL statement:
-**
-**   SELECT NULL, 123, 'abcd';
-*/
-static int sessionPrepareDfltStmt(
-  sqlite3 *db,                    /* Database handle */
-  SessionTable *pTab,             /* Table to prepare statement for */
-  sqlite3_stmt **ppStmt           /* OUT: Statement handle */
-){
-  SessionBuffer sql = {0,0,0};
-  int rc = SQLITE_OK;
-  const char *zSep = " ";
-  int ii = 0;
-
-  *ppStmt = 0;
-  sessionAppendPrintf(&sql, &rc, "SELECT");
-  for(ii=0; ii<pTab->nCol; ii++){
-    const char *zDflt = pTab->azDflt[ii] ? pTab->azDflt[ii] : "NULL";
-    sessionAppendPrintf(&sql, &rc, "%s%s", zSep, zDflt);
-    zSep = ", ";
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_prepare_v2(db, (const char*)sql.aBuf, -1, ppStmt, 0);
-  }
-  sqlite3_free(sql.aBuf);
-
-  return rc;
-}
-
-/*
-** Table pTab has one or more existing change-records with old.* records
-** with fewer than pTab->nCol columns. This function updates all such
-** change-records with the default values for the missing columns.
-*/
-static int sessionUpdateChanges(sqlite3_session *pSession, SessionTable *pTab){
-  sqlite3_stmt *pStmt = 0;
-  int rc = pSession->rc;
-
-  rc = sessionPrepareDfltStmt(pSession->db, pTab, &pStmt);
-  if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
-    int ii = 0;
-    SessionChange **pp = 0;
-    for(ii=0; ii<pTab->nChange; ii++){
-      for(pp=&pTab->apChange[ii]; *pp; pp=&((*pp)->pNext)){
-        if( (*pp)->nRecordField!=pTab->nCol ){
-          sessionUpdateOneChange(pSession, &rc, pp, pTab->nCol, pStmt);
-        }
-      }
-    }
-  }
-
-  pSession->rc = rc;
-  rc = sqlite3_finalize(pStmt);
-  if( pSession->rc==SQLITE_OK ) pSession->rc = rc;
-  return pSession->rc;
-}
-
-/*
-** Versions of the four methods in object SessionHook for use with the
-** sqlite_stat1 table. The purpose of this is to substitute a zero-length
-** blob each time a NULL value is read from the "idx" column of the
-** sqlite_stat1 table.
-*/
-typedef struct SessionStat1Ctx SessionStat1Ctx;
-struct SessionStat1Ctx {
-  SessionHook hook;
-  sqlite3_session *pSession;
-};
-static int sessionStat1Old(void *pCtx, int iCol, sqlite3_value **ppVal){
-  SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
-  sqlite3_value *pVal = 0;
-  int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
-  if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
-    pVal = p->pSession->pZeroBlob;
-  }
-  *ppVal = pVal;
-  return rc;
-}
-static int sessionStat1New(void *pCtx, int iCol, sqlite3_value **ppVal){
-  SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
-  sqlite3_value *pVal = 0;
-  int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
-  if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
-    pVal = p->pSession->pZeroBlob;
-  }
-  *ppVal = pVal;
-  return rc;
-}
-static int sessionStat1Count(void *pCtx){
-  SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
-  return p->hook.xCount(p->hook.pCtx);
-}
-static int sessionStat1Depth(void *pCtx){
-  SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
-  return p->hook.xDepth(p->hook.pCtx);
-}
-
-static int sessionUpdateMaxSize(
-  int op,
-  sqlite3_session *pSession,      /* Session object pTab is attached to */
-  SessionTable *pTab,             /* Table that change applies to */
-  SessionChange *pC               /* Update pC->nMaxSize */
-){
-  i64 nNew = 2;
-  if( pC->op==SQLITE_INSERT ){
-    if( pTab->bRowid ) nNew += 9;
-    if( op!=SQLITE_DELETE ){
-      int ii;
-      for(ii=0; ii<pTab->nCol; ii++){
-        sqlite3_value *p = 0;
-        pSession->hook.xNew(pSession->hook.pCtx, pTab->aiIdx[ii], &p);
-        sessionSerializeValue(0, p, &nNew);
-      }
-    }
-  }else if( op==SQLITE_DELETE ){
-    nNew += pC->nRecord;
-    if( sqlite3_preupdate_blobwrite(pSession->db)>=0 ){
-      nNew += pC->nRecord;
-    }
-  }else{
-    int ii;
-    u8 *pCsr = pC->aRecord;
-    if( pTab->bRowid ){
-      nNew += 9 + 1;
-      pCsr += 9;
-    }
-    for(ii=pTab->bRowid; ii<pTab->nCol; ii++){
-      int bChanged = 1;
-      int nOld = 0;
-      int eType;
-      int iIdx = pTab->aiIdx[ii];
-      sqlite3_value *p = 0;
-      pSession->hook.xNew(pSession->hook.pCtx, iIdx, &p);
-      if( p==0 ){
-        return SQLITE_NOMEM;
-      }
-
-      eType = *pCsr++;
-      switch( eType ){
-        case SQLITE_NULL:
-          bChanged = sqlite3_value_type(p)!=SQLITE_NULL;
-          break;
-
-        case SQLITE_FLOAT:
-        case SQLITE_INTEGER: {
-          if( eType==sqlite3_value_type(p) ){
-            sqlite3_int64 iVal = sessionGetI64(pCsr);
-            if( eType==SQLITE_INTEGER ){
-              bChanged = (iVal!=sqlite3_value_int64(p));
-            }else{
-              double dVal;
-              memcpy(&dVal, &iVal, 8);
-              bChanged = (dVal!=sqlite3_value_double(p));
-            }
-          }
-          nOld = 8;
-          pCsr += 8;
-          break;
-        }
-
-        default: {
-          int nByte;
-          nOld = sessionVarintGet(pCsr, &nByte);
-          pCsr += nOld;
-          nOld += nByte;
-          assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
-          if( eType==sqlite3_value_type(p)
-           && nByte==sqlite3_value_bytes(p)
-           && (nByte==0 || 0==memcmp(pCsr, sqlite3_value_blob(p), nByte))
-          ){
-            bChanged = 0;
-          }
-          pCsr += nByte;
-          break;
-        }
-      }
-
-      if( bChanged && pTab->abPK[ii] ){
-        nNew = pC->nRecord + 2;
-        break;
-      }
-
-      if( bChanged ){
-        nNew += 1 + nOld;
-        sessionSerializeValue(0, p, &nNew);
-      }else if( pTab->abPK[ii] ){
-        nNew += 2 + nOld;
-      }else{
-        nNew += 2;
-      }
-    }
-  }
-
-  if( nNew>pC->nMaxSize ){
-    int nIncr = nNew - pC->nMaxSize;
-    pC->nMaxSize = nNew;
-    pSession->nMaxChangesetSize += nIncr;
-  }
-  return SQLITE_OK;
-}
-
-/*
-** This function is only called from with a pre-update-hook reporting a
-** change on table pTab (attached to session pSession). The type of change
-** (UPDATE, INSERT, DELETE) is specified by the first argument.
-**
-** Unless one is already present or an error occurs, an entry is added
-** to the changed-rows hash table associated with table pTab.
-*/
-static void sessionPreupdateOneChange(
-  int op,                         /* One of SQLITE_UPDATE, INSERT, DELETE */
-  i64 iRowid,
-  sqlite3_session *pSession,      /* Session object pTab is attached to */
-  SessionTable *pTab              /* Table that change applies to */
-){
-  int iHash;
-  int bNull = 0;
-  int rc = SQLITE_OK;
-  int nExpect = 0;
-  SessionStat1Ctx stat1 = {{0,0,0,0,0},0};
-
-  if( pSession->rc ) return;
-
-  /* Load table details if required */
-  if( sessionInitTable(pSession, pTab, pSession->db, pSession->zDb) ) return;
-
-  /* Check the number of columns in this xPreUpdate call matches the
-  ** number of columns in the table.  */
-  nExpect = pSession->hook.xCount(pSession->hook.pCtx);
-  if( pTab->nTotalCol<nExpect ){
-    if( sessionReinitTable(pSession, pTab) ) return;
-    if( sessionUpdateChanges(pSession, pTab) ) return;
-  }
-  if( pTab->nTotalCol!=nExpect ){
-    pSession->rc = SQLITE_SCHEMA;
-    return;
-  }
-
-  /* Grow the hash table if required */
-  if( sessionGrowHash(pSession, 0, pTab) ){
-    pSession->rc = SQLITE_NOMEM;
-    return;
-  }
-
-  if( pTab->bStat1 ){
-    stat1.hook = pSession->hook;
-    stat1.pSession = pSession;
-    pSession->hook.pCtx = (void*)&stat1;
-    pSession->hook.xNew = sessionStat1New;
-    pSession->hook.xOld = sessionStat1Old;
-    pSession->hook.xCount = sessionStat1Count;
-    pSession->hook.xDepth = sessionStat1Depth;
-    if( pSession->pZeroBlob==0 ){
-      sqlite3_value *p = sqlite3ValueNew(0);
-      if( p==0 ){
-        rc = SQLITE_NOMEM;
-        goto error_out;
-      }
-      sqlite3ValueSetStr(p, 0, "", 0, SQLITE_STATIC);
-      pSession->pZeroBlob = p;
-    }
-  }
-
-  /* Calculate the hash-key for this change. If the primary key of the row
-  ** includes a NULL value, exit early. Such changes are ignored by the
-  ** session module. */
-  rc = sessionPreupdateHash(
-      pSession, iRowid, pTab, op==SQLITE_INSERT, &iHash, &bNull
-  );
-  if( rc!=SQLITE_OK ) goto error_out;
-
-  if( bNull==0 ){
-    /* Search the hash table for an existing record for this row. */
-    SessionChange *pC;
-    for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
-      if( sessionPreupdateEqual(pSession, iRowid, pTab, pC, op) ) break;
-    }
-
-    if( pC==0 ){
-      /* Create a new change object containing all the old values (if
-      ** this is an SQLITE_UPDATE or SQLITE_DELETE), or just the PK
-      ** values (if this is an INSERT). */
-      sqlite3_int64 nByte;    /* Number of bytes to allocate */
-      int i;                  /* Used to iterate through columns */
-
-      assert( rc==SQLITE_OK );
-      pTab->nEntry++;
-
-      /* Figure out how large an allocation is required */
-      nByte = sizeof(SessionChange);
-      for(i=pTab->bRowid; i<pTab->nCol; i++){
-        int iIdx = pTab->aiIdx[i];
-        sqlite3_value *p = 0;
-        if( op!=SQLITE_INSERT ){
-          /* This may fail if the column has a non-NULL default and was added
-          ** using ALTER TABLE ADD COLUMN after this record was created. */
-          rc = pSession->hook.xOld(pSession->hook.pCtx, iIdx, &p);
-        }else if( pTab->abPK[i] ){
-          TESTONLY(int trc = ) pSession->hook.xNew(pSession->hook.pCtx,iIdx,&p);
-          assert( trc==SQLITE_OK );
-        }
-
-        if( rc==SQLITE_OK ){
-          /* This may fail if SQLite value p contains a utf-16 string that must
-          ** be converted to utf-8 and an OOM error occurs while doing so. */
-          rc = sessionSerializeValue(0, p, &nByte);
-        }
-        if( rc!=SQLITE_OK ) goto error_out;
-      }
-      if( pTab->bRowid ){
-        nByte += 9;               /* Size of rowid field - an integer */
-      }
-
-      /* Allocate the change object */
-      pC = (SessionChange*)sessionMalloc64(pSession, nByte);
-      if( !pC ){
-        rc = SQLITE_NOMEM;
-        goto error_out;
-      }else{
-        memset(pC, 0, sizeof(SessionChange));
-        pC->aRecord = (u8 *)&pC[1];
-      }
-
-      /* Populate the change object. None of the preupdate_old(),
-      ** preupdate_new() or SerializeValue() calls below may fail as all
-      ** required values and encodings have already been cached in memory.
-      ** It is not possible for an OOM to occur in this block. */
-      nByte = 0;
-      if( pTab->bRowid ){
-        pC->aRecord[0] = SQLITE_INTEGER;
-        sessionPutI64(&pC->aRecord[1], iRowid);
-        nByte = 9;
-      }
-      for(i=pTab->bRowid; i<pTab->nCol; i++){
-        sqlite3_value *p = 0;
-        int iIdx = pTab->aiIdx[i];
-        if( op!=SQLITE_INSERT ){
-          pSession->hook.xOld(pSession->hook.pCtx, iIdx, &p);
-        }else if( pTab->abPK[i] ){
-          pSession->hook.xNew(pSession->hook.pCtx, iIdx, &p);
-        }
-        sessionSerializeValue(&pC->aRecord[nByte], p, &nByte);
-      }
-
-      /* Add the change to the hash-table */
-      if( pSession->bIndirect || pSession->hook.xDepth(pSession->hook.pCtx) ){
-        pC->bIndirect = 1;
-      }
-      pC->nRecordField = pTab->nCol;
-      pC->nRecord = nByte;
-      pC->op = op;
-      pC->pNext = pTab->apChange[iHash];
-      pTab->apChange[iHash] = pC;
-
-    }else if( pC->bIndirect ){
-      /* If the existing change is considered "indirect", but this current
-      ** change is "direct", mark the change object as direct. */
-      if( pSession->hook.xDepth(pSession->hook.pCtx)==0
-       && pSession->bIndirect==0
-      ){
-        pC->bIndirect = 0;
-      }
-    }
-
-    assert( rc==SQLITE_OK );
-    if( pSession->bEnableSize ){
-      rc = sessionUpdateMaxSize(op, pSession, pTab, pC);
-    }
-  }
-
-
-  /* If an error has occurred, mark the session object as failed. */
- error_out:
-  if( pTab->bStat1 ){
-    pSession->hook = stat1.hook;
-  }
-  if( rc!=SQLITE_OK ){
-    pSession->rc = rc;
-  }
-}
-
-static int sessionFindTable(
-  sqlite3_session *pSession,
-  const char *zName,
-  SessionTable **ppTab
-){
-  int rc = SQLITE_OK;
-  int nName = sqlite3Strlen30(zName);
-  SessionTable *pRet;
-
-  /* Search for an existing table */
-  for(pRet=pSession->pTable; pRet; pRet=pRet->pNext){
-    if( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) ) break;
-  }
-
-  if( pRet==0 && pSession->bAutoAttach ){
-    /* If there is a table-filter configured, invoke it. If it returns 0,
-    ** do not automatically add the new table. */
-    if( pSession->xTableFilter==0
-     || pSession->xTableFilter(pSession->pFilterCtx, zName)
-    ){
-      rc = sqlite3session_attach(pSession, zName);
-      if( rc==SQLITE_OK ){
-        pRet = pSession->pTable;
-        while( ALWAYS(pRet) && pRet->pNext ){
-          pRet = pRet->pNext;
-        }
-        assert( pRet!=0 );
-        assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
-      }
-    }
-  }
-
-  assert( rc==SQLITE_OK || pRet==0 );
-  *ppTab = pRet;
-  return rc;
-}
-
-/*
-** The 'pre-update' hook registered by this module with SQLite databases.
-*/
-static 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) */
-){
-  sqlite3_session *pSession;
-  int nDb = sqlite3Strlen30(zDb);
-
-  assert( sqlite3_mutex_held(db->mutex) );
-  (void)iKey1;
-  (void)iKey2;
-
-  for(pSession=(sqlite3_session *)pCtx; pSession; pSession=pSession->pNext){
-    SessionTable *pTab;
-
-    /* If this session is attached to a different database ("main", "temp"
-    ** etc.), or if it is not currently enabled, there is nothing to do. Skip
-    ** to the next session object attached to this database. */
-    if( pSession->bEnable==0 ) continue;
-    if( pSession->rc ) continue;
-    if( sqlite3_strnicmp(zDb, pSession->zDb, nDb+1) ) continue;
-
-    pSession->rc = sessionFindTable(pSession, zName, &pTab);
-    if( pTab ){
-      assert( pSession->rc==SQLITE_OK );
-      assert( op==SQLITE_UPDATE || iKey1==iKey2 );
-      sessionPreupdateOneChange(op, iKey1, pSession, pTab);
-      if( op==SQLITE_UPDATE ){
-        sessionPreupdateOneChange(SQLITE_INSERT, iKey2, pSession, pTab);
-      }
-    }
-  }
-}
-
-/*
-** The pre-update hook implementations.
-*/
-static int sessionPreupdateOld(void *pCtx, int iVal, sqlite3_value **ppVal){
-  return sqlite3_preupdate_old((sqlite3*)pCtx, iVal, ppVal);
-}
-static int sessionPreupdateNew(void *pCtx, int iVal, sqlite3_value **ppVal){
-  return sqlite3_preupdate_new((sqlite3*)pCtx, iVal, ppVal);
-}
-static int sessionPreupdateCount(void *pCtx){
-  return sqlite3_preupdate_count((sqlite3*)pCtx);
-}
-static int sessionPreupdateDepth(void *pCtx){
-  return sqlite3_preupdate_depth((sqlite3*)pCtx);
-}
-
-/*
-** Install the pre-update hooks on the session object passed as the only
-** argument.
-*/
-static void sessionPreupdateHooks(
-  sqlite3_session *pSession
-){
-  pSession->hook.pCtx = (void*)pSession->db;
-  pSession->hook.xOld = sessionPreupdateOld;
-  pSession->hook.xNew = sessionPreupdateNew;
-  pSession->hook.xCount = sessionPreupdateCount;
-  pSession->hook.xDepth = sessionPreupdateDepth;
-}
-
-typedef struct SessionDiffCtx SessionDiffCtx;
-struct SessionDiffCtx {
-  sqlite3_stmt *pStmt;
-  int bRowid;
-  int nOldOff;
-};
-
-/*
-** The diff hook implementations.
-*/
-static int sessionDiffOld(void *pCtx, int iVal, sqlite3_value **ppVal){
-  SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
-  *ppVal = sqlite3_column_value(p->pStmt, iVal+p->nOldOff+p->bRowid);
-  return SQLITE_OK;
-}
-static int sessionDiffNew(void *pCtx, int iVal, sqlite3_value **ppVal){
-  SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
-  *ppVal = sqlite3_column_value(p->pStmt, iVal+p->bRowid);
-   return SQLITE_OK;
-}
-static int sessionDiffCount(void *pCtx){
-  SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
-  return (p->nOldOff ? p->nOldOff : sqlite3_column_count(p->pStmt)) - p->bRowid;
-}
-static int sessionDiffDepth(void *pCtx){
-  (void)pCtx;
-  return 0;
-}
-
-/*
-** Install the diff hooks on the session object passed as the only
-** argument.
-*/
-static void sessionDiffHooks(
-  sqlite3_session *pSession,
-  SessionDiffCtx *pDiffCtx
-){
-  pSession->hook.pCtx = (void*)pDiffCtx;
-  pSession->hook.xOld = sessionDiffOld;
-  pSession->hook.xNew = sessionDiffNew;
-  pSession->hook.xCount = sessionDiffCount;
-  pSession->hook.xDepth = sessionDiffDepth;
-}
-
-static char *sessionExprComparePK(
-  int nCol,
-  const char *zDb1, const char *zDb2,
-  const char *zTab,
-  const char **azCol, u8 *abPK
-){
-  int i;
-  const char *zSep = "";
-  char *zRet = 0;
-
-  for(i=0; i<nCol; i++){
-    if( abPK[i] ){
-      zRet = sqlite3_mprintf("%z%s\"%w\".\"%w\".\"%w\"=\"%w\".\"%w\".\"%w\"",
-          zRet, zSep, zDb1, zTab, azCol[i], zDb2, zTab, azCol[i]
-      );
-      zSep = " AND ";
-      if( zRet==0 ) break;
-    }
-  }
-
-  return zRet;
-}
-
-static char *sessionExprCompareOther(
-  int nCol,
-  const char *zDb1, const char *zDb2,
-  const char *zTab,
-  const char **azCol, u8 *abPK
-){
-  int i;
-  const char *zSep = "";
-  char *zRet = 0;
-  int bHave = 0;
-
-  for(i=0; i<nCol; i++){
-    if( abPK[i]==0 ){
-      bHave = 1;
-      zRet = sqlite3_mprintf(
-          "%z%s\"%w\".\"%w\".\"%w\" IS NOT \"%w\".\"%w\".\"%w\"",
-          zRet, zSep, zDb1, zTab, azCol[i], zDb2, zTab, azCol[i]
-      );
-      zSep = " OR ";
-      if( zRet==0 ) break;
-    }
-  }
-
-  if( bHave==0 ){
-    assert( zRet==0 );
-    zRet = sqlite3_mprintf("0");
-  }
-
-  return zRet;
-}
-
-static char *sessionSelectFindNew(
-  const char *zDb1,      /* Pick rows in this db only */
-  const char *zDb2,      /* But not in this one */
-  int bRowid,
-  const char *zTbl,      /* Table name */
-  const char *zExpr
-){
-  const char *zSel = (bRowid ? SESSIONS_ROWID ", *" : "*");
-  char *zRet = sqlite3_mprintf(
-      "SELECT %s FROM \"%w\".\"%w\" WHERE NOT EXISTS ("
-      "  SELECT 1 FROM \"%w\".\"%w\" WHERE %s"
-      ")",
-      zSel, zDb1, zTbl, zDb2, zTbl, zExpr
-  );
-  return zRet;
-}
-
-static int sessionDiffFindNew(
-  int op,
-  sqlite3_session *pSession,
-  SessionTable *pTab,
-  const char *zDb1,
-  const char *zDb2,
-  char *zExpr
-){
-  int rc = SQLITE_OK;
-  char *zStmt = sessionSelectFindNew(
-      zDb1, zDb2, pTab->bRowid, pTab->zName, zExpr
-  );
-
-  if( zStmt==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    sqlite3_stmt *pStmt;
-    rc = sqlite3_prepare(pSession->db, zStmt, -1, &pStmt, 0);
-    if( rc==SQLITE_OK ){
-      SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
-      pDiffCtx->pStmt = pStmt;
-      pDiffCtx->nOldOff = 0;
-      pDiffCtx->bRowid = pTab->bRowid;
-      while( SQLITE_ROW==sqlite3_step(pStmt) ){
-        i64 iRowid = (pTab->bRowid ? sqlite3_column_int64(pStmt, 0) : 0);
-        sessionPreupdateOneChange(op, iRowid, pSession, pTab);
-      }
-      rc = sqlite3_finalize(pStmt);
-    }
-    sqlite3_free(zStmt);
-  }
-
-  return rc;
-}
-
-/*
-** Return a comma-separated list of the fully-qualified (with both database
-** and table name) column names from table pTab. e.g.
-**
-**    "main"."t1"."a", "main"."t1"."b", "main"."t1"."c"
-*/
-static char *sessionAllCols(
-  const char *zDb,
-  SessionTable *pTab
-){
-  int ii;
-  char *zRet = 0;
-  for(ii=0; ii<pTab->nCol; ii++){
-    zRet = sqlite3_mprintf("%z%s\"%w\".\"%w\".\"%w\"",
-        zRet, (zRet ? ", " : ""), zDb, pTab->zName, pTab->azCol[ii]
-    );
-    if( !zRet ) break;
-  }
-  return zRet;
-}
-
-static int sessionDiffFindModified(
-  sqlite3_session *pSession,
-  SessionTable *pTab,
-  const char *zFrom,
-  const char *zExpr
-){
-  int rc = SQLITE_OK;
-
-  char *zExpr2 = sessionExprCompareOther(pTab->nCol,
-      pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
-  );
-  if( zExpr2==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    char *z1 = sessionAllCols(pSession->zDb, pTab);
-    char *z2 = sessionAllCols(zFrom, pTab);
-    char *zStmt = sqlite3_mprintf(
-        "SELECT %s,%s FROM \"%w\".\"%w\", \"%w\".\"%w\" WHERE %s AND (%z)",
-        z1, z2, pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
-    );
-    if( zStmt==0 || z1==0 || z2==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      sqlite3_stmt *pStmt;
-      rc = sqlite3_prepare(pSession->db, zStmt, -1, &pStmt, 0);
-
-      if( rc==SQLITE_OK ){
-        SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
-        pDiffCtx->pStmt = pStmt;
-        pDiffCtx->nOldOff = pTab->nCol;
-        while( SQLITE_ROW==sqlite3_step(pStmt) ){
-          i64 iRowid = (pTab->bRowid ? sqlite3_column_int64(pStmt, 0) : 0);
-          sessionPreupdateOneChange(SQLITE_UPDATE, iRowid, pSession, pTab);
-        }
-        rc = sqlite3_finalize(pStmt);
-      }
-    }
-    sqlite3_free(zStmt);
-    sqlite3_free(z1);
-    sqlite3_free(z2);
-  }
-
-  return rc;
-}
-
-SQLITE_API int sqlite3session_diff(
-  sqlite3_session *pSession,
-  const char *zFrom,
-  const char *zTbl,
-  char **pzErrMsg
-){
-  const char *zDb = pSession->zDb;
-  int rc = pSession->rc;
-  SessionDiffCtx d;
-
-  memset(&d, 0, sizeof(d));
-  sessionDiffHooks(pSession, &d);
-
-  sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
-  if( pzErrMsg ) *pzErrMsg = 0;
-  if( rc==SQLITE_OK ){
-    char *zExpr = 0;
-    sqlite3 *db = pSession->db;
-    SessionTable *pTo;            /* Table zTbl */
-
-    /* Locate and if necessary initialize the target table object */
-    pSession->bAutoAttach++;
-    rc = sessionFindTable(pSession, zTbl, &pTo);
-    pSession->bAutoAttach--;
-    if( pTo==0 ) goto diff_out;
-    if( sessionInitTable(pSession, pTo, pSession->db, pSession->zDb) ){
-      rc = pSession->rc;
-      goto diff_out;
-    }
-
-    /* Check the table schemas match */
-    if( rc==SQLITE_OK ){
-      int bHasPk = 0;
-      int bMismatch = 0;
-      int nCol = 0;               /* Columns in zFrom.zTbl */
-      int bRowid = 0;
-      u8 *abPK = 0;
-      const char **azCol = 0;
-      char *zDbExists = 0;
-
-      /* Check that database zFrom is attached.  */
-      zDbExists = sqlite3_mprintf("SELECT * FROM %Q.sqlite_schema", zFrom);
-      if( zDbExists==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        sqlite3_stmt *pDbExists = 0;
-        rc = sqlite3_prepare_v2(db, zDbExists, -1, &pDbExists, 0);
-        if( rc==SQLITE_ERROR ){
-          rc = SQLITE_OK;
-          nCol = -1;
-        }
-        sqlite3_finalize(pDbExists);
-        sqlite3_free(zDbExists);
-      }
-
-      if( rc==SQLITE_OK && nCol==0 ){
-        rc = sessionTableInfo(0, db, zFrom, zTbl,
-            &nCol, 0, 0, &azCol, 0, 0, &abPK,
-            pSession->bImplicitPK ? &bRowid : 0
-        );
-      }
-      if( rc==SQLITE_OK ){
-        if( pTo->nCol!=nCol ){
-          if( nCol<=0 ){
-            rc = SQLITE_SCHEMA;
-            if( pzErrMsg ){
-              *pzErrMsg = sqlite3_mprintf("no such table: %s.%s", zFrom, zTbl);
-            }
-          }else{
-            bMismatch = 1;
-          }
-        }else{
-          int i;
-          for(i=0; i<nCol; i++){
-            if( pTo->abPK[i]!=abPK[i] ) bMismatch = 1;
-            if( sqlite3_stricmp(azCol[i], pTo->azCol[i]) ) bMismatch = 1;
-            if( abPK[i] ) bHasPk = 1;
-          }
-        }
-      }
-      sqlite3_free((char*)azCol);
-      if( bMismatch ){
-        if( pzErrMsg ){
-          *pzErrMsg = sqlite3_mprintf("table schemas do not match");
-        }
-        rc = SQLITE_SCHEMA;
-      }
-      if( bHasPk==0 ){
-        /* Ignore tables with no primary keys */
-        goto diff_out;
-      }
-    }
-
-    if( rc==SQLITE_OK ){
-      zExpr = sessionExprComparePK(pTo->nCol,
-          zDb, zFrom, pTo->zName, pTo->azCol, pTo->abPK
-      );
-    }
-
-    /* Find new rows */
-    if( rc==SQLITE_OK ){
-      rc = sessionDiffFindNew(SQLITE_INSERT, pSession, pTo, zDb, zFrom, zExpr);
-    }
-
-    /* Find old rows */
-    if( rc==SQLITE_OK ){
-      rc = sessionDiffFindNew(SQLITE_DELETE, pSession, pTo, zFrom, zDb, zExpr);
-    }
-
-    /* Find modified rows */
-    if( rc==SQLITE_OK ){
-      rc = sessionDiffFindModified(pSession, pTo, zFrom, zExpr);
-    }
-
-    sqlite3_free(zExpr);
-  }
-
- diff_out:
-  sessionPreupdateHooks(pSession);
-  sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
-  return rc;
-}
-
-/*
-** Create a session object. This session object will record changes to
-** database zDb attached to connection db.
-*/
-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 */
-){
-  sqlite3_session *pNew;          /* Newly allocated session object */
-  sqlite3_session *pOld;          /* Session object already attached to db */
-  int nDb = sqlite3Strlen30(zDb); /* Length of zDb in bytes */
-
-  /* Zero the output value in case an error occurs. */
-  *ppSession = 0;
-
-  /* Allocate and populate the new session object. */
-  pNew = (sqlite3_session *)sqlite3_malloc64(sizeof(sqlite3_session) + nDb + 1);
-  if( !pNew ) return SQLITE_NOMEM;
-  memset(pNew, 0, sizeof(sqlite3_session));
-  pNew->db = db;
-  pNew->zDb = (char *)&pNew[1];
-  pNew->bEnable = 1;
-  memcpy(pNew->zDb, zDb, nDb+1);
-  sessionPreupdateHooks(pNew);
-
-  /* Add the new session object to the linked list of session objects
-  ** attached to database handle $db. Do this under the cover of the db
-  ** handle mutex.  */
-  sqlite3_mutex_enter(sqlite3_db_mutex(db));
-  pOld = (sqlite3_session*)sqlite3_preupdate_hook(db, xPreUpdate, (void*)pNew);
-  pNew->pNext = pOld;
-  sqlite3_mutex_leave(sqlite3_db_mutex(db));
-
-  *ppSession = pNew;
-  return SQLITE_OK;
-}
-
-/*
-** Free the list of table objects passed as the first argument. The contents
-** of the changed-rows hash tables are also deleted.
-*/
-static void sessionDeleteTable(sqlite3_session *pSession, SessionTable *pList){
-  SessionTable *pNext;
-  SessionTable *pTab;
-
-  for(pTab=pList; pTab; pTab=pNext){
-    int i;
-    pNext = pTab->pNext;
-    for(i=0; i<pTab->nChange; i++){
-      SessionChange *p;
-      SessionChange *pNextChange;
-      for(p=pTab->apChange[i]; p; p=pNextChange){
-        pNextChange = p->pNext;
-        sessionFree(pSession, p);
-      }
-    }
-    sqlite3_finalize(pTab->pDfltStmt);
-    sessionFree(pSession, (char*)pTab->azCol);  /* cast works around VC++ bug */
-    sessionFree(pSession, pTab->apChange);
-    sessionFree(pSession, pTab);
-  }
-}
-
-/*
-** Delete a session object previously allocated using sqlite3session_create().
-*/
-SQLITE_API void sqlite3session_delete(sqlite3_session *pSession){
-  sqlite3 *db = pSession->db;
-  sqlite3_session *pHead;
-  sqlite3_session **pp;
-
-  /* Unlink the session from the linked list of sessions attached to the
-  ** database handle. Hold the db mutex while doing so.  */
-  sqlite3_mutex_enter(sqlite3_db_mutex(db));
-  pHead = (sqlite3_session*)sqlite3_preupdate_hook(db, 0, 0);
-  for(pp=&pHead; ALWAYS((*pp)!=0); pp=&((*pp)->pNext)){
-    if( (*pp)==pSession ){
-      *pp = (*pp)->pNext;
-      if( pHead ) sqlite3_preupdate_hook(db, xPreUpdate, (void*)pHead);
-      break;
-    }
-  }
-  sqlite3_mutex_leave(sqlite3_db_mutex(db));
-  sqlite3ValueFree(pSession->pZeroBlob);
-
-  /* Delete all attached table objects. And the contents of their
-  ** associated hash-tables. */
-  sessionDeleteTable(pSession, pSession->pTable);
-
-  /* Free the session object. */
-  sqlite3_free(pSession);
-}
-
-/*
-** Set a table filter on a Session Object.
-*/
-SQLITE_API void sqlite3session_table_filter(
-  sqlite3_session *pSession,
-  int(*xFilter)(void*, const char*),
-  void *pCtx                      /* First argument passed to xFilter */
-){
-  pSession->bAutoAttach = 1;
-  pSession->pFilterCtx = pCtx;
-  pSession->xTableFilter = xFilter;
-}
-
-/*
-** Attach a table to a session. All subsequent changes made to the table
-** while the session object is enabled will be recorded.
-**
-** Only tables that have a PRIMARY KEY defined may be attached. It does
-** not matter if the PRIMARY KEY is an "INTEGER PRIMARY KEY" (rowid alias)
-** or not.
-*/
-SQLITE_API int sqlite3session_attach(
-  sqlite3_session *pSession,      /* Session object */
-  const char *zName               /* Table name */
-){
-  int rc = SQLITE_OK;
-  sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
-
-  if( !zName ){
-    pSession->bAutoAttach = 1;
-  }else{
-    SessionTable *pTab;           /* New table object (if required) */
-    int nName;                    /* Number of bytes in string zName */
-
-    /* First search for an existing entry. If one is found, this call is
-    ** a no-op. Return early. */
-    nName = sqlite3Strlen30(zName);
-    for(pTab=pSession->pTable; pTab; pTab=pTab->pNext){
-      if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
-    }
-
-    if( !pTab ){
-      /* Allocate new SessionTable object. */
-      int nByte = sizeof(SessionTable) + nName + 1;
-      pTab = (SessionTable*)sessionMalloc64(pSession, nByte);
-      if( !pTab ){
-        rc = SQLITE_NOMEM;
-      }else{
-        /* Populate the new SessionTable object and link it into the list.
-        ** The new object must be linked onto the end of the list, not
-        ** simply added to the start of it in order to ensure that tables
-        ** appear in the correct order when a changeset or patchset is
-        ** eventually generated. */
-        SessionTable **ppTab;
-        memset(pTab, 0, sizeof(SessionTable));
-        pTab->zName = (char *)&pTab[1];
-        memcpy(pTab->zName, zName, nName+1);
-        for(ppTab=&pSession->pTable; *ppTab; ppTab=&(*ppTab)->pNext);
-        *ppTab = pTab;
-      }
-    }
-  }
-
-  sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
-  return rc;
-}
-
-/*
-** Append the value passed as the second argument to the buffer passed
-** as the first.
-**
-** This function is a no-op if *pRc is non-zero when it is called.
-** Otherwise, if an error occurs, *pRc is set to an SQLite error code
-** before returning.
-*/
-static void sessionAppendValue(SessionBuffer *p, sqlite3_value *pVal, int *pRc){
-  int rc = *pRc;
-  if( rc==SQLITE_OK ){
-    sqlite3_int64 nByte = 0;
-    rc = sessionSerializeValue(0, pVal, &nByte);
-    sessionBufferGrow(p, nByte, &rc);
-    if( rc==SQLITE_OK ){
-      rc = sessionSerializeValue(&p->aBuf[p->nBuf], pVal, 0);
-      p->nBuf += nByte;
-    }else{
-      *pRc = rc;
-    }
-  }
-}
-
-/*
-** This function is a no-op if *pRc is other than SQLITE_OK when it is
-** called. Otherwise, append a single byte to the buffer.
-**
-** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
-** returning.
-*/
-static void sessionAppendByte(SessionBuffer *p, u8 v, int *pRc){
-  if( 0==sessionBufferGrow(p, 1, pRc) ){
-    p->aBuf[p->nBuf++] = v;
-  }
-}
-
-/*
-** This function is a no-op if *pRc is other than SQLITE_OK when it is
-** called. Otherwise, append a single varint to the buffer.
-**
-** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
-** returning.
-*/
-static void sessionAppendVarint(SessionBuffer *p, int v, int *pRc){
-  if( 0==sessionBufferGrow(p, 9, pRc) ){
-    p->nBuf += sessionVarintPut(&p->aBuf[p->nBuf], v);
-  }
-}
-
-/*
-** This function is a no-op if *pRc is other than SQLITE_OK when it is
-** called. Otherwise, append a blob of data to the buffer.
-**
-** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
-** returning.
-*/
-static void sessionAppendBlob(
-  SessionBuffer *p,
-  const u8 *aBlob,
-  int nBlob,
-  int *pRc
-){
-  if( nBlob>0 && 0==sessionBufferGrow(p, nBlob, pRc) ){
-    memcpy(&p->aBuf[p->nBuf], aBlob, nBlob);
-    p->nBuf += nBlob;
-  }
-}
-
-/*
-** This function is a no-op if *pRc is other than SQLITE_OK when it is
-** called. Otherwise, append the string representation of integer iVal
-** to the buffer. No nul-terminator is written.
-**
-** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
-** returning.
-*/
-static void sessionAppendInteger(
-  SessionBuffer *p,               /* Buffer to append to */
-  int iVal,                       /* Value to write the string rep. of */
-  int *pRc                        /* IN/OUT: Error code */
-){
-  char aBuf[24];
-  sqlite3_snprintf(sizeof(aBuf)-1, aBuf, "%d", iVal);
-  sessionAppendStr(p, aBuf, pRc);
-}
-
-/*
-** This function is a no-op if *pRc is other than SQLITE_OK when it is
-** called. Otherwise, append the string zStr enclosed in quotes (") and
-** with any embedded quote characters escaped to the buffer. No
-** nul-terminator byte is written.
-**
-** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
-** returning.
-*/
-static void sessionAppendIdent(
-  SessionBuffer *p,               /* Buffer to a append to */
-  const char *zStr,               /* String to quote, escape and append */
-  int *pRc                        /* IN/OUT: Error code */
-){
-  int nStr = sqlite3Strlen30(zStr)*2 + 2 + 2;
-  if( 0==sessionBufferGrow(p, nStr, pRc) ){
-    char *zOut = (char *)&p->aBuf[p->nBuf];
-    const char *zIn = zStr;
-    *zOut++ = '"';
-    if( zIn!=0 ){
-      while( *zIn ){
-        if( *zIn=='"' ) *zOut++ = '"';
-        *zOut++ = *(zIn++);
-      }
-    }
-    *zOut++ = '"';
-    p->nBuf = (int)((u8 *)zOut - p->aBuf);
-    p->aBuf[p->nBuf] = 0x00;
-  }
-}
-
-/*
-** This function is a no-op if *pRc is other than SQLITE_OK when it is
-** called. Otherwse, it appends the serialized version of the value stored
-** in column iCol of the row that SQL statement pStmt currently points
-** to to the buffer.
-*/
-static void sessionAppendCol(
-  SessionBuffer *p,               /* Buffer to append to */
-  sqlite3_stmt *pStmt,            /* Handle pointing to row containing value */
-  int iCol,                       /* Column to read value from */
-  int *pRc                        /* IN/OUT: Error code */
-){
-  if( *pRc==SQLITE_OK ){
-    int eType = sqlite3_column_type(pStmt, iCol);
-    sessionAppendByte(p, (u8)eType, pRc);
-    if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
-      u8 aBuf[8];
-      if( eType==SQLITE_INTEGER ){
-        sqlite3_int64 i = sqlite3_column_int64(pStmt, iCol);
-        sessionPutI64(aBuf, i);
-      }else{
-        double r = sqlite3_column_double(pStmt, iCol);
-        sessionPutDouble(aBuf, r);
-      }
-      sessionAppendBlob(p, aBuf, 8, pRc);
-    }
-    if( eType==SQLITE_BLOB || eType==SQLITE_TEXT ){
-      u8 *z;
-      int nByte;
-      if( eType==SQLITE_BLOB ){
-        z = (u8 *)sqlite3_column_blob(pStmt, iCol);
-      }else{
-        z = (u8 *)sqlite3_column_text(pStmt, iCol);
-      }
-      nByte = sqlite3_column_bytes(pStmt, iCol);
-      if( z || (eType==SQLITE_BLOB && nByte==0) ){
-        sessionAppendVarint(p, nByte, pRc);
-        sessionAppendBlob(p, z, nByte, pRc);
-      }else{
-        *pRc = SQLITE_NOMEM;
-      }
-    }
-  }
-}
-
-/*
-**
-** This function appends an update change to the buffer (see the comments
-** under "CHANGESET FORMAT" at the top of the file). An update change
-** consists of:
-**
-**   1 byte:  SQLITE_UPDATE (0x17)
-**   n bytes: old.* record (see RECORD FORMAT)
-**   m bytes: new.* record (see RECORD FORMAT)
-**
-** The SessionChange object passed as the third argument contains the
-** values that were stored in the row when the session began (the old.*
-** values). The statement handle passed as the second argument points
-** at the current version of the row (the new.* values).
-**
-** If all of the old.* values are equal to their corresponding new.* value
-** (i.e. nothing has changed), then no data at all is appended to the buffer.
-**
-** Otherwise, the old.* record contains all primary key values and the
-** original values of any fields that have been modified. The new.* record
-** contains the new values of only those fields that have been modified.
-*/
-static int sessionAppendUpdate(
-  SessionBuffer *pBuf,            /* Buffer to append to */
-  int bPatchset,                  /* True for "patchset", 0 for "changeset" */
-  sqlite3_stmt *pStmt,            /* Statement handle pointing at new row */
-  SessionChange *p,               /* Object containing old values */
-  u8 *abPK                        /* Boolean array - true for PK columns */
-){
-  int rc = SQLITE_OK;
-  SessionBuffer buf2 = {0,0,0}; /* Buffer to accumulate new.* record in */
-  int bNoop = 1;                /* Set to zero if any values are modified */
-  int nRewind = pBuf->nBuf;     /* Set to zero if any values are modified */
-  int i;                        /* Used to iterate through columns */
-  u8 *pCsr = p->aRecord;        /* Used to iterate through old.* values */
-
-  assert( abPK!=0 );
-  sessionAppendByte(pBuf, SQLITE_UPDATE, &rc);
-  sessionAppendByte(pBuf, p->bIndirect, &rc);
-  for(i=0; i<sqlite3_column_count(pStmt); i++){
-    int bChanged = 0;
-    int nAdvance;
-    int eType = *pCsr;
-    switch( eType ){
-      case SQLITE_NULL:
-        nAdvance = 1;
-        if( sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
-          bChanged = 1;
-        }
-        break;
-
-      case SQLITE_FLOAT:
-      case SQLITE_INTEGER: {
-        nAdvance = 9;
-        if( eType==sqlite3_column_type(pStmt, i) ){
-          sqlite3_int64 iVal = sessionGetI64(&pCsr[1]);
-          if( eType==SQLITE_INTEGER ){
-            if( iVal==sqlite3_column_int64(pStmt, i) ) break;
-          }else{
-            double dVal;
-            memcpy(&dVal, &iVal, 8);
-            if( dVal==sqlite3_column_double(pStmt, i) ) break;
-          }
-        }
-        bChanged = 1;
-        break;
-      }
-
-      default: {
-        int n;
-        int nHdr = 1 + sessionVarintGet(&pCsr[1], &n);
-        assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
-        nAdvance = nHdr + n;
-        if( eType==sqlite3_column_type(pStmt, i)
-         && n==sqlite3_column_bytes(pStmt, i)
-         && (n==0 || 0==memcmp(&pCsr[nHdr], sqlite3_column_blob(pStmt, i), n))
-        ){
-          break;
-        }
-        bChanged = 1;
-      }
-    }
-
-    /* If at least one field has been modified, this is not a no-op. */
-    if( bChanged ) bNoop = 0;
-
-    /* Add a field to the old.* record. This is omitted if this module is
-    ** currently generating a patchset. */
-    if( bPatchset==0 ){
-      if( bChanged || abPK[i] ){
-        sessionAppendBlob(pBuf, pCsr, nAdvance, &rc);
-      }else{
-        sessionAppendByte(pBuf, 0, &rc);
-      }
-    }
-
-    /* Add a field to the new.* record. Or the only record if currently
-    ** generating a patchset.  */
-    if( bChanged || (bPatchset && abPK[i]) ){
-      sessionAppendCol(&buf2, pStmt, i, &rc);
-    }else{
-      sessionAppendByte(&buf2, 0, &rc);
-    }
-
-    pCsr += nAdvance;
-  }
-
-  if( bNoop ){
-    pBuf->nBuf = nRewind;
-  }else{
-    sessionAppendBlob(pBuf, buf2.aBuf, buf2.nBuf, &rc);
-  }
-  sqlite3_free(buf2.aBuf);
-
-  return rc;
-}
-
-/*
-** Append a DELETE change to the buffer passed as the first argument. Use
-** the changeset format if argument bPatchset is zero, or the patchset
-** format otherwise.
-*/
-static int sessionAppendDelete(
-  SessionBuffer *pBuf,            /* Buffer to append to */
-  int bPatchset,                  /* True for "patchset", 0 for "changeset" */
-  SessionChange *p,               /* Object containing old values */
-  int nCol,                       /* Number of columns in table */
-  u8 *abPK                        /* Boolean array - true for PK columns */
-){
-  int rc = SQLITE_OK;
-
-  sessionAppendByte(pBuf, SQLITE_DELETE, &rc);
-  sessionAppendByte(pBuf, p->bIndirect, &rc);
-
-  if( bPatchset==0 ){
-    sessionAppendBlob(pBuf, p->aRecord, p->nRecord, &rc);
-  }else{
-    int i;
-    u8 *a = p->aRecord;
-    for(i=0; i<nCol; i++){
-      u8 *pStart = a;
-      int eType = *a++;
-
-      switch( eType ){
-        case 0:
-        case SQLITE_NULL:
-          assert( abPK[i]==0 );
-          break;
-
-        case SQLITE_FLOAT:
-        case SQLITE_INTEGER:
-          a += 8;
-          break;
-
-        default: {
-          int n;
-          a += sessionVarintGet(a, &n);
-          a += n;
-          break;
-        }
-      }
-      if( abPK[i] ){
-        sessionAppendBlob(pBuf, pStart, (int)(a-pStart), &rc);
-      }
-    }
-    assert( (a - p->aRecord)==p->nRecord );
-  }
-
-  return rc;
-}
-
-static int sessionPrepare(
-  sqlite3 *db,
-  sqlite3_stmt **pp,
-  char **pzErrmsg,
-  const char *zSql
-){
-  int rc = sqlite3_prepare_v2(db, zSql, -1, pp, 0);
-  if( pzErrmsg && rc!=SQLITE_OK ){
-    *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
-  }
-  return rc;
-}
-
-/*
-** Formulate and prepare a SELECT statement to retrieve a row from table
-** zTab in database zDb based on its primary key. i.e.
-**
-**   SELECT *, <noop-test> FROM zDb.zTab WHERE (pk1, pk2,...) IS (?1, ?2,...)
-**
-** where <noop-test> is:
-**
-**   1 AND (?A OR ?1 IS <column>) AND ...
-**
-** for each non-pk <column>.
-*/
-static int sessionSelectStmt(
-  sqlite3 *db,                    /* Database handle */
-  int bIgnoreNoop,
-  const char *zDb,                /* Database name */
-  const char *zTab,               /* Table name */
-  int bRowid,
-  int nCol,                       /* Number of columns in table */
-  const char **azCol,             /* Names of table columns */
-  u8 *abPK,                       /* PRIMARY KEY  array */
-  sqlite3_stmt **ppStmt,          /* OUT: Prepared SELECT statement */
-  char **pzErrmsg                 /* OUT: Error message */
-){
-  int rc = SQLITE_OK;
-  char *zSql = 0;
-  const char *zSep = "";
-  int i;
-
-  SessionBuffer cols = {0, 0, 0};
-  SessionBuffer nooptest = {0, 0, 0};
-  SessionBuffer pkfield = {0, 0, 0};
-  SessionBuffer pkvar = {0, 0, 0};
-
-  sessionAppendStr(&nooptest, ", 1", &rc);
-
-  if( 0==sqlite3_stricmp("sqlite_stat1", zTab) ){
-    sessionAppendStr(&nooptest, " AND (?6 OR ?3 IS stat)", &rc);
-    sessionAppendStr(&pkfield, "tbl, idx", &rc);
-    sessionAppendStr(&pkvar,
-        "?1, (CASE WHEN ?2=X'' THEN NULL ELSE ?2 END)", &rc
-    );
-    sessionAppendStr(&cols, "tbl, ?2, stat", &rc);
-  }else{
-  #if 0
-    if( bRowid ){
-      sessionAppendStr(&cols, SESSIONS_ROWID, &rc);
-    }
-    #endif
-    for(i=0; i<nCol; i++){
-      if( cols.nBuf ) sessionAppendStr(&cols, ", ", &rc);
-      sessionAppendIdent(&cols, azCol[i], &rc);
-      if( abPK[i] ){
-        sessionAppendStr(&pkfield, zSep, &rc);
-        sessionAppendStr(&pkvar, zSep, &rc);
-        zSep = ", ";
-        sessionAppendIdent(&pkfield, azCol[i], &rc);
-        sessionAppendPrintf(&pkvar, &rc, "?%d", i+1);
-      }else{
-        sessionAppendPrintf(&nooptest, &rc,
-            " AND (?%d OR ?%d IS %w.%w)", i+1+nCol, i+1, zTab, azCol[i]
-        );
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    zSql = sqlite3_mprintf(
-        "SELECT %s%s FROM %Q.%Q WHERE (%s) IS (%s)",
-        (char*)cols.aBuf, (bIgnoreNoop ? (char*)nooptest.aBuf : ""),
-        zDb, zTab, (char*)pkfield.aBuf, (char*)pkvar.aBuf
-    );
-    if( zSql==0 ) rc = SQLITE_NOMEM;
-  }
-
-#if 0
-  if( 0==sqlite3_stricmp("sqlite_stat1", zTab) ){
-    zSql = sqlite3_mprintf(
-        "SELECT tbl, ?2, stat FROM %Q.sqlite_stat1 WHERE tbl IS ?1 AND "
-        "idx IS (CASE WHEN ?2=X'' THEN NULL ELSE ?2 END)", zDb
-    );
-    if( zSql==0 ) rc = SQLITE_NOMEM;
-  }else{
-    const char *zSep = "";
-    SessionBuffer buf = {0, 0, 0};
-
-    sessionAppendStr(&buf, "SELECT * FROM ", &rc);
-    sessionAppendIdent(&buf, zDb, &rc);
-    sessionAppendStr(&buf, ".", &rc);
-    sessionAppendIdent(&buf, zTab, &rc);
-    sessionAppendStr(&buf, " WHERE ", &rc);
-    for(i=0; i<nCol; i++){
-      if( abPK[i] ){
-        sessionAppendStr(&buf, zSep, &rc);
-        sessionAppendIdent(&buf, azCol[i], &rc);
-        sessionAppendStr(&buf, " IS ?", &rc);
-        sessionAppendInteger(&buf, i+1, &rc);
-        zSep = " AND ";
-      }
-    }
-    zSql = (char*)buf.aBuf;
-    nSql = buf.nBuf;
-  }
-#endif
-
-  if( rc==SQLITE_OK ){
-    rc = sessionPrepare(db, ppStmt, pzErrmsg, zSql);
-  }
-  sqlite3_free(zSql);
-  sqlite3_free(nooptest.aBuf);
-  sqlite3_free(pkfield.aBuf);
-  sqlite3_free(pkvar.aBuf);
-  sqlite3_free(cols.aBuf);
-  return rc;
-}
-
-/*
-** Bind the PRIMARY KEY values from the change passed in argument pChange
-** to the SELECT statement passed as the first argument. The SELECT statement
-** is as prepared by function sessionSelectStmt().
-**
-** Return SQLITE_OK if all PK values are successfully bound, or an SQLite
-** error code (e.g. SQLITE_NOMEM) otherwise.
-*/
-static int sessionSelectBind(
-  sqlite3_stmt *pSelect,          /* SELECT from sessionSelectStmt() */
-  int nCol,                       /* Number of columns in table */
-  u8 *abPK,                       /* PRIMARY KEY array */
-  SessionChange *pChange          /* Change structure */
-){
-  int i;
-  int rc = SQLITE_OK;
-  u8 *a = pChange->aRecord;
-
-  for(i=0; i<nCol && rc==SQLITE_OK; i++){
-    int eType = *a++;
-
-    switch( eType ){
-      case 0:
-      case SQLITE_NULL:
-        assert( abPK[i]==0 );
-        break;
-
-      case SQLITE_INTEGER: {
-        if( abPK[i] ){
-          i64 iVal = sessionGetI64(a);
-          rc = sqlite3_bind_int64(pSelect, i+1, iVal);
-        }
-        a += 8;
-        break;
-      }
-
-      case SQLITE_FLOAT: {
-        if( abPK[i] ){
-          double rVal;
-          i64 iVal = sessionGetI64(a);
-          memcpy(&rVal, &iVal, 8);
-          rc = sqlite3_bind_double(pSelect, i+1, rVal);
-        }
-        a += 8;
-        break;
-      }
-
-      case SQLITE_TEXT: {
-        int n;
-        a += sessionVarintGet(a, &n);
-        if( abPK[i] ){
-          rc = sqlite3_bind_text(pSelect, i+1, (char *)a, n, SQLITE_TRANSIENT);
-        }
-        a += n;
-        break;
-      }
-
-      default: {
-        int n;
-        assert( eType==SQLITE_BLOB );
-        a += sessionVarintGet(a, &n);
-        if( abPK[i] ){
-          rc = sqlite3_bind_blob(pSelect, i+1, a, n, SQLITE_TRANSIENT);
-        }
-        a += n;
-        break;
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** This function is a no-op if *pRc is set to other than SQLITE_OK when it
-** is called. Otherwise, append a serialized table header (part of the binary
-** changeset format) to buffer *pBuf. If an error occurs, set *pRc to an
-** SQLite error code before returning.
-*/
-static void sessionAppendTableHdr(
-  SessionBuffer *pBuf,            /* Append header to this buffer */
-  int bPatchset,                  /* Use the patchset format if true */
-  SessionTable *pTab,             /* Table object to append header for */
-  int *pRc                        /* IN/OUT: Error code */
-){
-  /* Write a table header */
-  sessionAppendByte(pBuf, (bPatchset ? 'P' : 'T'), pRc);
-  sessionAppendVarint(pBuf, pTab->nCol, pRc);
-  sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
-  sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
-}
-
-/*
-** Generate either a changeset (if argument bPatchset is zero) or a patchset
-** (if it is non-zero) based on the current contents of the session object
-** passed as the first argument.
-**
-** If no error occurs, SQLITE_OK is returned and the new changeset/patchset
-** stored in output variables *pnChangeset and *ppChangeset. Or, if an error
-** occurs, an SQLite error code is returned and both output variables set
-** to 0.
-*/
-static int sessionGenerateChangeset(
-  sqlite3_session *pSession,      /* Session object */
-  int bPatchset,                  /* True for patchset, false for changeset */
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut,                     /* First argument for xOutput */
-  int *pnChangeset,               /* OUT: Size of buffer at *ppChangeset */
-  void **ppChangeset              /* OUT: Buffer containing changeset */
-){
-  sqlite3 *db = pSession->db;     /* Source database handle */
-  SessionTable *pTab;             /* Used to iterate through attached tables */
-  SessionBuffer buf = {0,0,0};    /* Buffer in which to accumulate changeset */
-  int rc;                         /* Return code */
-
-  assert( xOutput==0 || (pnChangeset==0 && ppChangeset==0) );
-  assert( xOutput!=0 || (pnChangeset!=0 && ppChangeset!=0) );
-
-  /* Zero the output variables in case an error occurs. If this session
-  ** object is already in the error state (sqlite3_session.rc != SQLITE_OK),
-  ** this call will be a no-op.  */
-  if( xOutput==0 ){
-    assert( pnChangeset!=0  && ppChangeset!=0 );
-    *pnChangeset = 0;
-    *ppChangeset = 0;
-  }
-
-  if( pSession->rc ) return pSession->rc;
-
-  sqlite3_mutex_enter(sqlite3_db_mutex(db));
-  rc = sqlite3_exec(pSession->db, "SAVEPOINT changeset", 0, 0, 0);
-  if( rc!=SQLITE_OK ){
-    sqlite3_mutex_leave(sqlite3_db_mutex(db));
-    return rc;
-  }
-
-  for(pTab=pSession->pTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
-    if( pTab->nEntry ){
-      const char *zName = pTab->zName;
-      int i;                      /* Used to iterate through hash buckets */
-      sqlite3_stmt *pSel = 0;     /* SELECT statement to query table pTab */
-      int nRewind = buf.nBuf;     /* Initial size of write buffer */
-      int nNoop;                  /* Size of buffer after writing tbl header */
-      int nOldCol = pTab->nCol;
-
-      /* Check the table schema is still Ok. */
-      rc = sessionReinitTable(pSession, pTab);
-      if( rc==SQLITE_OK && pTab->nCol!=nOldCol ){
-        rc = sessionUpdateChanges(pSession, pTab);
-      }
-
-      /* Write a table header */
-      sessionAppendTableHdr(&buf, bPatchset, pTab, &rc);
-
-      /* Build and compile a statement to execute: */
-      if( rc==SQLITE_OK ){
-        rc = sessionSelectStmt(db, 0, pSession->zDb,
-            zName, pTab->bRowid, pTab->nCol, pTab->azCol, pTab->abPK, &pSel, 0
-        );
-      }
-
-      nNoop = buf.nBuf;
-      for(i=0; i<pTab->nChange && rc==SQLITE_OK; i++){
-        SessionChange *p;         /* Used to iterate through changes */
-
-        for(p=pTab->apChange[i]; rc==SQLITE_OK && p; p=p->pNext){
-          rc = sessionSelectBind(pSel, pTab->nCol, pTab->abPK, p);
-          if( rc!=SQLITE_OK ) continue;
-          if( sqlite3_step(pSel)==SQLITE_ROW ){
-            if( p->op==SQLITE_INSERT ){
-              int iCol;
-              sessionAppendByte(&buf, SQLITE_INSERT, &rc);
-              sessionAppendByte(&buf, p->bIndirect, &rc);
-              for(iCol=0; iCol<pTab->nCol; iCol++){
-                sessionAppendCol(&buf, pSel, iCol, &rc);
-              }
-            }else{
-              assert( pTab->abPK!=0 );
-              rc = sessionAppendUpdate(&buf, bPatchset, pSel, p, pTab->abPK);
-            }
-          }else if( p->op!=SQLITE_INSERT ){
-            rc = sessionAppendDelete(&buf, bPatchset, p, pTab->nCol,pTab->abPK);
-          }
-          if( rc==SQLITE_OK ){
-            rc = sqlite3_reset(pSel);
-          }
-
-          /* If the buffer is now larger than sessions_strm_chunk_size, pass
-          ** its contents to the xOutput() callback. */
-          if( xOutput
-           && rc==SQLITE_OK
-           && buf.nBuf>nNoop
-           && buf.nBuf>sessions_strm_chunk_size
-          ){
-            rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
-            nNoop = -1;
-            buf.nBuf = 0;
-          }
-
-        }
-      }
-
-      sqlite3_finalize(pSel);
-      if( buf.nBuf==nNoop ){
-        buf.nBuf = nRewind;
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    if( xOutput==0 ){
-      *pnChangeset = buf.nBuf;
-      *ppChangeset = buf.aBuf;
-      buf.aBuf = 0;
-    }else if( buf.nBuf>0 ){
-      rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
-    }
-  }
-
-  sqlite3_free(buf.aBuf);
-  sqlite3_exec(db, "RELEASE changeset", 0, 0, 0);
-  sqlite3_mutex_leave(sqlite3_db_mutex(db));
-  return rc;
-}
-
-/*
-** Obtain a changeset object containing all changes recorded by the
-** session object passed as the first argument.
-**
-** It is the responsibility of the caller to eventually free the buffer
-** using sqlite3_free().
-*/
-SQLITE_API int sqlite3session_changeset(
-  sqlite3_session *pSession,      /* Session object */
-  int *pnChangeset,               /* OUT: Size of buffer at *ppChangeset */
-  void **ppChangeset              /* OUT: Buffer containing changeset */
-){
-  int rc;
-
-  if( pnChangeset==0 || ppChangeset==0 ) return SQLITE_MISUSE;
-  rc = sessionGenerateChangeset(pSession, 0, 0, 0, pnChangeset, ppChangeset);
-  assert( rc || pnChangeset==0
-       || pSession->bEnableSize==0 || *pnChangeset<=pSession->nMaxChangesetSize
-  );
-  return rc;
-}
-
-/*
-** Streaming version of sqlite3session_changeset().
-*/
-SQLITE_API int sqlite3session_changeset_strm(
-  sqlite3_session *pSession,
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut
-){
-  if( xOutput==0 ) return SQLITE_MISUSE;
-  return sessionGenerateChangeset(pSession, 0, xOutput, pOut, 0, 0);
-}
-
-/*
-** Streaming version of sqlite3session_patchset().
-*/
-SQLITE_API int sqlite3session_patchset_strm(
-  sqlite3_session *pSession,
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut
-){
-  if( xOutput==0 ) return SQLITE_MISUSE;
-  return sessionGenerateChangeset(pSession, 1, xOutput, pOut, 0, 0);
-}
-
-/*
-** Obtain a patchset object containing all changes recorded by the
-** session object passed as the first argument.
-**
-** It is the responsibility of the caller to eventually free the buffer
-** using sqlite3_free().
-*/
-SQLITE_API int sqlite3session_patchset(
-  sqlite3_session *pSession,      /* Session object */
-  int *pnPatchset,                /* OUT: Size of buffer at *ppChangeset */
-  void **ppPatchset               /* OUT: Buffer containing changeset */
-){
-  if( pnPatchset==0 || ppPatchset==0 ) return SQLITE_MISUSE;
-  return sessionGenerateChangeset(pSession, 1, 0, 0, pnPatchset, ppPatchset);
-}
-
-/*
-** Enable or disable the session object passed as the first argument.
-*/
-SQLITE_API int sqlite3session_enable(sqlite3_session *pSession, int bEnable){
-  int ret;
-  sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
-  if( bEnable>=0 ){
-    pSession->bEnable = bEnable;
-  }
-  ret = pSession->bEnable;
-  sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
-  return ret;
-}
-
-/*
-** Enable or disable the session object passed as the first argument.
-*/
-SQLITE_API int sqlite3session_indirect(sqlite3_session *pSession, int bIndirect){
-  int ret;
-  sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
-  if( bIndirect>=0 ){
-    pSession->bIndirect = bIndirect;
-  }
-  ret = pSession->bIndirect;
-  sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
-  return ret;
-}
-
-/*
-** Return true if there have been no changes to monitored tables recorded
-** by the session object passed as the only argument.
-*/
-SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession){
-  int ret = 0;
-  SessionTable *pTab;
-
-  sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
-  for(pTab=pSession->pTable; pTab && ret==0; pTab=pTab->pNext){
-    ret = (pTab->nEntry>0);
-  }
-  sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
-
-  return (ret==0);
-}
-
-/*
-** Return the amount of heap memory in use.
-*/
-SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession){
-  return pSession->nMalloc;
-}
-
-/*
-** Configure the session object passed as the first argument.
-*/
-SQLITE_API int sqlite3session_object_config(sqlite3_session *pSession, int op, void *pArg){
-  int rc = SQLITE_OK;
-  switch( op ){
-    case SQLITE_SESSION_OBJCONFIG_SIZE: {
-      int iArg = *(int*)pArg;
-      if( iArg>=0 ){
-        if( pSession->pTable ){
-          rc = SQLITE_MISUSE;
-        }else{
-          pSession->bEnableSize = (iArg!=0);
-        }
-      }
-      *(int*)pArg = pSession->bEnableSize;
-      break;
-    }
-
-    case SQLITE_SESSION_OBJCONFIG_ROWID: {
-      int iArg = *(int*)pArg;
-      if( iArg>=0 ){
-        if( pSession->pTable ){
-          rc = SQLITE_MISUSE;
-        }else{
-          pSession->bImplicitPK = (iArg!=0);
-        }
-      }
-      *(int*)pArg = pSession->bImplicitPK;
-      break;
-    }
-
-    default:
-      rc = SQLITE_MISUSE;
-  }
-
-  return rc;
-}
-
-/*
-** Return the maximum size of sqlite3session_changeset() output.
-*/
-SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession){
-  return pSession->nMaxChangesetSize;
-}
-
-/*
-** Do the work for either sqlite3changeset_start() or start_strm().
-*/
-static int sessionChangesetStart(
-  sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn,
-  int nChangeset,                 /* Size of buffer pChangeset in bytes */
-  void *pChangeset,               /* Pointer to buffer containing changeset */
-  int bInvert,                    /* True to invert changeset */
-  int bSkipEmpty                  /* True to skip empty UPDATE changes */
-){
-  sqlite3_changeset_iter *pRet;   /* Iterator to return */
-  int nByte;                      /* Number of bytes to allocate for iterator */
-
-  assert( xInput==0 || (pChangeset==0 && nChangeset==0) );
-
-  /* Zero the output variable in case an error occurs. */
-  *pp = 0;
-
-  /* Allocate and initialize the iterator structure. */
-  nByte = sizeof(sqlite3_changeset_iter);
-  pRet = (sqlite3_changeset_iter *)sqlite3_malloc(nByte);
-  if( !pRet ) return SQLITE_NOMEM;
-  memset(pRet, 0, sizeof(sqlite3_changeset_iter));
-  pRet->in.aData = (u8 *)pChangeset;
-  pRet->in.nData = nChangeset;
-  pRet->in.xInput = xInput;
-  pRet->in.pIn = pIn;
-  pRet->in.bEof = (xInput ? 0 : 1);
-  pRet->bInvert = bInvert;
-  pRet->bSkipEmpty = bSkipEmpty;
-
-  /* Populate the output variable and return success. */
-  *pp = pRet;
-  return SQLITE_OK;
-}
-
-/*
-** Create an iterator used to iterate through the contents of a changeset.
-*/
-SQLITE_API int sqlite3changeset_start(
-  sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */
-  int nChangeset,                 /* Size of buffer pChangeset in bytes */
-  void *pChangeset                /* Pointer to buffer containing changeset */
-){
-  return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, 0, 0);
-}
-SQLITE_API int sqlite3changeset_start_v2(
-  sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */
-  int nChangeset,                 /* Size of buffer pChangeset in bytes */
-  void *pChangeset,               /* Pointer to buffer containing changeset */
-  int flags
-){
-  int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT);
-  return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, bInvert, 0);
-}
-
-/*
-** Streaming version of sqlite3changeset_start().
-*/
-SQLITE_API int sqlite3changeset_start_strm(
-  sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn
-){
-  return sessionChangesetStart(pp, xInput, pIn, 0, 0, 0, 0);
-}
-SQLITE_API int sqlite3changeset_start_v2_strm(
-  sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn,
-  int flags
-){
-  int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT);
-  return sessionChangesetStart(pp, xInput, pIn, 0, 0, bInvert, 0);
-}
-
-/*
-** If the SessionInput object passed as the only argument is a streaming
-** object and the buffer is full, discard some data to free up space.
-*/
-static void sessionDiscardData(SessionInput *pIn){
-  if( pIn->xInput && pIn->iCurrent>=sessions_strm_chunk_size ){
-    int nMove = pIn->buf.nBuf - pIn->iCurrent;
-    assert( nMove>=0 );
-    if( nMove>0 ){
-      memmove(pIn->buf.aBuf, &pIn->buf.aBuf[pIn->iCurrent], nMove);
-    }
-    pIn->buf.nBuf -= pIn->iCurrent;
-    pIn->iNext -= pIn->iCurrent;
-    pIn->iCurrent = 0;
-    pIn->nData = pIn->buf.nBuf;
-  }
-}
-
-/*
-** Ensure that there are at least nByte bytes available in the buffer. Or,
-** if there are not nByte bytes remaining in the input, that all available
-** data is in the buffer.
-**
-** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
-*/
-static int sessionInputBuffer(SessionInput *pIn, int nByte){
-  int rc = SQLITE_OK;
-  if( pIn->xInput ){
-    while( !pIn->bEof && (pIn->iNext+nByte)>=pIn->nData && rc==SQLITE_OK ){
-      int nNew = sessions_strm_chunk_size;
-
-      if( pIn->bNoDiscard==0 ) sessionDiscardData(pIn);
-      if( SQLITE_OK==sessionBufferGrow(&pIn->buf, nNew, &rc) ){
-        rc = pIn->xInput(pIn->pIn, &pIn->buf.aBuf[pIn->buf.nBuf], &nNew);
-        if( nNew==0 ){
-          pIn->bEof = 1;
-        }else{
-          pIn->buf.nBuf += nNew;
-        }
-      }
-
-      pIn->aData = pIn->buf.aBuf;
-      pIn->nData = pIn->buf.nBuf;
-    }
-  }
-  return rc;
-}
-
-/*
-** When this function is called, *ppRec points to the start of a record
-** that contains nCol values. This function advances the pointer *ppRec
-** until it points to the byte immediately following that record.
-*/
-static void sessionSkipRecord(
-  u8 **ppRec,                     /* IN/OUT: Record pointer */
-  int nCol                        /* Number of values in record */
-){
-  u8 *aRec = *ppRec;
-  int i;
-  for(i=0; i<nCol; i++){
-    int eType = *aRec++;
-    if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){
-      int nByte;
-      aRec += sessionVarintGet((u8*)aRec, &nByte);
-      aRec += nByte;
-    }else if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
-      aRec += 8;
-    }
-  }
-
-  *ppRec = aRec;
-}
-
-/*
-** This function sets the value of the sqlite3_value object passed as the
-** first argument to a copy of the string or blob held in the aData[]
-** buffer. SQLITE_OK is returned if successful, or SQLITE_NOMEM if an OOM
-** error occurs.
-*/
-static int sessionValueSetStr(
-  sqlite3_value *pVal,            /* Set the value of this object */
-  u8 *aData,                      /* Buffer containing string or blob data */
-  int nData,                      /* Size of buffer aData[] in bytes */
-  u8 enc                          /* String encoding (0 for blobs) */
-){
-  /* In theory this code could just pass SQLITE_TRANSIENT as the final
-  ** argument to sqlite3ValueSetStr() and have the copy created
-  ** automatically. But doing so makes it difficult to detect any OOM
-  ** error. Hence the code to create the copy externally. */
-  u8 *aCopy = sqlite3_malloc64((sqlite3_int64)nData+1);
-  if( aCopy==0 ) return SQLITE_NOMEM;
-  memcpy(aCopy, aData, nData);
-  sqlite3ValueSetStr(pVal, nData, (char*)aCopy, enc, sqlite3_free);
-  return SQLITE_OK;
-}
-
-/*
-** Deserialize a single record from a buffer in memory. See "RECORD FORMAT"
-** for details.
-**
-** When this function is called, *paChange points to the start of the record
-** to deserialize. Assuming no error occurs, *paChange is set to point to
-** one byte after the end of the same record before this function returns.
-** If the argument abPK is NULL, then the record contains nCol values. Or,
-** if abPK is other than NULL, then the record contains only the PK fields
-** (in other words, it is a patchset DELETE record).
-**
-** If successful, each element of the apOut[] array (allocated by the caller)
-** is set to point to an sqlite3_value object containing the value read
-** from the corresponding position in the record. If that value is not
-** included in the record (i.e. because the record is part of an UPDATE change
-** and the field was not modified), the corresponding element of apOut[] is
-** set to NULL.
-**
-** It is the responsibility of the caller to free all sqlite_value structures
-** using sqlite3_free().
-**
-** If an error occurs, an SQLite error code (e.g. SQLITE_NOMEM) is returned.
-** The apOut[] array may have been partially populated in this case.
-*/
-static int sessionReadRecord(
-  SessionInput *pIn,              /* Input data */
-  int nCol,                       /* Number of values in record */
-  u8 *abPK,                       /* Array of primary key flags, or NULL */
-  sqlite3_value **apOut,          /* Write values to this array */
-  int *pbEmpty
-){
-  int i;                          /* Used to iterate through columns */
-  int rc = SQLITE_OK;
-
-  assert( pbEmpty==0 || *pbEmpty==0 );
-  if( pbEmpty ) *pbEmpty = 1;
-  for(i=0; i<nCol && rc==SQLITE_OK; i++){
-    int eType = 0;                /* Type of value (SQLITE_NULL, TEXT etc.) */
-    if( abPK && abPK[i]==0 ) continue;
-    rc = sessionInputBuffer(pIn, 9);
-    if( rc==SQLITE_OK ){
-      if( pIn->iNext>=pIn->nData ){
-        rc = SQLITE_CORRUPT_BKPT;
-      }else{
-        eType = pIn->aData[pIn->iNext++];
-        assert( apOut[i]==0 );
-        if( eType ){
-          if( pbEmpty ) *pbEmpty = 0;
-          apOut[i] = sqlite3ValueNew(0);
-          if( !apOut[i] ) rc = SQLITE_NOMEM;
-        }
-      }
-    }
-
-    if( rc==SQLITE_OK ){
-      u8 *aVal = &pIn->aData[pIn->iNext];
-      if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){
-        int nByte;
-        int nRem = pIn->nData - pIn->iNext;
-        pIn->iNext += sessionVarintGetSafe(aVal, nRem, &nByte);
-        rc = sessionInputBuffer(pIn, nByte);
-        if( rc==SQLITE_OK ){
-          if( nByte<0 || nByte>pIn->nData-pIn->iNext ){
-            rc = SQLITE_CORRUPT_BKPT;
-          }else{
-            u8 enc = (eType==SQLITE_TEXT ? SQLITE_UTF8 : 0);
-            rc = sessionValueSetStr(apOut[i],&pIn->aData[pIn->iNext],nByte,enc);
-            pIn->iNext += nByte;
-          }
-        }
-      }
-      if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
-        if( (pIn->nData-pIn->iNext)<8 ){
-          rc = SQLITE_CORRUPT_BKPT;
-        }else{
-          sqlite3_int64 v = sessionGetI64(aVal);
-          if( eType==SQLITE_INTEGER ){
-            sqlite3VdbeMemSetInt64(apOut[i], v);
-          }else{
-            double d;
-            memcpy(&d, &v, 8);
-            sqlite3VdbeMemSetDouble(apOut[i], d);
-          }
-          pIn->iNext += 8;
-        }
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** The input pointer currently points to the second byte of a table-header.
-** Specifically, to the following:
-**
-**   + number of columns in table (varint)
-**   + array of PK flags (1 byte per column),
-**   + table name (nul terminated).
-**
-** This function ensures that all of the above is present in the input
-** buffer (i.e. that it can be accessed without any calls to xInput()).
-** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
-** The input pointer is not moved.
-*/
-static int sessionChangesetBufferTblhdr(SessionInput *pIn, int *pnByte){
-  int rc = SQLITE_OK;
-  int nCol = 0;
-  int nRead = 0;
-
-  rc = sessionInputBuffer(pIn, 9);
-  if( rc==SQLITE_OK ){
-    int nBuf = pIn->nData - pIn->iNext;
-    nRead += sessionVarintGetSafe(&pIn->aData[pIn->iNext], nBuf, &nCol);
-    /* The hard upper limit for the number of columns in an SQLite
-    ** database table is, according to sqliteLimit.h, 32676. So
-    ** consider any table-header that purports to have more than 65536
-    ** columns to be corrupt. This is convenient because otherwise,
-    ** if the (nCol>65536) condition below were omitted, a sufficiently
-    ** large value for nCol may cause nRead to wrap around and become
-    ** negative. Leading to a crash. */
-    if( nCol<0 || nCol>65536 ){
-      rc = SQLITE_CORRUPT_BKPT;
-    }else{
-      rc = sessionInputBuffer(pIn, nRead+nCol+100);
-      nRead += nCol;
-    }
-  }
-
-  while( rc==SQLITE_OK ){
-    while( (pIn->iNext + nRead)<pIn->nData && pIn->aData[pIn->iNext + nRead] ){
-      nRead++;
-    }
-
-    /* Break out of the loop if if the nul-terminator byte has been found.
-    ** Otherwise, read some more input data and keep seeking. If there is
-    ** no more input data, consider the changeset corrupt.  */
-    if( (pIn->iNext + nRead)<pIn->nData ) break;
-    rc = sessionInputBuffer(pIn, nRead + 100);
-    if( rc==SQLITE_OK && (pIn->iNext + nRead)>=pIn->nData ){
-      rc = SQLITE_CORRUPT_BKPT;
-    }
-  }
-  *pnByte = nRead+1;
-  return rc;
-}
-
-/*
-** The input pointer currently points to the first byte of the first field
-** of a record consisting of nCol columns. This function ensures the entire
-** record is buffered. It does not move the input pointer.
-**
-** If successful, SQLITE_OK is returned and *pnByte is set to the size of
-** the record in bytes. Otherwise, an SQLite error code is returned. The
-** final value of *pnByte is undefined in this case.
-*/
-static int sessionChangesetBufferRecord(
-  SessionInput *pIn,              /* Input data */
-  int nCol,                       /* Number of columns in record */
-  int *pnByte                     /* OUT: Size of record in bytes */
-){
-  int rc = SQLITE_OK;
-  i64 nByte = 0;
-  int i;
-  for(i=0; rc==SQLITE_OK && i<nCol; i++){
-    int eType;
-    rc = sessionInputBuffer(pIn, nByte + 10);
-    if( rc==SQLITE_OK ){
-      eType = pIn->aData[pIn->iNext + nByte++];
-      if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){
-        int n;
-        int nRem = pIn->nData - (pIn->iNext + nByte);
-        nByte += sessionVarintGetSafe(&pIn->aData[pIn->iNext+nByte], nRem, &n);
-        nByte += n;
-        rc = sessionInputBuffer(pIn, nByte);
-      }else if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
-        nByte += 8;
-      }else if( eType!=0 && eType!=SQLITE_NULL ){
-        rc = SQLITE_CORRUPT_BKPT;
-      }
-    }
-    if( rc==SQLITE_OK && (pIn->iNext+nByte)>pIn->nData ){
-      rc = SQLITE_CORRUPT_BKPT;
-    }
-  }
-  *pnByte = nByte;
-  return rc;
-}
-
-/*
-** The input pointer currently points to the second byte of a table-header.
-** Specifically, to the following:
-**
-**   + number of columns in table (varint)
-**   + array of PK flags (1 byte per column),
-**   + table name (nul terminated).
-**
-** This function decodes the table-header and populates the p->nCol,
-** p->zTab and p->abPK[] variables accordingly. The p->apValue[] array is
-** also allocated or resized according to the new value of p->nCol. The
-** input pointer is left pointing to the byte following the table header.
-**
-** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code
-** is returned and the final values of the various fields enumerated above
-** are undefined.
-*/
-static int sessionChangesetReadTblhdr(sqlite3_changeset_iter *p){
-  int rc;
-  int nCopy;
-  assert( p->rc==SQLITE_OK );
-
-  rc = sessionChangesetBufferTblhdr(&p->in, &nCopy);
-  if( rc==SQLITE_OK ){
-    int nByte;
-    int nVarint;
-    nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
-    if( p->nCol>0 ){
-      nCopy -= nVarint;
-      p->in.iNext += nVarint;
-      nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy;
-      p->tblhdr.nBuf = 0;
-      sessionBufferGrow(&p->tblhdr, nByte, &rc);
-    }else{
-      rc = SQLITE_CORRUPT_BKPT;
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    size_t iPK = sizeof(sqlite3_value*)*p->nCol*2;
-    memset(p->tblhdr.aBuf, 0, iPK);
-    memcpy(&p->tblhdr.aBuf[iPK], &p->in.aData[p->in.iNext], nCopy);
-    p->in.iNext += nCopy;
-  }
-
-  p->apValue = (sqlite3_value**)p->tblhdr.aBuf;
-  if( p->apValue==0 ){
-    p->abPK = 0;
-    p->zTab = 0;
-  }else{
-    p->abPK = (u8*)&p->apValue[p->nCol*2];
-    p->zTab = p->abPK ? (char*)&p->abPK[p->nCol] : 0;
-  }
-  return (p->rc = rc);
-}
-
-/*
-** Advance the changeset iterator to the next change. The differences between
-** this function and sessionChangesetNext() are that
-**
-**   * If pbEmpty is not NULL and the change is a no-op UPDATE (an UPDATE
-**     that modifies no columns), this function sets (*pbEmpty) to 1.
-**
-**   * If the iterator is configured to skip no-op UPDATEs,
-**     sessionChangesetNext() does that. This function does not.
-*/
-static int sessionChangesetNextOne(
-  sqlite3_changeset_iter *p,      /* Changeset iterator */
-  u8 **paRec,                     /* If non-NULL, store record pointer here */
-  int *pnRec,                     /* If non-NULL, store size of record here */
-  int *pbNew,                     /* If non-NULL, true if new table */
-  int *pbEmpty
-){
-  int i;
-  u8 op;
-
-  assert( (paRec==0 && pnRec==0) || (paRec && pnRec) );
-  assert( pbEmpty==0 || *pbEmpty==0 );
-
-  /* If the iterator is in the error-state, return immediately. */
-  if( p->rc!=SQLITE_OK ) return p->rc;
-
-  /* Free the current contents of p->apValue[], if any. */
-  if( p->apValue ){
-    for(i=0; i<p->nCol*2; i++){
-      sqlite3ValueFree(p->apValue[i]);
-    }
-    memset(p->apValue, 0, sizeof(sqlite3_value*)*p->nCol*2);
-  }
-
-  /* Make sure the buffer contains at least 2 bytes of input data, or all
-  ** remaining data if there are less than 2 bytes available. This is
-  ** sufficient either for the 'T' or 'P' byte that begins a new table,
-  ** or for the "op" and "bIndirect" single bytes otherwise. */
-  p->rc = sessionInputBuffer(&p->in, 2);
-  if( p->rc!=SQLITE_OK ) return p->rc;
-
-  p->in.iCurrent = p->in.iNext;
-  sessionDiscardData(&p->in);
-
-  /* If the iterator is already at the end of the changeset, return DONE. */
-  if( p->in.iNext>=p->in.nData ){
-    return SQLITE_DONE;
-  }
-
-  op = p->in.aData[p->in.iNext++];
-  while( op=='T' || op=='P' ){
-    if( pbNew ) *pbNew = 1;
-    p->bPatchset = (op=='P');
-    if( sessionChangesetReadTblhdr(p) ) return p->rc;
-    if( (p->rc = sessionInputBuffer(&p->in, 2)) ) return p->rc;
-    p->in.iCurrent = p->in.iNext;
-    if( p->in.iNext>=p->in.nData ) return SQLITE_DONE;
-    op = p->in.aData[p->in.iNext++];
-  }
-
-  if( p->zTab==0 || (p->bPatchset && p->bInvert) ){
-    /* The first record in the changeset is not a table header. Must be a
-    ** corrupt changeset. */
-    assert( p->in.iNext==1 || p->zTab );
-    return (p->rc = SQLITE_CORRUPT_BKPT);
-  }
-
-  if( (op!=SQLITE_UPDATE && op!=SQLITE_DELETE && op!=SQLITE_INSERT)
-   || (p->in.iNext>=p->in.nData)
-  ){
-    return (p->rc = SQLITE_CORRUPT_BKPT);
-  }
-  p->op = op;
-  p->bIndirect = p->in.aData[p->in.iNext++];
-
-  if( paRec ){
-    int nVal;                     /* Number of values to buffer */
-    if( p->bPatchset==0 && op==SQLITE_UPDATE ){
-      nVal = p->nCol * 2;
-    }else if( p->bPatchset && op==SQLITE_DELETE ){
-      nVal = 0;
-      for(i=0; i<p->nCol; i++) if( p->abPK[i] ) nVal++;
-    }else{
-      nVal = p->nCol;
-    }
-    p->rc = sessionChangesetBufferRecord(&p->in, nVal, pnRec);
-    if( p->rc!=SQLITE_OK ) return p->rc;
-    *paRec = &p->in.aData[p->in.iNext];
-    p->in.iNext += *pnRec;
-  }else{
-    sqlite3_value **apOld = (p->bInvert ? &p->apValue[p->nCol] : p->apValue);
-    sqlite3_value **apNew = (p->bInvert ? p->apValue : &p->apValue[p->nCol]);
-
-    /* If this is an UPDATE or DELETE, read the old.* record. */
-    if( p->op!=SQLITE_INSERT && (p->bPatchset==0 || p->op==SQLITE_DELETE) ){
-      u8 *abPK = p->bPatchset ? p->abPK : 0;
-      p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld, 0);
-      if( p->rc!=SQLITE_OK ) return p->rc;
-    }
-
-    /* If this is an INSERT or UPDATE, read the new.* record. */
-    if( p->op!=SQLITE_DELETE ){
-      p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew, pbEmpty);
-      if( p->rc!=SQLITE_OK ) return p->rc;
-    }
-
-    if( (p->bPatchset || p->bInvert) && p->op==SQLITE_UPDATE ){
-      /* If this is an UPDATE that is part of a patchset, then all PK and
-      ** modified fields are present in the new.* record. The old.* record
-      ** is currently completely empty. This block shifts the PK fields from
-      ** new.* to old.*, to accommodate the code that reads these arrays.  */
-      for(i=0; i<p->nCol; i++){
-        assert( p->bPatchset==0 || p->apValue[i]==0 );
-        if( p->abPK[i] ){
-          assert( p->apValue[i]==0 );
-          p->apValue[i] = p->apValue[i+p->nCol];
-          if( p->apValue[i]==0 ) return (p->rc = SQLITE_CORRUPT_BKPT);
-          p->apValue[i+p->nCol] = 0;
-        }
-      }
-    }else if( p->bInvert ){
-      if( p->op==SQLITE_INSERT ) p->op = SQLITE_DELETE;
-      else if( p->op==SQLITE_DELETE ) p->op = SQLITE_INSERT;
-    }
-
-    /* If this is an UPDATE that is part of a changeset, then check that
-    ** there are no fields in the old.* record that are not (a) PK fields,
-    ** or (b) also present in the new.* record.
-    **
-    ** Such records are technically corrupt, but the rebaser was at one
-    ** point generating them. Under most circumstances this is benign, but
-    ** can cause spurious SQLITE_RANGE errors when applying the changeset. */
-    if( p->bPatchset==0 && p->op==SQLITE_UPDATE){
-      for(i=0; i<p->nCol; i++){
-        if( p->abPK[i]==0 && p->apValue[i+p->nCol]==0 ){
-          sqlite3ValueFree(p->apValue[i]);
-          p->apValue[i] = 0;
-        }
-      }
-    }
-  }
-
-  return SQLITE_ROW;
-}
-
-/*
-** Advance the changeset iterator to the next change.
-**
-** If both paRec and pnRec are NULL, then this function works like the public
-** API sqlite3changeset_next(). If SQLITE_ROW is returned, then the
-** sqlite3changeset_new() and old() APIs may be used to query for values.
-**
-** Otherwise, if paRec and pnRec are not NULL, then a pointer to the change
-** record is written to *paRec before returning and the number of bytes in
-** the record to *pnRec.
-**
-** Either way, this function returns SQLITE_ROW if the iterator is
-** successfully advanced to the next change in the changeset, an SQLite
-** error code if an error occurs, or SQLITE_DONE if there are no further
-** changes in the changeset.
-*/
-static int sessionChangesetNext(
-  sqlite3_changeset_iter *p,      /* Changeset iterator */
-  u8 **paRec,                     /* If non-NULL, store record pointer here */
-  int *pnRec,                     /* If non-NULL, store size of record here */
-  int *pbNew                      /* If non-NULL, true if new table */
-){
-  int bEmpty;
-  int rc;
-  do {
-    bEmpty = 0;
-    rc = sessionChangesetNextOne(p, paRec, pnRec, pbNew, &bEmpty);
-  }while( rc==SQLITE_ROW && p->bSkipEmpty && bEmpty);
-  return rc;
-}
-
-/*
-** Advance an iterator created by sqlite3changeset_start() to the next
-** change in the changeset. This function may return SQLITE_ROW, SQLITE_DONE
-** or SQLITE_CORRUPT.
-**
-** This function may not be called on iterators passed to a conflict handler
-** callback by changeset_apply().
-*/
-SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *p){
-  return sessionChangesetNext(p, 0, 0, 0);
-}
-
-/*
-** The following function extracts information on the current change
-** from a changeset iterator. It may only be called after changeset_next()
-** has returned SQLITE_ROW.
-*/
-SQLITE_API int sqlite3changeset_op(
-  sqlite3_changeset_iter *pIter,  /* Iterator handle */
-  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 if change is indirect */
-){
-  *pOp = pIter->op;
-  *pnCol = pIter->nCol;
-  *pzTab = pIter->zTab;
-  if( pbIndirect ) *pbIndirect = pIter->bIndirect;
-  return SQLITE_OK;
-}
-
-/*
-** Return information regarding the PRIMARY KEY and number of columns in
-** the database table affected by the change that pIter currently points
-** to. This function may only be called after changeset_next() returns
-** SQLITE_ROW.
-*/
-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 */
-){
-  *pabPK = pIter->abPK;
-  if( pnCol ) *pnCol = pIter->nCol;
-  return SQLITE_OK;
-}
-
-/*
-** This function may only be called while the iterator is pointing to an
-** SQLITE_UPDATE or SQLITE_DELETE change (see sqlite3changeset_op()).
-** Otherwise, SQLITE_MISUSE is returned.
-**
-** It sets *ppValue to point to an sqlite3_value structure containing the
-** iVal'th value in the old.* record. Or, if that particular value is not
-** included in the record (because the change is an UPDATE and the field
-** was not modified and is not a PK column), set *ppValue to NULL.
-**
-** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
-** not modified. Otherwise, SQLITE_OK.
-*/
-SQLITE_API int sqlite3changeset_old(
-  sqlite3_changeset_iter *pIter,  /* Changeset iterator */
-  int iVal,                       /* Index of old.* value to retrieve */
-  sqlite3_value **ppValue         /* OUT: Old value (or NULL pointer) */
-){
-  if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_DELETE ){
-    return SQLITE_MISUSE;
-  }
-  if( iVal<0 || iVal>=pIter->nCol ){
-    return SQLITE_RANGE;
-  }
-  *ppValue = pIter->apValue[iVal];
-  return SQLITE_OK;
-}
-
-/*
-** This function may only be called while the iterator is pointing to an
-** SQLITE_UPDATE or SQLITE_INSERT change (see sqlite3changeset_op()).
-** Otherwise, SQLITE_MISUSE is returned.
-**
-** It sets *ppValue to point to an sqlite3_value structure containing the
-** iVal'th value in the new.* record. Or, if that particular value is not
-** included in the record (because the change is an UPDATE and the field
-** was not modified), set *ppValue to NULL.
-**
-** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
-** not modified. Otherwise, SQLITE_OK.
-*/
-SQLITE_API int sqlite3changeset_new(
-  sqlite3_changeset_iter *pIter,  /* Changeset iterator */
-  int iVal,                       /* Index of new.* value to retrieve */
-  sqlite3_value **ppValue         /* OUT: New value (or NULL pointer) */
-){
-  if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_INSERT ){
-    return SQLITE_MISUSE;
-  }
-  if( iVal<0 || iVal>=pIter->nCol ){
-    return SQLITE_RANGE;
-  }
-  *ppValue = pIter->apValue[pIter->nCol+iVal];
-  return SQLITE_OK;
-}
-
-/*
-** The following two macros are used internally. They are similar to the
-** sqlite3changeset_new() and sqlite3changeset_old() functions, except that
-** they omit all error checking and return a pointer to the requested value.
-*/
-#define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
-#define sessionChangesetOld(pIter, iVal) (pIter)->apValue[(iVal)]
-
-/*
-** This function may only be called with a changeset iterator that has been
-** passed to an SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT
-** conflict-handler function. Otherwise, SQLITE_MISUSE is returned.
-**
-** If successful, *ppValue is set to point to an sqlite3_value structure
-** containing the iVal'th value of the conflicting record.
-**
-** If value iVal is out-of-range or some other error occurs, an SQLite error
-** code is returned. Otherwise, SQLITE_OK.
-*/
-SQLITE_API int sqlite3changeset_conflict(
-  sqlite3_changeset_iter *pIter,  /* Changeset iterator */
-  int iVal,                       /* Index of conflict record value to fetch */
-  sqlite3_value **ppValue         /* OUT: Value from conflicting row */
-){
-  if( !pIter->pConflict ){
-    return SQLITE_MISUSE;
-  }
-  if( iVal<0 || iVal>=pIter->nCol ){
-    return SQLITE_RANGE;
-  }
-  *ppValue = sqlite3_column_value(pIter->pConflict, iVal);
-  return SQLITE_OK;
-}
-
-/*
-** 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 */
-){
-  if( pIter->pConflict || pIter->apValue ){
-    return SQLITE_MISUSE;
-  }
-  *pnOut = pIter->nCol;
-  return SQLITE_OK;
-}
-
-
-/*
-** Finalize an iterator allocated with sqlite3changeset_start().
-**
-** This function may not be called on iterators passed to a conflict handler
-** callback by changeset_apply().
-*/
-SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *p){
-  int rc = SQLITE_OK;
-  if( p ){
-    int i;                        /* Used to iterate through p->apValue[] */
-    rc = p->rc;
-    if( p->apValue ){
-      for(i=0; i<p->nCol*2; i++) sqlite3ValueFree(p->apValue[i]);
-    }
-    sqlite3_free(p->tblhdr.aBuf);
-    sqlite3_free(p->in.buf.aBuf);
-    sqlite3_free(p);
-  }
-  return rc;
-}
-
-static int sessionChangesetInvert(
-  SessionInput *pInput,           /* Input changeset */
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut,
-  int *pnInverted,                /* OUT: Number of bytes in output changeset */
-  void **ppInverted               /* OUT: Inverse of pChangeset */
-){
-  int rc = SQLITE_OK;             /* Return value */
-  SessionBuffer sOut;             /* Output buffer */
-  int nCol = 0;                   /* Number of cols in current table */
-  u8 *abPK = 0;                   /* PK array for current table */
-  sqlite3_value **apVal = 0;      /* Space for values for UPDATE inversion */
-  SessionBuffer sPK = {0, 0, 0};  /* PK array for current table */
-
-  /* Initialize the output buffer */
-  memset(&sOut, 0, sizeof(SessionBuffer));
-
-  /* Zero the output variables in case an error occurs. */
-  if( ppInverted ){
-    *ppInverted = 0;
-    *pnInverted = 0;
-  }
-
-  while( 1 ){
-    u8 eType;
-
-    /* Test for EOF. */
-    if( (rc = sessionInputBuffer(pInput, 2)) ) goto finished_invert;
-    if( pInput->iNext>=pInput->nData ) break;
-    eType = pInput->aData[pInput->iNext];
-
-    switch( eType ){
-      case 'T': {
-        /* A 'table' record consists of:
-        **
-        **   * A constant 'T' character,
-        **   * Number of columns in said table (a varint),
-        **   * An array of nCol bytes (sPK),
-        **   * A nul-terminated table name.
-        */
-        int nByte;
-        int nVar;
-        pInput->iNext++;
-        if( (rc = sessionChangesetBufferTblhdr(pInput, &nByte)) ){
-          goto finished_invert;
-        }
-        nVar = sessionVarintGet(&pInput->aData[pInput->iNext], &nCol);
-        sPK.nBuf = 0;
-        sessionAppendBlob(&sPK, &pInput->aData[pInput->iNext+nVar], nCol, &rc);
-        sessionAppendByte(&sOut, eType, &rc);
-        sessionAppendBlob(&sOut, &pInput->aData[pInput->iNext], nByte, &rc);
-        if( rc ) goto finished_invert;
-
-        pInput->iNext += nByte;
-        sqlite3_free(apVal);
-        apVal = 0;
-        abPK = sPK.aBuf;
-        break;
-      }
-
-      case SQLITE_INSERT:
-      case SQLITE_DELETE: {
-        int nByte;
-        int bIndirect = pInput->aData[pInput->iNext+1];
-        int eType2 = (eType==SQLITE_DELETE ? SQLITE_INSERT : SQLITE_DELETE);
-        pInput->iNext += 2;
-        assert( rc==SQLITE_OK );
-        rc = sessionChangesetBufferRecord(pInput, nCol, &nByte);
-        sessionAppendByte(&sOut, eType2, &rc);
-        sessionAppendByte(&sOut, bIndirect, &rc);
-        sessionAppendBlob(&sOut, &pInput->aData[pInput->iNext], nByte, &rc);
-        pInput->iNext += nByte;
-        if( rc ) goto finished_invert;
-        break;
-      }
-
-      case SQLITE_UPDATE: {
-        int iCol;
-
-        if( 0==apVal ){
-          apVal = (sqlite3_value **)sqlite3_malloc64(sizeof(apVal[0])*nCol*2);
-          if( 0==apVal ){
-            rc = SQLITE_NOMEM;
-            goto finished_invert;
-          }
-          memset(apVal, 0, sizeof(apVal[0])*nCol*2);
-        }
-
-        /* Write the header for the new UPDATE change. Same as the original. */
-        sessionAppendByte(&sOut, eType, &rc);
-        sessionAppendByte(&sOut, pInput->aData[pInput->iNext+1], &rc);
-
-        /* Read the old.* and new.* records for the update change. */
-        pInput->iNext += 2;
-        rc = sessionReadRecord(pInput, nCol, 0, &apVal[0], 0);
-        if( rc==SQLITE_OK ){
-          rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol], 0);
-        }
-
-        /* Write the new old.* record. Consists of the PK columns from the
-        ** original old.* record, and the other values from the original
-        ** new.* record. */
-        for(iCol=0; iCol<nCol; iCol++){
-          sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
-          sessionAppendValue(&sOut, pVal, &rc);
-        }
-
-        /* Write the new new.* record. Consists of a copy of all values
-        ** from the original old.* record, except for the PK columns, which
-        ** are set to "undefined". */
-        for(iCol=0; iCol<nCol; iCol++){
-          sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
-          sessionAppendValue(&sOut, pVal, &rc);
-        }
-
-        for(iCol=0; iCol<nCol*2; iCol++){
-          sqlite3ValueFree(apVal[iCol]);
-        }
-        memset(apVal, 0, sizeof(apVal[0])*nCol*2);
-        if( rc!=SQLITE_OK ){
-          goto finished_invert;
-        }
-
-        break;
-      }
-
-      default:
-        rc = SQLITE_CORRUPT_BKPT;
-        goto finished_invert;
-    }
-
-    assert( rc==SQLITE_OK );
-    if( xOutput && sOut.nBuf>=sessions_strm_chunk_size ){
-      rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
-      sOut.nBuf = 0;
-      if( rc!=SQLITE_OK ) goto finished_invert;
-    }
-  }
-
-  assert( rc==SQLITE_OK );
-  if( pnInverted && ALWAYS(ppInverted) ){
-    *pnInverted = sOut.nBuf;
-    *ppInverted = sOut.aBuf;
-    sOut.aBuf = 0;
-  }else if( sOut.nBuf>0 && ALWAYS(xOutput!=0) ){
-    rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
-  }
-
- finished_invert:
-  sqlite3_free(sOut.aBuf);
-  sqlite3_free(apVal);
-  sqlite3_free(sPK.aBuf);
-  return rc;
-}
-
-
-/*
-** Invert a changeset object.
-*/
-SQLITE_API int sqlite3changeset_invert(
-  int nChangeset,                 /* Number of bytes in input */
-  const void *pChangeset,         /* Input changeset */
-  int *pnInverted,                /* OUT: Number of bytes in output changeset */
-  void **ppInverted               /* OUT: Inverse of pChangeset */
-){
-  SessionInput sInput;
-
-  /* Set up the input stream */
-  memset(&sInput, 0, sizeof(SessionInput));
-  sInput.nData = nChangeset;
-  sInput.aData = (u8*)pChangeset;
-
-  return sessionChangesetInvert(&sInput, 0, 0, pnInverted, ppInverted);
-}
-
-/*
-** Streaming version of sqlite3changeset_invert().
-*/
-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
-){
-  SessionInput sInput;
-  int rc;
-
-  /* Set up the input stream */
-  memset(&sInput, 0, sizeof(SessionInput));
-  sInput.xInput = xInput;
-  sInput.pIn = pIn;
-
-  rc = sessionChangesetInvert(&sInput, xOutput, pOut, 0, 0);
-  sqlite3_free(sInput.buf.aBuf);
-  return rc;
-}
-
-
-typedef struct SessionUpdate SessionUpdate;
-struct SessionUpdate {
-  sqlite3_stmt *pStmt;
-  u32 *aMask;
-  SessionUpdate *pNext;
-};
-
-typedef struct SessionApplyCtx SessionApplyCtx;
-struct SessionApplyCtx {
-  sqlite3 *db;
-  sqlite3_stmt *pDelete;          /* DELETE statement */
-  sqlite3_stmt *pInsert;          /* INSERT statement */
-  sqlite3_stmt *pSelect;          /* SELECT statement */
-  int nCol;                       /* Size of azCol[] and abPK[] arrays */
-  const char **azCol;             /* Array of column names */
-  u8 *abPK;                       /* Boolean array - true if column is in PK */
-  u32 *aUpdateMask;               /* Used by sessionUpdateFind */
-  SessionUpdate *pUp;
-  int bStat1;                     /* True if table is sqlite_stat1 */
-  int bDeferConstraints;          /* True to defer constraints */
-  int bInvertConstraints;         /* Invert when iterating constraints buffer */
-  SessionBuffer constraints;      /* Deferred constraints are stored here */
-  SessionBuffer rebase;           /* Rebase information (if any) here */
-  u8 bRebaseStarted;              /* If table header is already in rebase */
-  u8 bRebase;                     /* True to collect rebase information */
-  u8 bIgnoreNoop;                 /* True to ignore no-op conflicts */
-  int bRowid;
-  char *zErr;                     /* Error message, if any */
-};
-
-/* Number of prepared UPDATE statements to cache. */
-#define SESSION_UPDATE_CACHE_SZ 12
-
-/*
-** Find a prepared UPDATE statement suitable for the UPDATE step currently
-** being visited by the iterator. The UPDATE is of the form:
-**
-**   UPDATE tbl SET col = ?, col2 = ? WHERE pk1 IS ? AND pk2 IS ?
-*/
-static int sessionUpdateFind(
-  sqlite3_changeset_iter *pIter,
-  SessionApplyCtx *p,
-  int bPatchset,
-  sqlite3_stmt **ppStmt
-){
-  int rc = SQLITE_OK;
-  SessionUpdate *pUp = 0;
-  int nCol = pIter->nCol;
-  int nU32 = (pIter->nCol+33)/32;
-  int ii;
-
-  if( p->aUpdateMask==0 ){
-    p->aUpdateMask = sqlite3_malloc(nU32*sizeof(u32));
-    if( p->aUpdateMask==0 ){
-      rc = SQLITE_NOMEM;
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    memset(p->aUpdateMask, 0, nU32*sizeof(u32));
-    rc = SQLITE_CORRUPT;
-    for(ii=0; ii<pIter->nCol; ii++){
-      if( sessionChangesetNew(pIter, ii) ){
-        p->aUpdateMask[ii/32] |= (1<<(ii%32));
-        rc = SQLITE_OK;
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    if( bPatchset ) p->aUpdateMask[nCol/32] |= (1<<(nCol%32));
-
-    if( p->pUp ){
-      int nUp = 0;
-      SessionUpdate **pp = &p->pUp;
-      while( 1 ){
-        nUp++;
-        if( 0==memcmp(p->aUpdateMask, (*pp)->aMask, nU32*sizeof(u32)) ){
-          pUp = *pp;
-          *pp = pUp->pNext;
-          pUp->pNext = p->pUp;
-          p->pUp = pUp;
-          break;
-        }
-
-        if( (*pp)->pNext ){
-          pp = &(*pp)->pNext;
-        }else{
-          if( nUp>=SESSION_UPDATE_CACHE_SZ ){
-            sqlite3_finalize((*pp)->pStmt);
-            sqlite3_free(*pp);
-            *pp = 0;
-          }
-          break;
-        }
-      }
-    }
-
-    if( pUp==0 ){
-      int nByte = sizeof(SessionUpdate) * nU32*sizeof(u32);
-      int bStat1 = (sqlite3_stricmp(pIter->zTab, "sqlite_stat1")==0);
-      pUp = (SessionUpdate*)sqlite3_malloc(nByte);
-      if( pUp==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        const char *zSep = "";
-        SessionBuffer buf;
-
-        memset(&buf, 0, sizeof(buf));
-        pUp->aMask = (u32*)&pUp[1];
-        memcpy(pUp->aMask, p->aUpdateMask, nU32*sizeof(u32));
-
-        sessionAppendStr(&buf, "UPDATE main.", &rc);
-        sessionAppendIdent(&buf, pIter->zTab, &rc);
-        sessionAppendStr(&buf, " SET ", &rc);
-
-        /* Create the assignments part of the UPDATE */
-        for(ii=0; ii<pIter->nCol; ii++){
-          if( p->abPK[ii]==0 && sessionChangesetNew(pIter, ii) ){
-            sessionAppendStr(&buf, zSep, &rc);
-            sessionAppendIdent(&buf, p->azCol[ii], &rc);
-            sessionAppendStr(&buf, " = ?", &rc);
-            sessionAppendInteger(&buf, ii*2+1, &rc);
-            zSep = ", ";
-          }
-        }
-
-        /* Create the WHERE clause part of the UPDATE */
-        zSep = "";
-        sessionAppendStr(&buf, " WHERE ", &rc);
-        for(ii=0; ii<pIter->nCol; ii++){
-          if( p->abPK[ii] || (bPatchset==0 && sessionChangesetOld(pIter, ii)) ){
-            sessionAppendStr(&buf, zSep, &rc);
-            if( bStat1 && ii==1 ){
-              assert( sqlite3_stricmp(p->azCol[ii], "idx")==0 );
-              sessionAppendStr(&buf,
-                  "idx IS CASE "
-                  "WHEN length(?4)=0 AND typeof(?4)='blob' THEN NULL "
-                  "ELSE ?4 END ", &rc
-              );
-            }else{
-              sessionAppendIdent(&buf, p->azCol[ii], &rc);
-              sessionAppendStr(&buf, " IS ?", &rc);
-              sessionAppendInteger(&buf, ii*2+2, &rc);
-            }
-            zSep = " AND ";
-          }
-        }
-
-        if( rc==SQLITE_OK ){
-          char *zSql = (char*)buf.aBuf;
-          rc = sqlite3_prepare_v2(p->db, zSql, buf.nBuf, &pUp->pStmt, 0);
-        }
-
-        if( rc!=SQLITE_OK ){
-          sqlite3_free(pUp);
-          pUp = 0;
-        }else{
-          pUp->pNext = p->pUp;
-          p->pUp = pUp;
-        }
-        sqlite3_free(buf.aBuf);
-      }
-    }
-  }
-
-  assert( (rc==SQLITE_OK)==(pUp!=0) );
-  if( pUp ){
-    *ppStmt = pUp->pStmt;
-  }else{
-    *ppStmt = 0;
-  }
-  return rc;
-}
-
-/*
-** Free all cached UPDATE statements.
-*/
-static void sessionUpdateFree(SessionApplyCtx *p){
-  SessionUpdate *pUp;
-  SessionUpdate *pNext;
-  for(pUp=p->pUp; pUp; pUp=pNext){
-    pNext = pUp->pNext;
-    sqlite3_finalize(pUp->pStmt);
-    sqlite3_free(pUp);
-  }
-  p->pUp = 0;
-  sqlite3_free(p->aUpdateMask);
-  p->aUpdateMask = 0;
-}
-
-/*
-** Formulate a statement to DELETE a row from database db. Assuming a table
-** structure like this:
-**
-**     CREATE TABLE x(a, b, c, d, PRIMARY KEY(a, c));
-**
-** The DELETE statement looks like this:
-**
-**     DELETE FROM x WHERE a = :1 AND c = :3 AND (:5 OR b IS :2 AND d IS :4)
-**
-** Variable :5 (nCol+1) is a boolean. It should be set to 0 if we require
-** matching b and d values, or 1 otherwise. The second case comes up if the
-** conflict handler is invoked with NOTFOUND and returns CHANGESET_REPLACE.
-**
-** If successful, SQLITE_OK is returned and SessionApplyCtx.pDelete is left
-** pointing to the prepared version of the SQL statement.
-*/
-static int sessionDeleteRow(
-  sqlite3 *db,                    /* Database handle */
-  const char *zTab,               /* Table name */
-  SessionApplyCtx *p              /* Session changeset-apply context */
-){
-  int i;
-  const char *zSep = "";
-  int rc = SQLITE_OK;
-  SessionBuffer buf = {0, 0, 0};
-  int nPk = 0;
-
-  sessionAppendStr(&buf, "DELETE FROM main.", &rc);
-  sessionAppendIdent(&buf, zTab, &rc);
-  sessionAppendStr(&buf, " WHERE ", &rc);
-
-  for(i=0; i<p->nCol; i++){
-    if( p->abPK[i] ){
-      nPk++;
-      sessionAppendStr(&buf, zSep, &rc);
-      sessionAppendIdent(&buf, p->azCol[i], &rc);
-      sessionAppendStr(&buf, " = ?", &rc);
-      sessionAppendInteger(&buf, i+1, &rc);
-      zSep = " AND ";
-    }
-  }
-
-  if( nPk<p->nCol ){
-    sessionAppendStr(&buf, " AND (?", &rc);
-    sessionAppendInteger(&buf, p->nCol+1, &rc);
-    sessionAppendStr(&buf, " OR ", &rc);
-
-    zSep = "";
-    for(i=0; i<p->nCol; i++){
-      if( !p->abPK[i] ){
-        sessionAppendStr(&buf, zSep, &rc);
-        sessionAppendIdent(&buf, p->azCol[i], &rc);
-        sessionAppendStr(&buf, " IS ?", &rc);
-        sessionAppendInteger(&buf, i+1, &rc);
-        zSep = "AND ";
-      }
-    }
-    sessionAppendStr(&buf, ")", &rc);
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = sessionPrepare(db, &p->pDelete, &p->zErr, (char*)buf.aBuf);
-  }
-  sqlite3_free(buf.aBuf);
-
-  return rc;
-}
-
-/*
-** Formulate and prepare an SQL statement to query table zTab by primary
-** key. Assuming the following table structure:
-**
-**     CREATE TABLE x(a, b, c, d, PRIMARY KEY(a, c));
-**
-** The SELECT statement looks like this:
-**
-**     SELECT * FROM x WHERE a = ?1 AND c = ?3
-**
-** If successful, SQLITE_OK is returned and SessionApplyCtx.pSelect is left
-** pointing to the prepared version of the SQL statement.
-*/
-static int sessionSelectRow(
-  sqlite3 *db,                    /* Database handle */
-  const char *zTab,               /* Table name */
-  SessionApplyCtx *p              /* Session changeset-apply context */
-){
-  /* TODO */
-  return sessionSelectStmt(db, p->bIgnoreNoop,
-      "main", zTab, p->bRowid, p->nCol, p->azCol, p->abPK, &p->pSelect, &p->zErr
-  );
-}
-
-/*
-** Formulate and prepare an INSERT statement to add a record to table zTab.
-** For example:
-**
-**     INSERT INTO main."zTab" VALUES(?1, ?2, ?3 ...);
-**
-** If successful, SQLITE_OK is returned and SessionApplyCtx.pInsert is left
-** pointing to the prepared version of the SQL statement.
-*/
-static int sessionInsertRow(
-  sqlite3 *db,                    /* Database handle */
-  const char *zTab,               /* Table name */
-  SessionApplyCtx *p              /* Session changeset-apply context */
-){
-  int rc = SQLITE_OK;
-  int i;
-  SessionBuffer buf = {0, 0, 0};
-
-  sessionAppendStr(&buf, "INSERT INTO main.", &rc);
-  sessionAppendIdent(&buf, zTab, &rc);
-  sessionAppendStr(&buf, "(", &rc);
-  for(i=0; i<p->nCol; i++){
-    if( i!=0 ) sessionAppendStr(&buf, ", ", &rc);
-    sessionAppendIdent(&buf, p->azCol[i], &rc);
-  }
-
-  sessionAppendStr(&buf, ") VALUES(?", &rc);
-  for(i=1; i<p->nCol; i++){
-    sessionAppendStr(&buf, ", ?", &rc);
-  }
-  sessionAppendStr(&buf, ")", &rc);
-
-  if( rc==SQLITE_OK ){
-    rc = sessionPrepare(db, &p->pInsert, &p->zErr, (char*)buf.aBuf);
-  }
-  sqlite3_free(buf.aBuf);
-  return rc;
-}
-
-/*
-** Prepare statements for applying changes to the sqlite_stat1 table.
-** These are similar to those created by sessionSelectRow(),
-** sessionInsertRow(), sessionUpdateRow() and sessionDeleteRow() for
-** other tables.
-*/
-static int sessionStat1Sql(sqlite3 *db, SessionApplyCtx *p){
-  int rc = sessionSelectRow(db, "sqlite_stat1", p);
-  if( rc==SQLITE_OK ){
-    rc = sessionPrepare(db, &p->pInsert, 0,
-        "INSERT INTO main.sqlite_stat1 VALUES(?1, "
-        "CASE WHEN length(?2)=0 AND typeof(?2)='blob' THEN NULL ELSE ?2 END, "
-        "?3)"
-    );
-  }
-  if( rc==SQLITE_OK ){
-    rc = sessionPrepare(db, &p->pDelete, 0,
-        "DELETE FROM main.sqlite_stat1 WHERE tbl=?1 AND idx IS "
-        "CASE WHEN length(?2)=0 AND typeof(?2)='blob' THEN NULL ELSE ?2 END "
-        "AND (?4 OR stat IS ?3)"
-    );
-  }
-  return rc;
-}
-
-/*
-** A wrapper around sqlite3_bind_value() that detects an extra problem.
-** See comments in the body of this function for details.
-*/
-static int sessionBindValue(
-  sqlite3_stmt *pStmt,            /* Statement to bind value to */
-  int i,                          /* Parameter number to bind to */
-  sqlite3_value *pVal             /* Value to bind */
-){
-  int eType = sqlite3_value_type(pVal);
-  /* COVERAGE: The (pVal->z==0) branch is never true using current versions
-  ** of SQLite. If a malloc fails in an sqlite3_value_xxx() function, either
-  ** the (pVal->z) variable remains as it was or the type of the value is
-  ** set to SQLITE_NULL.  */
-  if( (eType==SQLITE_TEXT || eType==SQLITE_BLOB) && pVal->z==0 ){
-    /* This condition occurs when an earlier OOM in a call to
-    ** sqlite3_value_text() or sqlite3_value_blob() (perhaps from within
-    ** a conflict-handler) has zeroed the pVal->z pointer. Return NOMEM. */
-    return SQLITE_NOMEM;
-  }
-  return sqlite3_bind_value(pStmt, i, pVal);
-}
-
-/*
-** Iterator pIter must point to an SQLITE_INSERT entry. This function
-** transfers new.* values from the current iterator entry to statement
-** pStmt. The table being inserted into has nCol columns.
-**
-** New.* value $i from the iterator is bound to variable ($i+1) of
-** statement pStmt. If parameter abPK is NULL, all values from 0 to (nCol-1)
-** are transfered to the statement. Otherwise, if abPK is not NULL, it points
-** to an array nCol elements in size. In this case only those values for
-** which abPK[$i] is true are read from the iterator and bound to the
-** statement.
-**
-** An SQLite error code is returned if an error occurs. Otherwise, SQLITE_OK.
-*/
-static int sessionBindRow(
-  sqlite3_changeset_iter *pIter,  /* Iterator to read values from */
-  int(*xValue)(sqlite3_changeset_iter *, int, sqlite3_value **),
-  int nCol,                       /* Number of columns */
-  u8 *abPK,                       /* If not NULL, bind only if true */
-  sqlite3_stmt *pStmt             /* Bind values to this statement */
-){
-  int i;
-  int rc = SQLITE_OK;
-
-  /* Neither sqlite3changeset_old or sqlite3changeset_new can fail if the
-  ** argument iterator points to a suitable entry. Make sure that xValue
-  ** is one of these to guarantee that it is safe to ignore the return
-  ** in the code below. */
-  assert( xValue==sqlite3changeset_old || xValue==sqlite3changeset_new );
-
-  for(i=0; rc==SQLITE_OK && i<nCol; i++){
-    if( !abPK || abPK[i] ){
-      sqlite3_value *pVal = 0;
-      (void)xValue(pIter, i, &pVal);
-      if( pVal==0 ){
-        /* The value in the changeset was "undefined". This indicates a
-        ** corrupt changeset blob.  */
-        rc = SQLITE_CORRUPT_BKPT;
-      }else{
-        rc = sessionBindValue(pStmt, i+1, pVal);
-      }
-    }
-  }
-  return rc;
-}
-
-/*
-** SQL statement pSelect is as generated by the sessionSelectRow() function.
-** This function binds the primary key values from the change that changeset
-** iterator pIter points to to the SELECT and attempts to seek to the table
-** entry. If a row is found, the SELECT statement left pointing at the row
-** and SQLITE_ROW is returned. Otherwise, if no row is found and no error
-** has occured, the statement is reset and SQLITE_OK is returned. If an
-** error occurs, the statement is reset and an SQLite error code is returned.
-**
-** If this function returns SQLITE_ROW, the caller must eventually reset()
-** statement pSelect. If any other value is returned, the statement does
-** not require a reset().
-**
-** If the iterator currently points to an INSERT record, bind values from the
-** new.* record to the SELECT statement. Or, if it points to a DELETE or
-** UPDATE, bind values from the old.* record.
-*/
-static int sessionSeekToRow(
-  sqlite3_changeset_iter *pIter,  /* Changeset iterator */
-  SessionApplyCtx *p
-){
-  sqlite3_stmt *pSelect = p->pSelect;
-  int rc;                         /* Return code */
-  int nCol;                       /* Number of columns in table */
-  int op;                         /* Changset operation (SQLITE_UPDATE etc.) */
-  const char *zDummy;             /* Unused */
-
-  sqlite3_clear_bindings(pSelect);
-  sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
-  rc = sessionBindRow(pIter,
-      op==SQLITE_INSERT ? sqlite3changeset_new : sqlite3changeset_old,
-      nCol, p->abPK, pSelect
-  );
-
-  if( op!=SQLITE_DELETE && p->bIgnoreNoop ){
-    int ii;
-    for(ii=0; rc==SQLITE_OK && ii<nCol; ii++){
-      if( p->abPK[ii]==0 ){
-        sqlite3_value *pVal = 0;
-        sqlite3changeset_new(pIter, ii, &pVal);
-        sqlite3_bind_int(pSelect, ii+1+nCol, (pVal==0));
-        if( pVal ) rc = sessionBindValue(pSelect, ii+1, pVal);
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_step(pSelect);
-    if( rc!=SQLITE_ROW ) rc = sqlite3_reset(pSelect);
-  }
-
-  return rc;
-}
-
-/*
-** This function is called from within sqlite3changeset_apply_v2() when
-** a conflict is encountered and resolved using conflict resolution
-** mode eType (either SQLITE_CHANGESET_OMIT or SQLITE_CHANGESET_REPLACE)..
-** It adds a conflict resolution record to the buffer in
-** SessionApplyCtx.rebase, which will eventually be returned to the caller
-** of apply_v2() as the "rebase" buffer.
-**
-** Return SQLITE_OK if successful, or an SQLite error code otherwise.
-*/
-static int sessionRebaseAdd(
-  SessionApplyCtx *p,             /* Apply context */
-  int eType,                      /* Conflict resolution (OMIT or REPLACE) */
-  sqlite3_changeset_iter *pIter   /* Iterator pointing at current change */
-){
-  int rc = SQLITE_OK;
-  if( p->bRebase ){
-    int i;
-    int eOp = pIter->op;
-    if( p->bRebaseStarted==0 ){
-      /* Append a table-header to the rebase buffer */
-      const char *zTab = pIter->zTab;
-      sessionAppendByte(&p->rebase, 'T', &rc);
-      sessionAppendVarint(&p->rebase, p->nCol, &rc);
-      sessionAppendBlob(&p->rebase, p->abPK, p->nCol, &rc);
-      sessionAppendBlob(&p->rebase, (u8*)zTab, (int)strlen(zTab)+1, &rc);
-      p->bRebaseStarted = 1;
-    }
-
-    assert( eType==SQLITE_CHANGESET_REPLACE||eType==SQLITE_CHANGESET_OMIT );
-    assert( eOp==SQLITE_DELETE || eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE );
-
-    sessionAppendByte(&p->rebase,
-        (eOp==SQLITE_DELETE ? SQLITE_DELETE : SQLITE_INSERT), &rc
-        );
-    sessionAppendByte(&p->rebase, (eType==SQLITE_CHANGESET_REPLACE), &rc);
-    for(i=0; i<p->nCol; i++){
-      sqlite3_value *pVal = 0;
-      if( eOp==SQLITE_DELETE || (eOp==SQLITE_UPDATE && p->abPK[i]) ){
-        sqlite3changeset_old(pIter, i, &pVal);
-      }else{
-        sqlite3changeset_new(pIter, i, &pVal);
-      }
-      sessionAppendValue(&p->rebase, pVal, &rc);
-    }
-  }
-  return rc;
-}
-
-/*
-** Invoke the conflict handler for the change that the changeset iterator
-** currently points to.
-**
-** Argument eType must be either CHANGESET_DATA or CHANGESET_CONFLICT.
-** If argument pbReplace is NULL, then the type of conflict handler invoked
-** depends solely on eType, as follows:
-**
-**    eType value                 Value passed to xConflict
-**    -------------------------------------------------
-**    CHANGESET_DATA              CHANGESET_NOTFOUND
-**    CHANGESET_CONFLICT          CHANGESET_CONSTRAINT
-**
-** Or, if pbReplace is not NULL, then an attempt is made to find an existing
-** record with the same primary key as the record about to be deleted, updated
-** or inserted. If such a record can be found, it is available to the conflict
-** handler as the "conflicting" record. In this case the type of conflict
-** handler invoked is as follows:
-**
-**    eType value         PK Record found?   Value passed to xConflict
-**    ----------------------------------------------------------------
-**    CHANGESET_DATA      Yes                CHANGESET_DATA
-**    CHANGESET_DATA      No                 CHANGESET_NOTFOUND
-**    CHANGESET_CONFLICT  Yes                CHANGESET_CONFLICT
-**    CHANGESET_CONFLICT  No                 CHANGESET_CONSTRAINT
-**
-** If pbReplace is not NULL, and a record with a matching PK is found, and
-** the conflict handler function returns SQLITE_CHANGESET_REPLACE, *pbReplace
-** is set to non-zero before returning SQLITE_OK.
-**
-** If the conflict handler returns SQLITE_CHANGESET_ABORT, SQLITE_ABORT is
-** returned. Or, if the conflict handler returns an invalid value,
-** SQLITE_MISUSE. If the conflict handler returns SQLITE_CHANGESET_OMIT,
-** this function returns SQLITE_OK.
-*/
-static int sessionConflictHandler(
-  int eType,                      /* Either CHANGESET_DATA or CONFLICT */
-  SessionApplyCtx *p,             /* changeset_apply() context */
-  sqlite3_changeset_iter *pIter,  /* Changeset iterator */
-  int(*xConflict)(void *, int, sqlite3_changeset_iter*),
-  void *pCtx,                     /* First argument for conflict handler */
-  int *pbReplace                  /* OUT: Set to true if PK row is found */
-){
-  int res = SQLITE_CHANGESET_OMIT;/* Value returned by conflict handler */
-  int rc;
-  int nCol;
-  int op;
-  const char *zDummy;
-
-  sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
-
-  assert( eType==SQLITE_CHANGESET_CONFLICT || eType==SQLITE_CHANGESET_DATA );
-  assert( SQLITE_CHANGESET_CONFLICT+1==SQLITE_CHANGESET_CONSTRAINT );
-  assert( SQLITE_CHANGESET_DATA+1==SQLITE_CHANGESET_NOTFOUND );
-
-  /* Bind the new.* PRIMARY KEY values to the SELECT statement. */
-  if( pbReplace ){
-    rc = sessionSeekToRow(pIter, p);
-  }else{
-    rc = SQLITE_OK;
-  }
-
-  if( rc==SQLITE_ROW ){
-    /* There exists another row with the new.* primary key. */
-    if( 0==p->bIgnoreNoop
-     || 0==sqlite3_column_int(p->pSelect, sqlite3_column_count(p->pSelect)-1)
-    ){
-      pIter->pConflict = p->pSelect;
-      res = xConflict(pCtx, eType, pIter);
-      pIter->pConflict = 0;
-    }
-    rc = sqlite3_reset(p->pSelect);
-  }else if( rc==SQLITE_OK ){
-    if( p->bDeferConstraints && eType==SQLITE_CHANGESET_CONFLICT ){
-      /* Instead of invoking the conflict handler, append the change blob
-      ** to the SessionApplyCtx.constraints buffer. */
-      u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
-      int nBlob = pIter->in.iNext - pIter->in.iCurrent;
-      sessionAppendBlob(&p->constraints, aBlob, nBlob, &rc);
-      return SQLITE_OK;
-    }else if( p->bIgnoreNoop==0 || op!=SQLITE_DELETE
-           || eType==SQLITE_CHANGESET_CONFLICT
-    ){
-      /* No other row with the new.* primary key. */
-      res = xConflict(pCtx, eType+1, pIter);
-      if( res==SQLITE_CHANGESET_REPLACE ) rc = SQLITE_MISUSE;
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    switch( res ){
-      case SQLITE_CHANGESET_REPLACE:
-        assert( pbReplace );
-        *pbReplace = 1;
-        break;
-
-      case SQLITE_CHANGESET_OMIT:
-        break;
-
-      case SQLITE_CHANGESET_ABORT:
-        rc = SQLITE_ABORT;
-        break;
-
-      default:
-        rc = SQLITE_MISUSE;
-        break;
-    }
-    if( rc==SQLITE_OK ){
-      rc = sessionRebaseAdd(p, res, pIter);
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Attempt to apply the change that the iterator passed as the first argument
-** currently points to to the database. If a conflict is encountered, invoke
-** the conflict handler callback.
-**
-** If argument pbRetry is NULL, then ignore any CHANGESET_DATA conflict. If
-** one is encountered, update or delete the row with the matching primary key
-** instead. Or, if pbRetry is not NULL and a CHANGESET_DATA conflict occurs,
-** invoke the conflict handler. If it returns CHANGESET_REPLACE, set *pbRetry
-** to true before returning. In this case the caller will invoke this function
-** again, this time with pbRetry set to NULL.
-**
-** If argument pbReplace is NULL and a CHANGESET_CONFLICT conflict is
-** encountered invoke the conflict handler with CHANGESET_CONSTRAINT instead.
-** Or, if pbReplace is not NULL, invoke it with CHANGESET_CONFLICT. If such
-** an invocation returns SQLITE_CHANGESET_REPLACE, set *pbReplace to true
-** before retrying. In this case the caller attempts to remove the conflicting
-** row before invoking this function again, this time with pbReplace set
-** to NULL.
-**
-** If any conflict handler returns SQLITE_CHANGESET_ABORT, this function
-** returns SQLITE_ABORT. Otherwise, if no error occurs, SQLITE_OK is
-** returned.
-*/
-static int sessionApplyOneOp(
-  sqlite3_changeset_iter *pIter,  /* Changeset iterator */
-  SessionApplyCtx *p,             /* changeset_apply() context */
-  int(*xConflict)(void *, int, sqlite3_changeset_iter *),
-  void *pCtx,                     /* First argument for the conflict handler */
-  int *pbReplace,                 /* OUT: True to remove PK row and retry */
-  int *pbRetry                    /* OUT: True to retry. */
-){
-  const char *zDummy;
-  int op;
-  int nCol;
-  int rc = SQLITE_OK;
-
-  assert( p->pDelete && p->pInsert && p->pSelect );
-  assert( p->azCol && p->abPK );
-  assert( !pbReplace || *pbReplace==0 );
-
-  sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
-
-  if( op==SQLITE_DELETE ){
-
-    /* Bind values to the DELETE statement. If conflict handling is required,
-    ** bind values for all columns and set bound variable (nCol+1) to true.
-    ** Or, if conflict handling is not required, bind just the PK column
-    ** values and, if it exists, set (nCol+1) to false. Conflict handling
-    ** is not required if:
-    **
-    **   * this is a patchset, or
-    **   * (pbRetry==0), or
-    **   * all columns of the table are PK columns (in this case there is
-    **     no (nCol+1) variable to bind to).
-    */
-    u8 *abPK = (pIter->bPatchset ? p->abPK : 0);
-    rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
-    if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
-      rc = sqlite3_bind_int(p->pDelete, nCol+1, (pbRetry==0 || abPK));
-    }
-    if( rc!=SQLITE_OK ) return rc;
-
-    sqlite3_step(p->pDelete);
-    rc = sqlite3_reset(p->pDelete);
-    if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 ){
-      rc = sessionConflictHandler(
-          SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
-      );
-    }else if( (rc&0xff)==SQLITE_CONSTRAINT ){
-      rc = sessionConflictHandler(
-          SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
-      );
-    }
-
-  }else if( op==SQLITE_UPDATE ){
-    int i;
-    sqlite3_stmt *pUp = 0;
-    int bPatchset = (pbRetry==0 || pIter->bPatchset);
-
-    rc = sessionUpdateFind(pIter, p, bPatchset, &pUp);
-
-    /* Bind values to the UPDATE statement. */
-    for(i=0; rc==SQLITE_OK && i<nCol; i++){
-      sqlite3_value *pOld = sessionChangesetOld(pIter, i);
-      sqlite3_value *pNew = sessionChangesetNew(pIter, i);
-      if( p->abPK[i] || (bPatchset==0 && pOld) ){
-        rc = sessionBindValue(pUp, i*2+2, pOld);
-      }
-      if( rc==SQLITE_OK && pNew ){
-        rc = sessionBindValue(pUp, i*2+1, pNew);
-      }
-    }
-    if( rc!=SQLITE_OK ) return rc;
-
-    /* Attempt the UPDATE. In the case of a NOTFOUND or DATA conflict,
-    ** the result will be SQLITE_OK with 0 rows modified. */
-    sqlite3_step(pUp);
-    rc = sqlite3_reset(pUp);
-
-    if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 ){
-      /* A NOTFOUND or DATA error. Search the table to see if it contains
-      ** a row with a matching primary key. If so, this is a DATA conflict.
-      ** Otherwise, if there is no primary key match, it is a NOTFOUND. */
-
-      rc = sessionConflictHandler(
-          SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
-      );
-
-    }else if( (rc&0xff)==SQLITE_CONSTRAINT ){
-      /* This is always a CONSTRAINT conflict. */
-      rc = sessionConflictHandler(
-          SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
-      );
-    }
-
-  }else{
-    assert( op==SQLITE_INSERT );
-    if( p->bStat1 ){
-      /* Check if there is a conflicting row. For sqlite_stat1, this needs
-      ** to be done using a SELECT, as there is no PRIMARY KEY in the
-      ** database schema to throw an exception if a duplicate is inserted.  */
-      rc = sessionSeekToRow(pIter, p);
-      if( rc==SQLITE_ROW ){
-        rc = SQLITE_CONSTRAINT;
-        sqlite3_reset(p->pSelect);
-      }
-    }
-
-    if( rc==SQLITE_OK ){
-      rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
-      if( rc!=SQLITE_OK ) return rc;
-
-      sqlite3_step(p->pInsert);
-      rc = sqlite3_reset(p->pInsert);
-    }
-
-    if( (rc&0xff)==SQLITE_CONSTRAINT ){
-      rc = sessionConflictHandler(
-          SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
-      );
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Attempt to apply the change that the iterator passed as the first argument
-** currently points to to the database. If a conflict is encountered, invoke
-** the conflict handler callback.
-**
-** The difference between this function and sessionApplyOne() is that this
-** function handles the case where the conflict-handler is invoked and
-** returns SQLITE_CHANGESET_REPLACE - indicating that the change should be
-** retried in some manner.
-*/
-static int sessionApplyOneWithRetry(
-  sqlite3 *db,                    /* Apply change to "main" db of this handle */
-  sqlite3_changeset_iter *pIter,  /* Changeset iterator to read change from */
-  SessionApplyCtx *pApply,        /* Apply context */
-  int(*xConflict)(void*, int, sqlite3_changeset_iter*),
-  void *pCtx                      /* First argument passed to xConflict */
-){
-  int bReplace = 0;
-  int bRetry = 0;
-  int rc;
-
-  rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
-  if( rc==SQLITE_OK ){
-    /* If the bRetry flag is set, the change has not been applied due to an
-    ** SQLITE_CHANGESET_DATA problem (i.e. this is an UPDATE or DELETE and
-    ** a row with the correct PK is present in the db, but one or more other
-    ** fields do not contain the expected values) and the conflict handler
-    ** returned SQLITE_CHANGESET_REPLACE. In this case retry the operation,
-    ** but pass NULL as the final argument so that sessionApplyOneOp() ignores
-    ** the SQLITE_CHANGESET_DATA problem.  */
-    if( bRetry ){
-      assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
-      rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
-    }
-
-    /* If the bReplace flag is set, the change is an INSERT that has not
-    ** been performed because the database already contains a row with the
-    ** specified primary key and the conflict handler returned
-    ** SQLITE_CHANGESET_REPLACE. In this case remove the conflicting row
-    ** before reattempting the INSERT.  */
-    else if( bReplace ){
-      assert( pIter->op==SQLITE_INSERT );
-      rc = sqlite3_exec(db, "SAVEPOINT replace_op", 0, 0, 0);
-      if( rc==SQLITE_OK ){
-        rc = sessionBindRow(pIter,
-            sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete);
-        sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1);
-      }
-      if( rc==SQLITE_OK ){
-        sqlite3_step(pApply->pDelete);
-        rc = sqlite3_reset(pApply->pDelete);
-      }
-      if( rc==SQLITE_OK ){
-        rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
-      }
-      if( rc==SQLITE_OK ){
-        rc = sqlite3_exec(db, "RELEASE replace_op", 0, 0, 0);
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Retry the changes accumulated in the pApply->constraints buffer.
-*/
-static int sessionRetryConstraints(
-  sqlite3 *db,
-  int bPatchset,
-  const char *zTab,
-  SessionApplyCtx *pApply,
-  int(*xConflict)(void*, int, sqlite3_changeset_iter*),
-  void *pCtx                      /* First argument passed to xConflict */
-){
-  int rc = SQLITE_OK;
-
-  while( pApply->constraints.nBuf ){
-    sqlite3_changeset_iter *pIter2 = 0;
-    SessionBuffer cons = pApply->constraints;
-    memset(&pApply->constraints, 0, sizeof(SessionBuffer));
-
-    rc = sessionChangesetStart(
-        &pIter2, 0, 0, cons.nBuf, cons.aBuf, pApply->bInvertConstraints, 1
-    );
-    if( rc==SQLITE_OK ){
-      size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
-      int rc2;
-      pIter2->bPatchset = bPatchset;
-      pIter2->zTab = (char*)zTab;
-      pIter2->nCol = pApply->nCol;
-      pIter2->abPK = pApply->abPK;
-      sessionBufferGrow(&pIter2->tblhdr, nByte, &rc);
-      pIter2->apValue = (sqlite3_value**)pIter2->tblhdr.aBuf;
-      if( rc==SQLITE_OK ) memset(pIter2->apValue, 0, nByte);
-
-      while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter2) ){
-        rc = sessionApplyOneWithRetry(db, pIter2, pApply, xConflict, pCtx);
-      }
-
-      rc2 = sqlite3changeset_finalize(pIter2);
-      if( rc==SQLITE_OK ) rc = rc2;
-    }
-    assert( pApply->bDeferConstraints || pApply->constraints.nBuf==0 );
-
-    sqlite3_free(cons.aBuf);
-    if( rc!=SQLITE_OK ) break;
-    if( pApply->constraints.nBuf>=cons.nBuf ){
-      /* No progress was made on the last round. */
-      pApply->bDeferConstraints = 0;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Argument pIter is a changeset iterator that has been initialized, but
-** not yet passed to sqlite3changeset_next(). This function applies the
-** changeset to the main database attached to handle "db". The supplied
-** conflict handler callback is invoked to resolve any conflicts encountered
-** while applying the change.
-*/
-static int sessionChangesetApply(
-  sqlite3 *db,                    /* Apply change to "main" db of this handle */
-  sqlite3_changeset_iter *pIter,  /* Changeset to apply */
-  int(*xFilter)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    const char *zTab              /* Table name */
-  ),
-  int(*xFilterIter)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    sqlite3_changeset_iter *p
-  ),
-  int(*xConflict)(
-    void *pCtx,                   /* Copy of fifth 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 information */
-  int flags                       /* SESSION_APPLY_XXX flags */
-){
-  int schemaMismatch = 0;
-  int rc = SQLITE_OK;             /* Return code */
-  const char *zTab = 0;           /* Name of current table */
-  int nTab = 0;                   /* Result of sqlite3Strlen30(zTab) */
-  SessionApplyCtx sApply;         /* changeset_apply() context object */
-  int bPatchset;
-  u64 savedFlag = db->flags & SQLITE_FkNoAction;
-
-  assert( xConflict!=0 );
-
-  sqlite3_mutex_enter(sqlite3_db_mutex(db));
-  if( flags & SQLITE_CHANGESETAPPLY_FKNOACTION ){
-    db->flags |= ((u64)SQLITE_FkNoAction);
-    db->aDb[0].pSchema->schema_cookie -= 32;
-  }
-
-  pIter->in.bNoDiscard = 1;
-  memset(&sApply, 0, sizeof(sApply));
-  sApply.bRebase = (ppRebase && pnRebase);
-  sApply.bInvertConstraints = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
-  sApply.bIgnoreNoop = !!(flags & SQLITE_CHANGESETAPPLY_IGNORENOOP);
-  if( (flags & SQLITE_CHANGESETAPPLY_NOSAVEPOINT)==0 ){
-    rc = sqlite3_exec(db, "SAVEPOINT changeset_apply", 0, 0, 0);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_exec(db, "PRAGMA defer_foreign_keys = 1", 0, 0, 0);
-  }
-  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
-    int nCol;
-    int op;
-    const char *zNew;
-
-    sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
-
-    if( zTab==0 || sqlite3_strnicmp(zNew, zTab, nTab+1) ){
-      u8 *abPK;
-
-      rc = sessionRetryConstraints(
-          db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
-      );
-      if( rc!=SQLITE_OK ) break;
-
-      sessionUpdateFree(&sApply);
-      sqlite3_free((char*)sApply.azCol);  /* cast works around VC++ bug */
-      sqlite3_finalize(sApply.pDelete);
-      sqlite3_finalize(sApply.pInsert);
-      sqlite3_finalize(sApply.pSelect);
-      sApply.db = db;
-      sApply.pDelete = 0;
-      sApply.pInsert = 0;
-      sApply.pSelect = 0;
-      sApply.nCol = 0;
-      sApply.azCol = 0;
-      sApply.abPK = 0;
-      sApply.bStat1 = 0;
-      sApply.bDeferConstraints = 1;
-      sApply.bRebaseStarted = 0;
-      sApply.bRowid = 0;
-      memset(&sApply.constraints, 0, sizeof(SessionBuffer));
-
-      /* If an xFilter() callback was specified, invoke it now. If the
-      ** xFilter callback returns zero, skip this table. If it returns
-      ** non-zero, proceed. */
-      schemaMismatch = (xFilter && (0==xFilter(pCtx, zNew)));
-      if( schemaMismatch ){
-        zTab = sqlite3_mprintf("%s", zNew);
-        if( zTab==0 ){
-          rc = SQLITE_NOMEM;
-          break;
-        }
-        nTab = (int)strlen(zTab);
-        sApply.azCol = (const char **)zTab;
-      }else{
-        int nMinCol = 0;
-        int i;
-
-        sqlite3changeset_pk(pIter, &abPK, 0);
-        rc = sessionTableInfo(0, db, "main", zNew,
-            &sApply.nCol, 0, &zTab, &sApply.azCol, 0, 0,
-            &sApply.abPK, &sApply.bRowid
-        );
-        if( rc!=SQLITE_OK ) break;
-        for(i=0; i<sApply.nCol; i++){
-          if( sApply.abPK[i] ) nMinCol = i+1;
-        }
-
-        if( sApply.nCol==0 ){
-          schemaMismatch = 1;
-          sqlite3_log(SQLITE_SCHEMA,
-              "sqlite3changeset_apply(): no such table: %s", zTab
-          );
-        }
-        else if( sApply.nCol<nCol ){
-          schemaMismatch = 1;
-          sqlite3_log(SQLITE_SCHEMA,
-              "sqlite3changeset_apply(): table %s has %d columns, "
-              "expected %d or more",
-              zTab, sApply.nCol, nCol
-          );
-        }
-        else if( nCol<nMinCol || memcmp(sApply.abPK, abPK, nCol)!=0 ){
-          schemaMismatch = 1;
-          sqlite3_log(SQLITE_SCHEMA, "sqlite3changeset_apply(): "
-              "primary key mismatch for table %s", zTab
-          );
-        }
-        else{
-          sApply.nCol = nCol;
-          if( 0==sqlite3_stricmp(zTab, "sqlite_stat1") ){
-            if( (rc = sessionStat1Sql(db, &sApply) ) ){
-              break;
-            }
-            sApply.bStat1 = 1;
-          }else{
-            if( (rc = sessionSelectRow(db, zTab, &sApply))
-             || (rc = sessionDeleteRow(db, zTab, &sApply))
-             || (rc = sessionInsertRow(db, zTab, &sApply))
-            ){
-              break;
-            }
-            sApply.bStat1 = 0;
-          }
-        }
-        nTab = sqlite3Strlen30(zTab);
-      }
-    }
-
-    /* If there is a schema mismatch on the current table, proceed to the
-    ** next change. A log message has already been issued. */
-    if( schemaMismatch ) continue;
-
-    /* If this is a call to apply_v3(), invoke xFilterIter here. */
-    if( xFilterIter && 0==xFilterIter(pCtx, pIter) ) continue;
-
-    rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
-  }
-
-  bPatchset = pIter->bPatchset;
-  if( rc==SQLITE_OK ){
-    rc = sqlite3changeset_finalize(pIter);
-  }else{
-    sqlite3changeset_finalize(pIter);
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = sessionRetryConstraints(db, bPatchset, zTab, &sApply, xConflict, pCtx);
-  }
-
-  if( rc==SQLITE_OK ){
-    int nFk, notUsed;
-    sqlite3_db_status(db, SQLITE_DBSTATUS_DEFERRED_FKS, &nFk, &notUsed, 0);
-    if( nFk!=0 ){
-      int res = SQLITE_CHANGESET_ABORT;
-      sqlite3_changeset_iter sIter;
-      memset(&sIter, 0, sizeof(sIter));
-      sIter.nCol = nFk;
-      res = xConflict(pCtx, SQLITE_CHANGESET_FOREIGN_KEY, &sIter);
-      if( res!=SQLITE_CHANGESET_OMIT ){
-        rc = SQLITE_CONSTRAINT;
-      }
-    }
-  }
-
-  {
-    int rc2 = sqlite3_exec(db, "PRAGMA defer_foreign_keys = 0", 0, 0, 0);
-    if( rc==SQLITE_OK ) rc = rc2;
-  }
-
-  if( (flags & SQLITE_CHANGESETAPPLY_NOSAVEPOINT)==0 ){
-    if( rc==SQLITE_OK ){
-      rc = sqlite3_exec(db, "RELEASE changeset_apply", 0, 0, 0);
-    }
-    if( rc!=SQLITE_OK ){
-      sqlite3_exec(db, "ROLLBACK TO changeset_apply", 0, 0, 0);
-      sqlite3_exec(db, "RELEASE changeset_apply", 0, 0, 0);
-    }
-  }
-
-  assert( sApply.bRebase || sApply.rebase.nBuf==0 );
-  if( rc==SQLITE_OK && bPatchset==0 && sApply.bRebase ){
-    assert( ppRebase!=0 && pnRebase!=0 );
-    *ppRebase = (void*)sApply.rebase.aBuf;
-    *pnRebase = sApply.rebase.nBuf;
-    sApply.rebase.aBuf = 0;
-  }
-  sessionUpdateFree(&sApply);
-  sqlite3_finalize(sApply.pInsert);
-  sqlite3_finalize(sApply.pDelete);
-  sqlite3_finalize(sApply.pSelect);
-  sqlite3_free((char*)sApply.azCol);  /* cast works around VC++ bug */
-  sqlite3_free((char*)sApply.constraints.aBuf);
-  sqlite3_free((char*)sApply.rebase.aBuf);
-
-  if( (flags & SQLITE_CHANGESETAPPLY_FKNOACTION) && savedFlag==0 ){
-    assert( db->flags & SQLITE_FkNoAction );
-    db->flags &= ~((u64)SQLITE_FkNoAction);
-    db->aDb[0].pSchema->schema_cookie -= 32;
-  }
-
-  assert( rc!=SQLITE_OK || sApply.zErr==0 );
-  sqlite3_set_errmsg(db, rc, sApply.zErr);
-  sqlite3_free(sApply.zErr);
-
-  sqlite3_mutex_leave(sqlite3_db_mutex(db));
-  return rc;
-}
-
-/*
-** This function is called by all six sqlite3changeset_apply() variants:
-**
-**   +  sqlite3changeset_apply()
-**   +  sqlite3changeset_apply_v2()
-**   +  sqlite3changeset_apply_v3()
-**   +  sqlite3changeset_apply_strm()
-**   +  sqlite3changeset_apply_strm_v2()
-**   +  sqlite3changeset_apply_strm_v3()
-**
-** Arguments passed to this function are as follows:
-**
-** db:
-**   Database handle to apply changeset to main database of.
-**
-** nChangeset/pChangeset:
-**   These are both passed zero for the streaming variants. For the normal
-**   apply() functions, these are passed the size of and the buffer containing
-**   the changeset, respectively.
-**
-** xInput/pIn:
-**   These are both passed zero for the normal variants. For the streaming
-**   apply() functions, these are passed the input callback and context
-**   pointer, respectively.
-**
-** xFilter:
-**   The filter function as passed to apply() or apply_v2() (to filter by
-**   table name), if any. This is always NULL for apply_v3() calls.
-**
-** xFilterIter:
-**   The filter function as passed to apply_v3(), if any.
-**
-** xConflict:
-**   The conflict handler callback (must not be NULL).
-**
-** pCtx:
-**   The context pointer passed to the xFilter and xConflict handler callbacks.
-**
-** ppRebase, pnRebase:
-**   Zero for apply(). The rebase changeset output pointers, if any, for
-**   apply_v2() and apply_v3().
-**
-** flags:
-**   Zero for apply(). The flags parameter for apply_v2() and apply_v3().
-*/
-static int sessionChangesetApplyV23(
-  sqlite3 *db,                    /* Apply change to "main" db of this handle */
-  int nChangeset,                 /* Size of changeset in bytes */
-  void *pChangeset,               /* Changeset blob */
-  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(*xFilterIter)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    sqlite3_changeset_iter *p     /* Handle describing current change */
-  ),
-  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
-){
-  sqlite3_changeset_iter *pIter;  /* Iterator to skip through changeset */
-  int bInverse = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
-  int rc = sessionChangesetStart(
-      &pIter, xInput, pIn, nChangeset, pChangeset, bInverse, 1
-  );
-  if( rc==SQLITE_OK ){
-    rc = sessionChangesetApply(db, pIter,
-        xFilter, xFilterIter, xConflict, pCtx, ppRebase, pnRebase, flags
-    );
-  }
-  return rc;
-}
-
-/*
-** Apply the changeset passed via pChangeset/nChangeset to the main
-** database attached to handle "db".
-*/
-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,
-  int flags
-){
-  return sessionChangesetApplyV23(db,
-      nChangeset, pChangeset, 0, 0,
-      xFilter, 0, xConflict, pCtx,
-      ppRebase, pnRebase, flags
-  );
-}
-
-/*
-** Apply the changeset passed via pChangeset/nChangeset to the main
-** database attached to handle "db".
-*/
-SQLITE_API int sqlite3changeset_apply_v3(
-  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() */
-    sqlite3_changeset_iter *p     /* Handle describing current change */
-  ),
-  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
-){
-  return sessionChangesetApplyV23(db,
-      nChangeset, pChangeset, 0, 0,
-      0, xFilter, xConflict, pCtx,
-      ppRebase, pnRebase, flags
-  );
-}
-
-/*
-** Apply the changeset passed via pChangeset/nChangeset to the main database
-** attached to handle "db". Invoke the supplied conflict handler callback
-** to resolve any conflicts encountered while applying the 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 fifth 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 */
-){
-  return sessionChangesetApplyV23(db,
-      nChangeset, pChangeset, 0, 0,
-      xFilter, 0, xConflict, pCtx,
-      0, 0, 0
-  );
-}
-
-/*
-** Apply the changeset passed via xInput/pIn to the main database
-** attached to handle "db". Invoke the supplied conflict handler callback
-** to resolve any conflicts encountered while applying the change.
-*/
-SQLITE_API int sqlite3changeset_apply_v3_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() */
-    sqlite3_changeset_iter *p
-  ),
-  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
-){
-  return sessionChangesetApplyV23(db,
-      0, 0, xInput, pIn,
-      0, xFilter, xConflict, pCtx,
-      ppRebase, pnRebase, flags
-  );
-}
-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
-){
-  return sessionChangesetApplyV23(db,
-      0, 0, xInput, pIn,
-      xFilter, 0, xConflict, pCtx,
-      ppRebase, pnRebase, flags
-  );
-}
-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 */
-){
-  return sessionChangesetApplyV23(db,
-      0, 0, xInput, pIn,
-      xFilter, 0, xConflict, pCtx,
-      0, 0, 0
-  );
-}
-
-/*
-** The parts of the sqlite3_changegroup structure used by the
-** sqlite3changegroup_change_xxx() APIs.
-*/
-typedef struct ChangeData ChangeData;
-struct ChangeData {
-  SessionTable *pTab;
-  int bIndirect;
-  int eOp;
-
-  int nBufAlloc;
-  SessionBuffer *aBuf;
-  SessionBuffer record;
-};
-
-/*
-** sqlite3_changegroup handle.
-*/
-struct sqlite3_changegroup {
-  int rc;                         /* Error code */
-  int bPatch;                     /* True to accumulate patchsets */
-  SessionTable *pList;            /* List of tables in current patch */
-  SessionBuffer rec;
-
-  sqlite3 *db;                    /* Configured by changegroup_schema() */
-  char *zDb;                      /* Configured by changegroup_schema() */
-  ChangeData cd;                  /* Used by changegroup_change_xxx() APIs. */
-};
-
-/*
-** This function is called to merge two changes to the same row together as
-** part of an sqlite3changeset_concat() operation. A new change object is
-** allocated and a pointer to it stored in *ppNew.
-**
-** Because they have been vetted by sqlite3changegroup_add() or similar,
-** both the aRec[] change and the pExist change are safe to use without
-** checking for buffer overflows.
-*/
-static int sessionChangeMerge(
-  SessionTable *pTab,             /* Table structure */
-  int bRebase,                    /* True for a rebase hash-table */
-  int bPatchset,                  /* True for patchsets */
-  SessionChange *pExist,          /* Existing change */
-  int op2,                        /* Second change operation */
-  int bIndirect,                  /* True if second change is indirect */
-  u8 *aRec,                       /* Second change record */
-  int nRec,                       /* Number of bytes in aRec */
-  SessionChange **ppNew           /* OUT: Merged change */
-){
-  SessionChange *pNew = 0;
-  int rc = SQLITE_OK;
-  assert( aRec!=0 );
-
-  if( !pExist ){
-    pNew = (SessionChange *)sqlite3_malloc64(sizeof(SessionChange) + nRec);
-    if( !pNew ){
-      return SQLITE_NOMEM;
-    }
-    memset(pNew, 0, sizeof(SessionChange));
-    pNew->op = op2;
-    pNew->bIndirect = bIndirect;
-    pNew->aRecord = (u8*)&pNew[1];
-    if( bIndirect==0 || bRebase==0 ){
-      pNew->nRecord = nRec;
-      memcpy(pNew->aRecord, aRec, nRec);
-    }else{
-      int i;
-      u8 *pIn = aRec;
-      u8 *pOut = pNew->aRecord;
-      for(i=0; i<pTab->nCol; i++){
-        int nIn = sessionSerialLen(pIn);
-        if( *pIn==0 ){
-          *pOut++ = 0;
-        }else if( pTab->abPK[i]==0 ){
-          *pOut++ = 0xFF;
-        }else{
-          memcpy(pOut, pIn, nIn);
-          pOut += nIn;
-        }
-        pIn += nIn;
-      }
-      pNew->nRecord = pOut - pNew->aRecord;
-    }
-  }else if( bRebase ){
-    if( pExist->op==SQLITE_DELETE && pExist->bIndirect ){
-      *ppNew = pExist;
-    }else{
-      sqlite3_int64 nByte = nRec + pExist->nRecord + sizeof(SessionChange);
-      pNew = (SessionChange*)sqlite3_malloc64(nByte);
-      if( pNew==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        int i;
-        u8 *a1 = pExist->aRecord;
-        u8 *a2 = aRec;
-        u8 *pOut;
-
-        memset(pNew, 0, nByte);
-        pNew->bIndirect = bIndirect || pExist->bIndirect;
-        pNew->op = op2;
-        pOut = pNew->aRecord = (u8*)&pNew[1];
-
-        for(i=0; i<pTab->nCol; i++){
-          int n1 = sessionSerialLen(a1);
-          int n2 = sessionSerialLen(a2);
-          if( *a1==0xFF || (pTab->abPK[i]==0 && bIndirect) ){
-            *pOut++ = 0xFF;
-          }else if( *a2==0 ){
-            memcpy(pOut, a1, n1);
-            pOut += n1;
-          }else{
-            memcpy(pOut, a2, n2);
-            pOut += n2;
-          }
-          a1 += n1;
-          a2 += n2;
-        }
-        pNew->nRecord = pOut - pNew->aRecord;
-      }
-      sqlite3_free(pExist);
-    }
-  }else{
-    int op1 = pExist->op;
-
-    /*
-    **   op1=INSERT, op2=INSERT      ->      Unsupported. Discard op2.
-    **   op1=INSERT, op2=UPDATE      ->      INSERT.
-    **   op1=INSERT, op2=DELETE      ->      (none)
-    **
-    **   op1=UPDATE, op2=INSERT      ->      Unsupported. Discard op2.
-    **   op1=UPDATE, op2=UPDATE      ->      UPDATE.
-    **   op1=UPDATE, op2=DELETE      ->      DELETE.
-    **
-    **   op1=DELETE, op2=INSERT      ->      UPDATE.
-    **   op1=DELETE, op2=UPDATE      ->      Unsupported. Discard op2.
-    **   op1=DELETE, op2=DELETE      ->      Unsupported. Discard op2.
-    */
-    if( (op1==SQLITE_INSERT && op2==SQLITE_INSERT)
-     || (op1==SQLITE_UPDATE && op2==SQLITE_INSERT)
-     || (op1==SQLITE_DELETE && op2==SQLITE_UPDATE)
-     || (op1==SQLITE_DELETE && op2==SQLITE_DELETE)
-    ){
-      pNew = pExist;
-    }else if( op1==SQLITE_INSERT && op2==SQLITE_DELETE ){
-      sqlite3_free(pExist);
-      assert( pNew==0 );
-    }else{
-      u8 *aExist = pExist->aRecord;
-      sqlite3_int64 nByte;
-      u8 *aCsr;
-
-      /* Allocate a new SessionChange object. Ensure that the aRecord[]
-      ** buffer of the new object is large enough to hold any record that
-      ** may be generated by combining the input records.  */
-      nByte = sizeof(SessionChange) + pExist->nRecord + nRec;
-      pNew = (SessionChange *)sqlite3_malloc64(nByte);
-      if( !pNew ){
-        sqlite3_free(pExist);
-        return SQLITE_NOMEM;
-      }
-      memset(pNew, 0, sizeof(SessionChange));
-      pNew->bIndirect = (bIndirect && pExist->bIndirect);
-      aCsr = pNew->aRecord = (u8 *)&pNew[1];
-
-      if( op1==SQLITE_INSERT ){             /* INSERT + UPDATE */
-        u8 *a1 = aRec;
-        assert( op2==SQLITE_UPDATE );
-        pNew->op = SQLITE_INSERT;
-        if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
-        sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
-      }else if( op1==SQLITE_DELETE ){       /* DELETE + INSERT */
-        assert( op2==SQLITE_INSERT );
-        pNew->op = SQLITE_UPDATE;
-        if( bPatchset ){
-          memcpy(aCsr, aRec, nRec);
-          aCsr += nRec;
-        }else{
-          if( 0==sessionMergeUpdate(&aCsr, pTab, bPatchset, aExist,0,aRec,0) ){
-            sqlite3_free(pNew);
-            pNew = 0;
-          }
-        }
-      }else if( op2==SQLITE_UPDATE ){       /* UPDATE + UPDATE */
-        u8 *a1 = aExist;
-        u8 *a2 = aRec;
-        assert( op1==SQLITE_UPDATE );
-        if( bPatchset==0 ){
-          sessionSkipRecord(&a1, pTab->nCol);
-          sessionSkipRecord(&a2, pTab->nCol);
-        }
-        pNew->op = SQLITE_UPDATE;
-        if( 0==sessionMergeUpdate(&aCsr, pTab, bPatchset, aRec, aExist,a1,a2) ){
-          sqlite3_free(pNew);
-          pNew = 0;
-        }
-      }else{                                /* UPDATE + DELETE */
-        assert( op1==SQLITE_UPDATE && op2==SQLITE_DELETE );
-        pNew->op = SQLITE_DELETE;
-        if( bPatchset ){
-          memcpy(aCsr, aRec, nRec);
-          aCsr += nRec;
-        }else{
-          sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
-        }
-      }
-
-      if( pNew ){
-        pNew->nRecord = (int)(aCsr - pNew->aRecord);
-      }
-      sqlite3_free(pExist);
-    }
-  }
-
-  *ppNew = pNew;
-  return rc;
-}
-
-/*
-** Check if a changeset entry with nCol columns and the PK array passed
-** as the final argument to this function is compatible with SessionTable
-** pTab. If so, return 1. Otherwise, if they are incompatible in some way,
-** return 0.
-*/
-static int sessionChangesetCheckCompat(
-  SessionTable *pTab,
-  int nCol,
-  u8 *abPK
-){
-  if( pTab->azCol && nCol<pTab->nCol ){
-    int ii;
-    for(ii=0; ii<pTab->nCol; ii++){
-      u8 bPK = (ii < nCol) ? abPK[ii] : 0;
-      if( pTab->abPK[ii]!=bPK ) return 0;
-    }
-    return 1;
-  }
-  return (pTab->nCol==nCol && 0==memcmp(abPK, pTab->abPK, nCol));
-}
-
-static int sessionChangesetExtendRecord(
-  sqlite3_changegroup *pGrp,
-  SessionTable *pTab,
-  int nCol,
-  int op,
-  const u8 *aRec,
-  int nRec,
-  SessionBuffer *pOut
-){
-  int rc = SQLITE_OK;
-  int ii = 0;
-
-  assert( pTab->azCol );
-  assert( nCol<pTab->nCol );
-
-  pOut->nBuf = 0;
-  if( op==SQLITE_INSERT || (op==SQLITE_DELETE && pGrp->bPatch==0) ){
-    /* Append the missing default column values to the record. */
-    sessionAppendBlob(pOut, aRec, nRec, &rc);
-    if( rc==SQLITE_OK && pTab->pDfltStmt==0 ){
-      rc = sessionPrepareDfltStmt(pGrp->db, pTab, &pTab->pDfltStmt);
-      if( rc==SQLITE_OK && SQLITE_ROW!=sqlite3_step(pTab->pDfltStmt) ){
-        rc = sqlite3_errcode(pGrp->db);
-      }
-    }
-    for(ii=nCol; rc==SQLITE_OK && ii<pTab->nCol; ii++){
-      int eType = sqlite3_column_type(pTab->pDfltStmt, ii);
-      sessionAppendByte(pOut, eType, &rc);
-      switch( eType ){
-        case SQLITE_FLOAT:
-        case SQLITE_INTEGER: {
-          if( SQLITE_OK==sessionBufferGrow(pOut, 8, &rc) ){
-            if( eType==SQLITE_INTEGER ){
-              sqlite3_int64 iVal = sqlite3_column_int64(pTab->pDfltStmt, ii);
-              sessionPutI64(&pOut->aBuf[pOut->nBuf], iVal);
-            }else{
-              double rVal = sqlite3_column_double(pTab->pDfltStmt, ii);
-              sessionPutDouble(&pOut->aBuf[pOut->nBuf], rVal);
-            }
-            pOut->nBuf += 8;
-          }
-          break;
-        }
-
-        case SQLITE_BLOB:
-        case SQLITE_TEXT: {
-          int n = sqlite3_column_bytes(pTab->pDfltStmt, ii);
-          sessionAppendVarint(pOut, n, &rc);
-          if( eType==SQLITE_TEXT ){
-            const u8 *z = (const u8*)sqlite3_column_text(pTab->pDfltStmt, ii);
-            sessionAppendBlob(pOut, z, n, &rc);
-          }else{
-            const u8 *z = (const u8*)sqlite3_column_blob(pTab->pDfltStmt, ii);
-            sessionAppendBlob(pOut, z, n, &rc);
-          }
-          break;
-        }
-
-        default:
-          assert( eType==SQLITE_NULL );
-          break;
-      }
-    }
-  }else if( op==SQLITE_UPDATE ){
-    /* Append missing "undefined" entries to the old.* record. And, if this
-    ** is an UPDATE, to the new.* record as well.  */
-    int iOff = 0;
-    if( pGrp->bPatch==0 ){
-      for(ii=0; ii<nCol; ii++){
-        iOff += sessionSerialLen(&aRec[iOff]);
-      }
-      sessionAppendBlob(pOut, aRec, iOff, &rc);
-      for(ii=0; ii<(pTab->nCol-nCol); ii++){
-        sessionAppendByte(pOut, 0x00, &rc);
-      }
-    }
-
-    sessionAppendBlob(pOut, &aRec[iOff], nRec-iOff, &rc);
-    for(ii=0; ii<(pTab->nCol-nCol); ii++){
-      sessionAppendByte(pOut, 0x00, &rc);
-    }
-  }else{
-    assert( op==SQLITE_DELETE && pGrp->bPatch );
-    sessionAppendBlob(pOut, aRec, nRec, &rc);
-  }
-
-  return rc;
-}
-
-/*
-** Locate or create a SessionTable object that may be used to add the
-** change currently pointed to by iterator pIter to changegroup pGrp.
-** If successful, set output variable (*ppTab) to point to the table
-** object and return SQLITE_OK. Otherwise, if some error occurs, return
-** an SQLite error code and leave (*ppTab) set to NULL.
-*/
-static int sessionChangesetFindTable(
-  sqlite3_changegroup *pGrp,
-  const char *zTab,
-  sqlite3_changeset_iter *pIter,
-  SessionTable **ppTab
-){
-  int rc = SQLITE_OK;
-  SessionTable *pTab = 0;
-  int nTab = (int)strlen(zTab);
-  u8 *abPK = 0;
-  int nCol = 0;
-
-  *ppTab = 0;
-
-  /* Search the list for an existing table */
-  for(pTab = pGrp->pList; pTab; pTab=pTab->pNext){
-    if( 0==sqlite3_strnicmp(pTab->zName, zTab, nTab+1) ) break;
-  }
-
-
-  if( pIter ){
-    sqlite3changeset_pk(pIter, &abPK, &nCol);
-  }else if( !pTab && !pGrp->db ){
-    return SQLITE_OK;
-  }
-
-  /* If one was not found above, create a new table now */
-  if( !pTab ){
-    SessionTable **ppNew;
-
-    pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nTab+1);
-    if( !pTab ){
-      return SQLITE_NOMEM;
-    }
-    memset(pTab, 0, sizeof(SessionTable));
-    pTab->nCol = nCol;
-    pTab->abPK = (u8*)&pTab[1];
-    if( nCol>0 ){
-      memcpy(pTab->abPK, abPK, nCol);
-    }
-    pTab->zName = (char*)&pTab->abPK[nCol];
-    memcpy(pTab->zName, zTab, nTab+1);
-
-    if( pGrp->db ){
-      pTab->nCol = 0;
-      rc = sessionInitTable(0, pTab, pGrp->db, pGrp->zDb);
-      if( rc || pTab->nCol==0 ){
-        sqlite3_free(pTab->azCol);
-        sqlite3_free(pTab);
-        return rc;
-      }
-    }
-
-    /* The new object must be linked on to the end of the list, not
-    ** simply added to the start of it. This is to ensure that the
-    ** tables within the output of sqlite3changegroup_output() are in
-    ** the right order.  */
-    for(ppNew=&pGrp->pList; *ppNew; ppNew=&(*ppNew)->pNext);
-    *ppNew = pTab;
-  }
-
-  /* Check that the table is compatible. */
-  if( pIter && !sessionChangesetCheckCompat(pTab, nCol, abPK) ){
-    rc = SQLITE_SCHEMA;
-  }
-
-  *ppTab = pTab;
-  return rc;
-}
-
-/*
-** Add a single change to the changegroup pGrp.
-*/
-static int sessionOneChangeToHash(
-  sqlite3_changegroup *pGrp,      /* Changegroup to update */
-  SessionTable *pTab,             /* Table change pertains to */
-  int op,                         /* One of SQLITE_INSERT, UPDATE, DELETE */
-  int bIndirect,                  /* True to flag change as "indirect" */
-  int nCol,                       /* Number of columns in record(s) */
-  u8 *aRec,                       /* Serialized change record(s) */
-  int nRec,                       /* Size of aRec[] in bytes */
-  int bRebase                     /* True if this is a rebase blob */
-){
-  int rc = SQLITE_OK;
-  int iHash = 0;
-  SessionChange *pChange = 0;
-  SessionChange *pExist = 0;
-  SessionChange **pp = 0;
-
-  assert( nRec>0 );
-
-  if( nCol<pTab->nCol ){
-    SessionBuffer *pBuf = &pGrp->rec;
-    rc = sessionChangesetExtendRecord(pGrp, pTab, nCol, op, aRec, nRec, pBuf);
-    aRec = pBuf->aBuf;
-    nRec = pBuf->nBuf;
-    assert( pGrp->db );
-  }
-
-  if( rc==SQLITE_OK && sessionGrowHash(0, pGrp->bPatch, pTab) ){
-    rc = SQLITE_NOMEM;
-  }
-
-  if( rc==SQLITE_OK ){
-    /* Search for existing entry. If found, remove it from the hash table.
-    ** Code below may link it back in.  */
-    iHash = sessionChangeHash(
-        pTab, (pGrp->bPatch && op==SQLITE_DELETE), aRec, pTab->nChange
-    );
-    for(pp=&pTab->apChange[iHash]; *pp; pp=&(*pp)->pNext){
-      int bPkOnly1 = 0;
-      int bPkOnly2 = 0;
-      if( pGrp->bPatch ){
-        bPkOnly1 = (*pp)->op==SQLITE_DELETE;
-        bPkOnly2 = op==SQLITE_DELETE;
-      }
-      if( sessionChangeEqual(pTab, bPkOnly1, (*pp)->aRecord, bPkOnly2, aRec) ){
-        pExist = *pp;
-        *pp = (*pp)->pNext;
-        pTab->nEntry--;
-        break;
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = sessionChangeMerge(pTab, bRebase,
-        pGrp->bPatch, pExist, op, bIndirect, aRec, nRec, &pChange
-    );
-  }
-  if( rc==SQLITE_OK && pChange ){
-    pChange->pNext = pTab->apChange[iHash];
-    pTab->apChange[iHash] = pChange;
-    pTab->nEntry++;
-  }
-
-  return rc;
-}
-
-/*
-** Add the change currently indicated by iterator pIter to the hash table
-** belonging to changegroup pGrp.
-*/
-static int sessionOneChangeIterToHash(
-  sqlite3_changegroup *pGrp,
-  sqlite3_changeset_iter *pIter,
-  int bRebase
-){
-  u8 *aRec = &pIter->in.aData[pIter->in.iCurrent + 2];
-  int nRec = (pIter->in.iNext - pIter->in.iCurrent) - 2;
-  const char *zTab = 0;
-  int nCol = 0;
-  int op = 0;
-  int bIndirect = 0;
-  int rc = SQLITE_OK;
-  SessionTable *pTab = 0;
-
-  /* Ensure that only changesets, or only patchsets, but not a mixture
-  ** of both, are being combined. It is an error to try to combine a
-  ** changeset and a patchset.  */
-  if( pGrp->pList==0 ){
-    pGrp->bPatch = pIter->bPatchset;
-  }else if( pIter->bPatchset!=pGrp->bPatch ){
-    rc = SQLITE_ERROR;
-  }
-
-  if( rc==SQLITE_OK ){
-    sqlite3changeset_op(pIter, &zTab, &nCol, &op, &bIndirect);
-    rc = sessionChangesetFindTable(pGrp, zTab, pIter, &pTab);
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = sessionOneChangeToHash(
-        pGrp, pTab, op, bIndirect, nCol, aRec, nRec, bRebase
-    );
-  }
-
-  if( rc==SQLITE_OK ) rc = pIter->rc;
-  return rc;
-}
-
-/*
-** Add all changes in the changeset traversed by the iterator passed as
-** the first argument to the changegroup hash tables.
-*/
-static int sessionChangesetToHash(
-  sqlite3_changeset_iter *pIter,   /* Iterator to read from */
-  sqlite3_changegroup *pGrp,       /* Changegroup object to add changeset to */
-  int bRebase                      /* True if hash table is for rebasing */
-){
-  u8 *aRec;
-  int nRec;
-  int rc = SQLITE_OK;
-
-  pIter->in.bNoDiscard = 1;
-  while( SQLITE_ROW==(sessionChangesetNext(pIter, &aRec, &nRec, 0)) ){
-    rc = sessionOneChangeIterToHash(pGrp, pIter, bRebase);
-    if( rc!=SQLITE_OK ) break;
-  }
-
-  if( rc==SQLITE_OK ) rc = pIter->rc;
-  return rc;
-}
-
-/*
-** Serialize a changeset (or patchset) based on all changesets (or patchsets)
-** added to the changegroup object passed as the first argument.
-**
-** If xOutput is not NULL, then the changeset/patchset is returned to the
-** user via one or more calls to xOutput, as with the other streaming
-** interfaces.
-**
-** Or, if xOutput is NULL, then (*ppOut) is populated with a pointer to a
-** buffer containing the output changeset before this function returns. In
-** this case (*pnOut) is set to the size of the output buffer in bytes. It
-** is the responsibility of the caller to free the output buffer using
-** sqlite3_free() when it is no longer required.
-**
-** If successful, SQLITE_OK is returned. Or, if an error occurs, an SQLite
-** error code. If an error occurs and xOutput is NULL, (*ppOut) and (*pnOut)
-** are both set to 0 before returning.
-*/
-static int sessionChangegroupOutput(
-  sqlite3_changegroup *pGrp,
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut,
-  int *pnOut,
-  void **ppOut
-){
-  int rc = SQLITE_OK;
-  SessionBuffer buf = {0, 0, 0};
-  SessionTable *pTab;
-  assert( xOutput==0 || (ppOut==0 && pnOut==0) );
-
-  /* Create the serialized output changeset based on the contents of the
-  ** hash tables attached to the SessionTable objects in list p->pList.
-  */
-  for(pTab=pGrp->pList; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
-    int i;
-    if( pTab->nEntry==0 ) continue;
-
-    sessionAppendTableHdr(&buf, pGrp->bPatch, pTab, &rc);
-    for(i=0; i<pTab->nChange; i++){
-      SessionChange *p;
-      for(p=pTab->apChange[i]; p; p=p->pNext){
-        sessionAppendByte(&buf, p->op, &rc);
-        sessionAppendByte(&buf, p->bIndirect, &rc);
-        sessionAppendBlob(&buf, p->aRecord, p->nRecord, &rc);
-        if( rc==SQLITE_OK && xOutput && buf.nBuf>=sessions_strm_chunk_size ){
-          rc = xOutput(pOut, buf.aBuf, buf.nBuf);
-          buf.nBuf = 0;
-        }
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    if( xOutput ){
-      if( buf.nBuf>0 ) rc = xOutput(pOut, buf.aBuf, buf.nBuf);
-    }else if( ppOut ){
-      *ppOut = buf.aBuf;
-      if( pnOut ) *pnOut = buf.nBuf;
-      buf.aBuf = 0;
-    }
-  }
-  sqlite3_free(buf.aBuf);
-
-  return rc;
-}
-
-/*
-** Allocate a new, empty, sqlite3_changegroup.
-*/
-SQLITE_API int sqlite3changegroup_new(sqlite3_changegroup **pp){
-  int rc = SQLITE_OK;             /* Return code */
-  sqlite3_changegroup *p;         /* New object */
-  p = (sqlite3_changegroup*)sqlite3_malloc(sizeof(sqlite3_changegroup));
-  if( p==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    memset(p, 0, sizeof(sqlite3_changegroup));
-  }
-  *pp = p;
-  return rc;
-}
-
-/*
-** Configure a changegroup object.
-*/
-SQLITE_API int sqlite3changegroup_config(
-  sqlite3_changegroup *pGrp,
-  int op,
-  void *pArg
-){
-  int rc = SQLITE_OK;
-
-  switch( op ){
-    case SQLITE_CHANGEGROUP_CONFIG_PATCHSET: {
-      int arg = *(int*)pArg;
-      if( pGrp->pList==0  && arg>=0 ){
-        pGrp->bPatch = (arg>0);
-      }
-      *(int*)pArg = pGrp->bPatch;
-      break;
-    }
-    default:
-      rc = SQLITE_MISUSE;
-      break;
-  }
-
-  return rc;
-}
-
-/*
-** Provide a database schema to the changegroup object.
-*/
-SQLITE_API int sqlite3changegroup_schema(
-  sqlite3_changegroup *pGrp,
-  sqlite3 *db,
-  const char *zDb
-){
-  int rc = SQLITE_OK;
-
-  if( pGrp->pList || pGrp->db ){
-    /* Cannot add a schema after one or more calls to sqlite3changegroup_add(),
-    ** or after sqlite3changegroup_schema() has already been called. */
-    rc = SQLITE_MISUSE;
-  }else{
-    pGrp->zDb = sqlite3_mprintf("%s", zDb);
-    if( pGrp->zDb==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      pGrp->db = db;
-    }
-  }
-  return rc;
-}
-
-/*
-** Add the changeset currently stored in buffer pData, size nData bytes,
-** to changeset-group p.
-*/
-SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup *pGrp, int nData, void *pData){
-  sqlite3_changeset_iter *pIter;  /* Iterator opened on pData/nData */
-  int rc;                         /* Return code */
-
-  rc = sqlite3changeset_start(&pIter, nData, pData);
-  if( rc==SQLITE_OK ){
-    rc = sessionChangesetToHash(pIter, pGrp, 0);
-  }
-  sqlite3changeset_finalize(pIter);
-  return rc;
-}
-
-/*
-** Add a single change to a changeset-group.
-*/
-SQLITE_API int sqlite3changegroup_add_change(
-  sqlite3_changegroup *pGrp,
-  sqlite3_changeset_iter *pIter
-){
-  int rc = SQLITE_OK;
-
-  if( pIter->in.iCurrent==pIter->in.iNext
-   || pIter->rc!=SQLITE_OK
-   || pIter->bInvert
-  ){
-    /* Iterator does not point to any valid entry or is an INVERT iterator. */
-    rc = SQLITE_ERROR;
-  }else{
-    pIter->in.bNoDiscard = 1;
-    rc = sessionOneChangeIterToHash(pGrp, pIter, 0);
-  }
-  return rc;
-}
-
-/*
-** Obtain a buffer containing a changeset representing the concatenation
-** of all changesets added to the group so far.
-*/
-SQLITE_API int sqlite3changegroup_output(
-    sqlite3_changegroup *pGrp,
-    int *pnData,
-    void **ppData
-){
-  return sessionChangegroupOutput(pGrp, 0, 0, pnData, ppData);
-}
-
-/*
-** Streaming versions of changegroup_add().
-*/
-SQLITE_API int sqlite3changegroup_add_strm(
-  sqlite3_changegroup *pGrp,
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn
-){
-  sqlite3_changeset_iter *pIter;  /* Iterator opened on pData/nData */
-  int rc;                         /* Return code */
-
-  rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
-  if( rc==SQLITE_OK ){
-    rc = sessionChangesetToHash(pIter, pGrp, 0);
-  }
-  sqlite3changeset_finalize(pIter);
-  return rc;
-}
-
-/*
-** Streaming versions of changegroup_output().
-*/
-SQLITE_API int sqlite3changegroup_output_strm(
-  sqlite3_changegroup *pGrp,
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut
-){
-  return sessionChangegroupOutput(pGrp, xOutput, pOut, 0, 0);
-}
-
-/*
-** Delete a changegroup object.
-*/
-SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup *pGrp){
-  if( pGrp ){
-    int ii;
-    for(ii=0; ii<pGrp->cd.nBufAlloc; ii++){
-      sqlite3_free(pGrp->cd.aBuf[ii].aBuf);
-    }
-    sqlite3_free(pGrp->cd.record.aBuf);
-    sqlite3_free(pGrp->cd.aBuf);
-    sqlite3_free(pGrp->zDb);
-    sessionDeleteTable(0, pGrp->pList);
-    sqlite3_free(pGrp->rec.aBuf);
-    sqlite3_free(pGrp);
-  }
-}
-
-/*
-** Combine two changesets together.
-*/
-SQLITE_API int sqlite3changeset_concat(
-  int nLeft,                      /* Number of bytes in lhs input */
-  void *pLeft,                    /* Lhs input changeset */
-  int nRight                      /* Number of bytes in rhs input */,
-  void *pRight,                   /* Rhs input changeset */
-  int *pnOut,                     /* OUT: Number of bytes in output changeset */
-  void **ppOut                    /* OUT: changeset (left <concat> right) */
-){
-  sqlite3_changegroup *pGrp;
-  int rc;
-
-  rc = sqlite3changegroup_new(&pGrp);
-  if( rc==SQLITE_OK ){
-    rc = sqlite3changegroup_add(pGrp, nLeft, pLeft);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3changegroup_add(pGrp, nRight, pRight);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3changegroup_output(pGrp, pnOut, ppOut);
-  }
-  sqlite3changegroup_delete(pGrp);
-
-  return rc;
-}
-
-/*
-** Streaming version of sqlite3changeset_concat().
-*/
-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
-){
-  sqlite3_changegroup *pGrp;
-  int rc;
-
-  rc = sqlite3changegroup_new(&pGrp);
-  if( rc==SQLITE_OK ){
-    rc = sqlite3changegroup_add_strm(pGrp, xInputA, pInA);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3changegroup_add_strm(pGrp, xInputB, pInB);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3changegroup_output_strm(pGrp, xOutput, pOut);
-  }
-  sqlite3changegroup_delete(pGrp);
-
-  return rc;
-}
-
-/*
-** Changeset rebaser handle.
-*/
-struct sqlite3_rebaser {
-  sqlite3_changegroup grp;        /* Hash table */
-};
-
-/*
-** Buffers a1 and a2 must both contain a sessions module record nCol
-** fields in size. This function appends an nCol sessions module
-** record to buffer pBuf that is a copy of a1, except that for
-** each field that is undefined in a1[], swap in the field from a2[].
-*/
-static void sessionAppendRecordMerge(
-  SessionBuffer *pBuf,            /* Buffer to append to */
-  int nCol,                       /* Number of columns in each record */
-  u8 *a1, int n1,                 /* Record 1 */
-  u8 *a2, int n2,                 /* Record 2 */
-  int *pRc                        /* IN/OUT: error code */
-){
-  sessionBufferGrow(pBuf, n1+n2, pRc);
-  if( *pRc==SQLITE_OK ){
-    int i;
-    u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
-    for(i=0; i<nCol; i++){
-      int nn1 = sessionSerialLen(a1);
-      int nn2 = sessionSerialLen(a2);
-      if( *a1==0 || *a1==0xFF ){
-        memcpy(pOut, a2, nn2);
-        pOut += nn2;
-      }else{
-        memcpy(pOut, a1, nn1);
-        pOut += nn1;
-      }
-      a1 += nn1;
-      a2 += nn2;
-    }
-
-    pBuf->nBuf = pOut-pBuf->aBuf;
-    assert( pBuf->nBuf<=pBuf->nAlloc );
-  }
-}
-
-/*
-** This function is called when rebasing a local UPDATE change against one
-** or more remote UPDATE changes. The aRec/nRec buffer contains the current
-** old.* and new.* records for the change. The rebase buffer (a single
-** record) is in aChange/nChange. The rebased change is appended to buffer
-** pBuf.
-**
-** Rebasing the UPDATE involves:
-**
-**   * Removing any changes to fields for which the corresponding field
-**     in the rebase buffer is set to "replaced" (type 0xFF). If this
-**     means the UPDATE change updates no fields, nothing is appended
-**     to the output buffer.
-**
-**   * For each field modified by the local change for which the
-**     corresponding field in the rebase buffer is not "undefined" (0x00)
-**     or "replaced" (0xFF), the old.* value is replaced by the value
-**     in the rebase buffer.
-*/
-static void sessionAppendPartialUpdate(
-  SessionBuffer *pBuf,            /* Append record here */
-  sqlite3_changeset_iter *pIter,  /* Iterator pointed at local change */
-  u8 *aRec, int nRec,             /* Local change */
-  u8 *aChange, int nChange,       /* Record to rebase against */
-  int *pRc                        /* IN/OUT: Return Code */
-){
-  sessionBufferGrow(pBuf, 2+nRec+nChange, pRc);
-  if( *pRc==SQLITE_OK ){
-    int bData = 0;
-    u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
-    int i;
-    u8 *a1 = aRec;
-    u8 *a2 = aChange;
-
-    *pOut++ = SQLITE_UPDATE;
-    *pOut++ = pIter->bIndirect;
-    for(i=0; i<pIter->nCol; i++){
-      int n1 = sessionSerialLen(a1);
-      int n2 = sessionSerialLen(a2);
-      if( pIter->abPK[i] || a2[0]==0 ){
-        if( !pIter->abPK[i] && a1[0] ) bData = 1;
-        memcpy(pOut, a1, n1);
-        pOut += n1;
-      }else if( a2[0]!=0xFF && a1[0] ){
-        bData = 1;
-        memcpy(pOut, a2, n2);
-        pOut += n2;
-      }else{
-        *pOut++ = '\0';
-      }
-      a1 += n1;
-      a2 += n2;
-    }
-    if( bData ){
-      a2 = aChange;
-      for(i=0; i<pIter->nCol; i++){
-        int n1 = sessionSerialLen(a1);
-        int n2 = sessionSerialLen(a2);
-        if( pIter->abPK[i] || a2[0]!=0xFF ){
-          memcpy(pOut, a1, n1);
-          pOut += n1;
-        }else{
-          *pOut++ = '\0';
-        }
-        a1 += n1;
-        a2 += n2;
-      }
-      pBuf->nBuf = (pOut - pBuf->aBuf);
-    }
-  }
-}
-
-/*
-** pIter is configured to iterate through a changeset. This function rebases
-** that changeset according to the current configuration of the rebaser
-** object passed as the first argument. If no error occurs and argument xOutput
-** is not NULL, then the changeset is returned to the caller by invoking
-** xOutput zero or more times and SQLITE_OK returned. Or, if xOutput is NULL,
-** then (*ppOut) is set to point to a buffer containing the rebased changeset
-** before this function returns. In this case (*pnOut) is set to the size of
-** the buffer in bytes.  It is the responsibility of the caller to eventually
-** free the (*ppOut) buffer using sqlite3_free().
-**
-** If an error occurs, an SQLite error code is returned. If ppOut and
-** pnOut are not NULL, then the two output parameters are set to 0 before
-** returning.
-*/
-static int sessionRebase(
-  sqlite3_rebaser *p,             /* Rebaser hash table */
-  sqlite3_changeset_iter *pIter,  /* Input data */
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut,                     /* Context for xOutput callback */
-  int *pnOut,                     /* OUT: Number of bytes in output changeset */
-  void **ppOut                    /* OUT: Inverse of pChangeset */
-){
-  int rc = SQLITE_OK;
-  u8 *aRec = 0;
-  int nRec = 0;
-  int bNew = 0;
-  SessionTable *pTab = 0;
-  SessionBuffer sOut = {0,0,0};
-
-  while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, &bNew) ){
-    SessionChange *pChange = 0;
-    int bDone = 0;
-
-    if( bNew ){
-      const char *zTab = pIter->zTab;
-      for(pTab=p->grp.pList; pTab; pTab=pTab->pNext){
-        if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break;
-      }
-      bNew = 0;
-
-      /* A patchset may not be rebased */
-      if( pIter->bPatchset ){
-        rc = SQLITE_ERROR;
-      }
-
-      /* Append a table header to the output for this new table */
-      sessionAppendByte(&sOut, pIter->bPatchset ? 'P' : 'T', &rc);
-      sessionAppendVarint(&sOut, pIter->nCol, &rc);
-      sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
-      sessionAppendBlob(&sOut,(u8*)pIter->zTab,(int)strlen(pIter->zTab)+1,&rc);
-    }
-
-    if( pTab && rc==SQLITE_OK ){
-      int iHash = sessionChangeHash(pTab, 0, aRec, pTab->nChange);
-
-      for(pChange=pTab->apChange[iHash]; pChange; pChange=pChange->pNext){
-        if( sessionChangeEqual(pTab, 0, aRec, 0, pChange->aRecord) ){
-          break;
-        }
-      }
-    }
-
-    if( pChange ){
-      assert( pChange->op==SQLITE_DELETE || pChange->op==SQLITE_INSERT );
-      switch( pIter->op ){
-        case SQLITE_INSERT:
-          if( pChange->op==SQLITE_INSERT ){
-            bDone = 1;
-            if( pChange->bIndirect==0 ){
-              sessionAppendByte(&sOut, SQLITE_UPDATE, &rc);
-              sessionAppendByte(&sOut, pIter->bIndirect, &rc);
-              sessionAppendBlob(&sOut, pChange->aRecord, pChange->nRecord, &rc);
-              sessionAppendBlob(&sOut, aRec, nRec, &rc);
-            }
-          }
-          break;
-
-        case SQLITE_UPDATE:
-          bDone = 1;
-          if( pChange->op==SQLITE_DELETE ){
-            if( pChange->bIndirect==0 ){
-              u8 *pCsr = aRec;
-              sessionSkipRecord(&pCsr, pIter->nCol);
-              sessionAppendByte(&sOut, SQLITE_INSERT, &rc);
-              sessionAppendByte(&sOut, pIter->bIndirect, &rc);
-              sessionAppendRecordMerge(&sOut, pIter->nCol,
-                  pCsr, nRec-(pCsr-aRec),
-                  pChange->aRecord, pChange->nRecord, &rc
-              );
-            }
-          }else{
-            sessionAppendPartialUpdate(&sOut, pIter,
-                aRec, nRec, pChange->aRecord, pChange->nRecord, &rc
-            );
-          }
-          break;
-
-        default:
-          assert( pIter->op==SQLITE_DELETE );
-          bDone = 1;
-          if( pChange->op==SQLITE_INSERT ){
-            sessionAppendByte(&sOut, SQLITE_DELETE, &rc);
-            sessionAppendByte(&sOut, pIter->bIndirect, &rc);
-            sessionAppendRecordMerge(&sOut, pIter->nCol,
-                pChange->aRecord, pChange->nRecord, aRec, nRec, &rc
-            );
-          }
-          break;
-      }
-    }
-
-    if( bDone==0 ){
-      sessionAppendByte(&sOut, pIter->op, &rc);
-      sessionAppendByte(&sOut, pIter->bIndirect, &rc);
-      sessionAppendBlob(&sOut, aRec, nRec, &rc);
-    }
-    if( rc==SQLITE_OK && xOutput && sOut.nBuf>sessions_strm_chunk_size ){
-      rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
-      sOut.nBuf = 0;
-    }
-    if( rc ) break;
-  }
-
-  if( rc!=SQLITE_OK ){
-    sqlite3_free(sOut.aBuf);
-    memset(&sOut, 0, sizeof(sOut));
-  }
-
-  if( rc==SQLITE_OK ){
-    if( xOutput ){
-      if( sOut.nBuf>0 ){
-        rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
-      }
-    }else if( ppOut ){
-      *ppOut = (void*)sOut.aBuf;
-      *pnOut = sOut.nBuf;
-      sOut.aBuf = 0;
-    }
-  }
-  sqlite3_free(sOut.aBuf);
-  return rc;
-}
-
-/*
-** Create a new rebaser object.
-*/
-SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew){
-  int rc = SQLITE_OK;
-  sqlite3_rebaser *pNew;
-
-  pNew = sqlite3_malloc(sizeof(sqlite3_rebaser));
-  if( pNew==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    memset(pNew, 0, sizeof(sqlite3_rebaser));
-  }
-  *ppNew = pNew;
-  return rc;
-}
-
-/*
-** Call this one or more times to configure a rebaser.
-*/
-SQLITE_API int sqlite3rebaser_configure(
-  sqlite3_rebaser *p,
-  int nRebase, const void *pRebase
-){
-  sqlite3_changeset_iter *pIter = 0;   /* Iterator opened on pData/nData */
-  int rc;                              /* Return code */
-  rc = sqlite3changeset_start(&pIter, nRebase, (void*)pRebase);
-  if( rc==SQLITE_OK ){
-    rc = sessionChangesetToHash(pIter, &p->grp, 1);
-  }
-  sqlite3changeset_finalize(pIter);
-  return rc;
-}
-
-/*
-** Rebase a changeset according to current rebaser configuration
-*/
-SQLITE_API int sqlite3rebaser_rebase(
-  sqlite3_rebaser *p,
-  int nIn, const void *pIn,
-  int *pnOut, void **ppOut
-){
-  sqlite3_changeset_iter *pIter = 0;   /* Iterator to skip through input */
-  int rc = sqlite3changeset_start(&pIter, nIn, (void*)pIn);
-
-  if( rc==SQLITE_OK ){
-    rc = sessionRebase(p, pIter, 0, 0, pnOut, ppOut);
-    sqlite3changeset_finalize(pIter);
-  }
-
-  return rc;
-}
-
-/*
-** Rebase a changeset according to current rebaser configuration
-*/
-SQLITE_API int sqlite3rebaser_rebase_strm(
-  sqlite3_rebaser *p,
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn,
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut
-){
-  sqlite3_changeset_iter *pIter = 0;   /* Iterator to skip through input */
-  int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
-
-  if( rc==SQLITE_OK ){
-    rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
-    sqlite3changeset_finalize(pIter);
-  }
-
-  return rc;
-}
-
-/*
-** Destroy a rebaser object
-*/
-SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p){
-  if( p ){
-    sessionDeleteTable(0, p->grp.pList);
-    sqlite3_free(p->grp.rec.aBuf);
-    sqlite3_free(p);
-  }
-}
-
-/*
-** Global configuration
-*/
-SQLITE_API int sqlite3session_config(int op, void *pArg){
-  int rc = SQLITE_OK;
-  switch( op ){
-    case SQLITE_SESSION_CONFIG_STRMSIZE: {
-      int *pInt = (int*)pArg;
-      if( *pInt>0 ){
-        sessions_strm_chunk_size = *pInt;
-      }
-      *pInt = sessions_strm_chunk_size;
-      break;
-    }
-    default:
-      rc = SQLITE_MISUSE;
-      break;
-  }
-  return rc;
-}
-
-/*
-** Begin adding a change to a changegroup object.
-*/
-SQLITE_API int sqlite3changegroup_change_begin(
-  sqlite3_changegroup *pGrp,
-  int eOp,
-  const char *zTab,
-  int bIndirect,
-  char **pzErr
-){
-  SessionTable *pTab = 0;
-  int rc = SQLITE_OK;
-
-  if( pGrp->cd.pTab ){
-    rc = SQLITE_MISUSE;
-  }else if( eOp!=SQLITE_INSERT && eOp!=SQLITE_UPDATE && eOp!=SQLITE_DELETE ){
-    rc = SQLITE_ERROR;
-  }else{
-    rc = sessionChangesetFindTable(pGrp, zTab, 0, &pTab);
-  }
-  if( rc==SQLITE_OK ){
-    if( pTab==0 ){
-      if( pzErr ){
-        *pzErr = sqlite3_mprintf("no such table: %s", zTab);
-      }
-      rc = SQLITE_ERROR;
-    }else{
-      int nReq = pTab->nCol * (eOp==SQLITE_UPDATE ? 2 : 1);
-      pGrp->cd.pTab = pTab;
-      pGrp->cd.eOp = eOp;
-      pGrp->cd.bIndirect = bIndirect;
-
-      if( pGrp->cd.nBufAlloc<nReq ){
-        SessionBuffer *aBuf = (SessionBuffer*)sqlite3_realloc(
-            pGrp->cd.aBuf, nReq * sizeof(SessionBuffer)
-        );
-        if( aBuf==0 ){
-          rc = SQLITE_NOMEM;
-        }else{
-          memset(&aBuf[pGrp->cd.nBufAlloc], 0,
-              sizeof(SessionBuffer) * (nReq - pGrp->cd.nBufAlloc)
-          );
-          pGrp->cd.aBuf = aBuf;
-          pGrp->cd.nBufAlloc = nReq;
-        }
-      }
-
-#ifdef SQLITE_DEBUG
-      {
-        /* Assert that all column values are currently undefined */
-        int ii;
-        for(ii=0; ii<pGrp->cd.nBufAlloc; ii++){
-          assert( pGrp->cd.aBuf[ii].nBuf==0 );
-        }
-      }
-#endif
-    }
-  }
-
-  return rc;
-}
-
-/*
-** This function does processing common to the _change_int64(), _change_text()
-** and other similar APIs.
-*/
-static int checkChangeParams(
-  sqlite3_changegroup *pGrp,
-  int bNew,
-  int iCol,
-  sqlite3_int64 nReq,
-  SessionBuffer **ppBuf
-){
-  int rc = SQLITE_OK;
-  if( pGrp->cd.pTab==0 ){
-    rc = SQLITE_MISUSE;
-  }else if( iCol<0 || iCol>=pGrp->cd.pTab->nCol ){
-    rc = SQLITE_RANGE;
-  }else if(
-      (bNew && pGrp->cd.eOp==SQLITE_DELETE)
-   || (!bNew && pGrp->cd.eOp==SQLITE_INSERT)
-  ){
-    rc = SQLITE_ERROR;
-  }else{
-    SessionBuffer *pBuf = &pGrp->cd.aBuf[iCol];
-    if( pGrp->cd.eOp==SQLITE_UPDATE && bNew ){
-      pBuf += pGrp->cd.pTab->nCol;
-    }
-    pBuf->nBuf = 0;
-    sessionBufferGrow(pBuf, nReq, &rc);
-    pBuf->nBuf = nReq;
-    *ppBuf = pBuf;
-  }
-  return rc;
-}
-
-/*
-** Configure the change currently under construction with an integer value.
-*/
-SQLITE_API int sqlite3changegroup_change_int64(
-  sqlite3_changegroup *pGrp,
-  int bNew,
-  int iCol,
-  sqlite3_int64 iVal
-){
-  int rc = SQLITE_OK;
-  SessionBuffer *pBuf = 0;
-
-  if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, 9, &pBuf)) ){
-    return rc;
-  }
-
-  pBuf->aBuf[0] = SQLITE_INTEGER;
-  sessionPutI64(&pBuf->aBuf[1], iVal);
-  return SQLITE_OK;
-}
-
-/*
-** Configure the change currently under construction with a null value.
-*/
-SQLITE_API int sqlite3changegroup_change_null(
-  sqlite3_changegroup *pGrp,
-  int bNew,
-  int iCol
-){
-  int rc = SQLITE_OK;
-  SessionBuffer *pBuf = 0;
-
-  if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, 1, &pBuf)) ){
-    return rc;
-  }
-
-  pBuf->aBuf[0] = SQLITE_NULL;
-  return SQLITE_OK;
-}
-
-/*
-** Configure the change currently under construction with a real value.
-*/
-SQLITE_API int sqlite3changegroup_change_double(
-  sqlite3_changegroup *pGrp,
-  int bNew,
-  int iCol,
-  double fVal
-){
-  int rc = SQLITE_OK;
-  SessionBuffer *pBuf = 0;
-
-  if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, 9, &pBuf)) ){
-    return rc;
-  }
-
-  pBuf->aBuf[0] = SQLITE_FLOAT;
-  sessionPutDouble(&pBuf->aBuf[1], fVal);
-  return SQLITE_OK;
-}
-
-/*
-** Configure the change currently under construction with a text value.
-*/
-SQLITE_API int sqlite3changegroup_change_text(
-  sqlite3_changegroup *pGrp,
-  int bNew,
-  int iCol,
-  const char *pVal,
-  int nVal
-){
-  int nText = nVal>=0 ? nVal : strlen(pVal);
-  sqlite3_int64 nByte = 1 + sessionVarintLen(nText) + nText;
-  int rc = SQLITE_OK;
-  SessionBuffer *pBuf = 0;
-
-  if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, nByte, &pBuf)) ){
-    return rc;
-  }
-
-  pBuf->aBuf[0] = SQLITE_TEXT;
-  pBuf->nBuf = (1 + sessionVarintPut(&pBuf->aBuf[1], nText));
-  memcpy(&pBuf->aBuf[pBuf->nBuf], pVal, nText);
-  pBuf->nBuf += nText;
-
-  return SQLITE_OK;
-}
-
-/*
-** Configure the change currently under construction with a blob value.
-*/
-SQLITE_API int sqlite3changegroup_change_blob(
-  sqlite3_changegroup *pGrp,
-  int bNew,
-  int iCol,
-  const void *pVal,
-  int nVal
-){
-  sqlite3_int64 nByte = 1 + sessionVarintLen(nVal) + nVal;
-  int rc = SQLITE_OK;
-  SessionBuffer *pBuf = 0;
-
-  if( SQLITE_OK!=(rc = checkChangeParams(pGrp, bNew, iCol, nByte, &pBuf)) ){
-    return rc;
-  }
-
-  pBuf->aBuf[0] = SQLITE_BLOB;
-  pBuf->nBuf = (1 + sessionVarintPut(&pBuf->aBuf[1], nVal));
-  memcpy(&pBuf->aBuf[pBuf->nBuf], pVal, nVal);
-  pBuf->nBuf += nVal;
-
-  return SQLITE_OK;
-}
-
-/*
-** Finish any change currently being constructed by the changegroup object.
-*/
-SQLITE_API int sqlite3changegroup_change_finish(
-  sqlite3_changegroup *pGrp,
-  int bDiscard,
-  char **pzErr
-){
-  int rc = SQLITE_OK;
-  if( pGrp->cd.pTab ){
-    SessionBuffer *aBuf = pGrp->cd.aBuf;
-    int ii;
-
-    if( bDiscard==0 ){
-      int nBuf = pGrp->cd.pTab->nCol;
-      u8 eUndef = SQLITE_NULL;
-      if( pGrp->cd.eOp==SQLITE_UPDATE ){
-        for(ii=0; ii<nBuf; ii++){
-          if( pGrp->cd.pTab->abPK[ii] ){
-            if( aBuf[ii].nBuf<=1 ){
-              *pzErr = sqlite3_mprintf(
-                  "invalid change: %s value in PK of old.* record",
-                  aBuf[ii].nBuf==1 ? "null" : "undefined"
-              );
-              rc = SQLITE_ERROR;
-              break;
-            }else if( aBuf[ii + nBuf].nBuf>0 ){
-              *pzErr = sqlite3_mprintf(
-                  "invalid change: defined value in PK of new.* record"
-              );
-              rc = SQLITE_ERROR;
-              break;
-            }
-          }else
-          if( pGrp->bPatch==0 && (aBuf[ii].nBuf>0)!=(aBuf[ii+nBuf].nBuf>0) ){
-            *pzErr = sqlite3_mprintf(
-                "invalid change: column %d "
-                "- old.* value is %sdefined but new.* is %sdefined",
-                ii, aBuf[ii].nBuf ? "" : "un", aBuf[ii+nBuf].nBuf ? "" : "un"
-            );
-            rc = SQLITE_ERROR;
-            break;
-          }
-        }
-        eUndef = 0x00;
-        if( pGrp->bPatch==0 ) nBuf = nBuf * 2;
-      }else{
-        for(ii=0; ii<nBuf; ii++){
-          int isPK = pGrp->cd.pTab->abPK[ii];
-          if( (pGrp->cd.eOp==SQLITE_INSERT || pGrp->bPatch==0 || isPK)
-           && aBuf[ii].nBuf==0
-          ){
-            *pzErr = sqlite3_mprintf(
-                "invalid change: column %d is undefined", ii
-            );
-            rc = SQLITE_ERROR;
-            break;
-          }
-          if( aBuf[ii].nBuf==1 && isPK ){
-            *pzErr = sqlite3_mprintf(
-                "invalid change: null value in PK"
-            );
-            rc = SQLITE_ERROR;
-            break;
-          }
-        }
-      }
-
-      pGrp->cd.record.nBuf = 0;
-      for(ii=0; ii<nBuf; ii++){
-        SessionBuffer *p = &pGrp->cd.aBuf[ii];
-        if( pGrp->bPatch ){
-          if( pGrp->cd.pTab->abPK[ii]==0 ){
-            if( pGrp->cd.eOp==SQLITE_UPDATE ){
-              p += pGrp->cd.pTab->nCol;
-            }else if( pGrp->cd.eOp==SQLITE_DELETE ){
-              continue;
-            }
-          }
-        }
-        if( 0==sessionBufferGrow(&pGrp->cd.record, p->nBuf?p->nBuf:1, &rc) ){
-          if( p->nBuf ){
-            memcpy(&pGrp->cd.record.aBuf[pGrp->cd.record.nBuf],p->aBuf,p->nBuf);
-            pGrp->cd.record.nBuf += p->nBuf;
-          }else{
-            pGrp->cd.record.aBuf[pGrp->cd.record.nBuf++] = eUndef;
-          }
-        }
-      }
-      if( rc==SQLITE_OK ){
-        rc = sessionOneChangeToHash(
-            pGrp, pGrp->cd.pTab,
-            pGrp->cd.eOp, pGrp->cd.bIndirect, pGrp->cd.pTab->nCol,
-            pGrp->cd.record.aBuf, pGrp->cd.record.nBuf, 0
-        );
-      }
-    }
-
-    /* Reset all aBuf[] entries to "undefined". */
-    {
-      int nZero = pGrp->cd.pTab->nCol;
-      if( pGrp->cd.eOp==SQLITE_UPDATE ) nZero += nZero;
-      for(ii=0; ii<nZero; ii++){
-        pGrp->cd.aBuf[ii].nBuf = 0;
-      }
-    }
-    pGrp->cd.pTab = 0;
-  }
-
-  return rc;
-}
-
-#endif /* SQLITE_ENABLE_SESSION && SQLITE_ENABLE_PREUPDATE_HOOK */
-
-/************** End of sqlite3session.c **************************************/
-/************** Begin file fts5.c ********************************************/
-
-/*
-** This, the "fts5.c" source file, is a composite file that is itself
-** assembled from the following files:
-**
-**    fts5.h
-**    fts5Int.h
-**    fts5parse.h          <--- Generated from fts5parse.y by Lemon
-**    fts5parse.c          <--- Generated from fts5parse.y by Lemon
-**    fts5_aux.c
-**    fts5_buffer.c
-**    fts5_config.c
-**    fts5_expr.c
-**    fts5_hash.c
-**    fts5_index.c
-**    fts5_main.c
-**    fts5_storage.c
-**    fts5_tokenize.c
-**    fts5_unicode2.c
-**    fts5_varint.c
-**    fts5_vocab.c
-*/
-#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS5)
-
-#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
-# define NDEBUG 1
-#endif
-#if defined(NDEBUG) && defined(SQLITE_DEBUG)
-# undef NDEBUG
-#endif
-
-#ifdef HAVE_STDINT_H
-/* #include <stdint.h> */
-#endif
-#ifdef HAVE_INTTYPES_H
-/* #include <inttypes.h> */
-#endif
-/*
-** 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
-
-/* #include "sqlite3.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 pUserData pointer passed to the xCreateFunction()
-**   API when the extension function was registered.
-**
-** 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:
-**   If parameter iCol is less than zero, or greater than or equal to the
-**   number of columns in the table, SQLITE_RANGE is returned.
-**
-**   Otherwise, 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:
-**   If parameter iCol is less than zero, or greater than or equal to the
-**   number of phrases in the current query, as returned by xPhraseCount,
-**   0 is returned. Otherwise, this function 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(). If iIdx is less than zero or greater than
-**   or equal to the value returned by xInstCount(), SQLITE_RANGE is returned.
-**
-**   Otherwise, 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. SQLITE_OK is returned 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 parameter iPhrase is less than zero, or greater than or equal to
-**   the number of phrases in the query, as returned by xPhraseCount(),
-**   this function returns SQLITE_RANGE.
-**
-**   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).
-**
-**   In all cases, matches are visited in (column ASC, offset ASC) order.
-**   i.e. all those in column 0, sorted by offset, followed by those in
-**   column 1, etc.
-**
-** 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.
-**
-** xQueryToken(pFts5, iPhrase, iToken, ppToken, pnToken)
-**   This is used to access token iToken of phrase iPhrase of the current
-**   query. Before returning, output parameter *ppToken is set to point
-**   to a buffer containing the requested token, and *pnToken to the
-**   size of this buffer in bytes.
-**
-**   If iPhrase or iToken are less than zero, or if iPhrase is greater than
-**   or equal to the number of phrases in the query as reported by
-**   xPhraseCount(), or if iToken is equal to or greater than the number of
-**   tokens in the phrase, SQLITE_RANGE is returned and *ppToken and *pnToken
-     are both zeroed.
-**
-**   The output text is not a copy of the query text that specified the
-**   token. It is the output of the tokenizer module. For tokendata=1
-**   tables, this includes any embedded 0x00 and trailing data.
-**
-** xInstToken(pFts5, iIdx, iToken, ppToken, pnToken)
-**   This is used to access token iToken of phrase hit iIdx within the
-**   current row. If iIdx is less than zero or greater than or equal to the
-**   value returned by xInstCount(), SQLITE_RANGE is returned.  Otherwise,
-**   output variable (*ppToken) is set to point to a buffer containing the
-**   matching document token, and (*pnToken) to the size of that buffer in
-**   bytes.
-**
-**   The output text is not a copy of the document text that was tokenized.
-**   It is the output of the tokenizer module. For tokendata=1 tables, this
-**   includes any embedded 0x00 and trailing data.
-**
-**   This API may be slow in some cases if the token identified by parameters
-**   iIdx and iToken matched a prefix token in the query. In most cases, the
-**   first call to this API for each prefix token in the query is forced
-**   to scan the portion of the full-text index that matches the prefix
-**   token to collect the extra data required by this API. If the prefix
-**   token matches a large number of token instances in the document set,
-**   this may be a performance problem.
-**
-**   If the user knows in advance that a query may use this API for a
-**   prefix token, FTS5 may be configured to collect all required data as part
-**   of the initial querying of the full-text index, avoiding the second scan
-**   entirely. This also causes prefix queries that do not use this API to
-**   run more slowly and use more memory. FTS5 may be configured in this way
-**   either on a per-table basis using the [FTS5 insttoken | 'insttoken']
-**   option, or on a per-query basis using the
-**   [fts5_insttoken | fts5_insttoken()] user function.
-**
-**   This API can be quite slow if used with an FTS5 table created with the
-**   "detail=none" or "detail=column" option.
-**
-** xColumnLocale(pFts5, iIdx, pzLocale, pnLocale)
-**   If parameter iCol is less than zero, or greater than or equal to the
-**   number of columns in the table, SQLITE_RANGE is returned.
-**
-**   Otherwise, this function attempts to retrieve the locale associated
-**   with column iCol of the current row. Usually, there is no associated
-**   locale, and output parameters (*pzLocale) and (*pnLocale) are set
-**   to NULL and 0, respectively. However, if the fts5_locale() function
-**   was used to associate a locale with the value when it was inserted
-**   into the fts5 table, then (*pzLocale) is set to point to a nul-terminated
-**   buffer containing the name of the locale in utf-8 encoding. (*pnLocale)
-**   is set to the size in bytes of the buffer, not including the
-**   nul-terminator.
-**
-**   If successful, SQLITE_OK is returned. Or, if an error occurs, an
-**   SQLite error code is returned. The final value of the output parameters
-**   is undefined in this case.
-**
-** xTokenize_v2:
-**   Tokenize text using the tokenizer belonging to the FTS5 table. This
-**   API is the same as the xTokenize() API, except that it allows a tokenizer
-**   locale to be specified.
-*/
-struct Fts5ExtensionApi {
-  int iVersion;                   /* Currently always set to 4 */
-
-  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);
-
-  /* Below this point are iVersion>=3 only */
-  int (*xQueryToken)(Fts5Context*,
-      int iPhrase, int iToken,
-      const char **ppToken, int *pnToken
-  );
-  int (*xInstToken)(Fts5Context*, int iIdx, int iToken, const char**, int*);
-
-  /* Below this point are iVersion>=4 only */
-  int (*xColumnLocale)(Fts5Context*, int iCol, const char **pz, int *pn);
-  int (*xTokenize_v2)(Fts5Context*,
-    const char *pText, int nText,      /* Text to tokenize */
-    const char *pLocale, int nLocale,  /* Locale to pass to tokenizer */
-    void *pCtx,                        /* Context passed to xToken() */
-    int (*xToken)(void*, int, const char*, int, int, int)       /* Callback */
-  );
-};
-
-/*
-** 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_v2 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 third argument indicates the reason that FTS5 is requesting
-**   tokenization of the supplied text. This is always one of the following
-**   four values:
-**
-**   <ul><li> <b>FTS5_TOKENIZE_DOCUMENT</b> - 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.
-**
-**       <li> <b>FTS5_TOKENIZE_QUERY</b> - 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.
-**
-**       <li> <b>(FTS5_TOKENIZE_QUERY | FTS5_TOKENIZE_PREFIX)</b> - 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.
-**
-**       <li> <b>FTS5_TOKENIZE_AUX</b> - 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.
-**   </ul>
-**
-**   The sixth and seventh arguments passed to xTokenize() - pLocale and
-**   nLocale - are a pointer to a buffer containing the locale to use for
-**   tokenization (e.g. "en_US") and its size in bytes, respectively. The
-**   pLocale buffer is not nul-terminated. pLocale may be passed NULL (in
-**   which case nLocale is always 0) to indicate that the tokenizer should
-**   use its default locale.
-**
-**   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.
-**
-**   If the tokenizer is registered using an fts5_tokenizer_v2 object,
-**   then the xTokenize() method has two additional arguments - pLocale
-**   and nLocale. These specify the locale that the tokenizer should use
-**   for the current request. If pLocale and nLocale are both 0, then the
-**   tokenizer should use its default locale. Otherwise, pLocale points to
-**   an nLocale byte buffer containing the name of the locale to use as utf-8
-**   text. pLocale is not nul-terminated.
-**
-** FTS5_TOKENIZER
-**
-** There is also an fts5_tokenizer object. This is an older, deprecated,
-** version of fts5_tokenizer_v2. It is similar except that:
-**
-**  <ul>
-**    <li> There is no "iVersion" field, and
-**    <li> The xTokenize() method does not take a locale argument.
-**  </ul>
-**
-** Legacy fts5_tokenizer tokenizers must be registered using the
-** legacy xCreateTokenizer() function, instead of xCreateTokenizer_v2().
-**
-** Tokenizer implementations registered using either API may be retrieved
-** using both xFindTokenizer() and xFindTokenizer_v2().
-**
-** 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:
-**
-**   <ol><li> 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.
-**
-**       <li> 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:
-**
-**   <codeblock>
-**     ... MATCH 'first place'</codeblock>
-**
-**            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:
-**
-**   <codeblock>
-**     ... MATCH '(first OR 1st) place'</codeblock>
-**
-**            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.
-**
-**       <li> 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.
-**   </ol>
-**
-**   Whether it is parsing document or query text, any call to xToken that
-**   specifies a <i>tflags</i> 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:
-**
-**   <codeblock>
-**       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);
-**</codeblock>
-**
-**   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:
-**
-**   <codeblock>
-**     ... MATCH '1s*'</codeblock>
-**
-**   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 (3)) or query
-**   text (method (2)), not both. Doing so will not cause any errors, but is
-**   inefficient.
-*/
-typedef struct Fts5Tokenizer Fts5Tokenizer;
-typedef struct fts5_tokenizer_v2 fts5_tokenizer_v2;
-struct fts5_tokenizer_v2 {
-  int iVersion;             /* Currently always 2 */
-
-  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,
-      const char *pLocale, int nLocale,
-      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 */
-      )
-  );
-};
-
-/*
-** New code should use the fts5_tokenizer_v2 type to define tokenizer
-** implementations. The following type is included for legacy applications
-** that still use it.
-*/
-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 3 */
-
-  /* Create a new tokenizer */
-  int (*xCreateTokenizer)(
-    fts5_api *pApi,
-    const char *zName,
-    void *pUserData,
-    fts5_tokenizer *pTokenizer,
-    void (*xDestroy)(void*)
-  );
-
-  /* Find an existing tokenizer */
-  int (*xFindTokenizer)(
-    fts5_api *pApi,
-    const char *zName,
-    void **ppUserData,
-    fts5_tokenizer *pTokenizer
-  );
-
-  /* Create a new auxiliary function */
-  int (*xCreateFunction)(
-    fts5_api *pApi,
-    const char *zName,
-    void *pUserData,
-    fts5_extension_function xFunction,
-    void (*xDestroy)(void*)
-  );
-
-  /* APIs below this point are only available if iVersion>=3 */
-
-  /* Create a new tokenizer */
-  int (*xCreateTokenizer_v2)(
-    fts5_api *pApi,
-    const char *zName,
-    void *pUserData,
-    fts5_tokenizer_v2 *pTokenizer,
-    void (*xDestroy)(void*)
-  );
-
-  /* Find an existing tokenizer */
-  int (*xFindTokenizer_v2)(
-    fts5_api *pApi,
-    const char *zName,
-    void **ppUserData,
-    fts5_tokenizer_v2 **ppTokenizer
-  );
-};
-
-/*
-** END OF REGISTRATION API
-*************************************************************************/
-
-#if 0
-}  /* end of the 'extern "C"' block */
-#endif
-
-#endif /* _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.
-**
-******************************************************************************
-**
-*/
-#ifndef _FTS5INT_H
-#define _FTS5INT_H
-
-/* #include "fts5.h" */
-/* #include "sqlite3ext.h" */
-SQLITE_EXTENSION_INIT1
-
-/* #include <string.h> */
-/* #include <assert.h> */
-/* #include <stddef.h> */
-
-#ifndef SQLITE_AMALGAMATION
-
-typedef unsigned char  u8;
-typedef unsigned int   u32;
-typedef unsigned short u16;
-typedef short i16;
-typedef sqlite3_int64 i64;
-typedef sqlite3_uint64 u64;
-
-#ifndef ArraySize
-# define ArraySize(x) ((int)(sizeof(x) / sizeof(x[0])))
-#endif
-
-#define testcase(x)
-
-#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
-
-#define MIN(x,y) (((x) < (y)) ? (x) : (y))
-#define MAX(x,y) (((x) > (y)) ? (x) : (y))
-
-/*
-** Constants for the largest and smallest possible 64-bit signed integers.
-*/
-# define LARGEST_INT64  (0xffffffff|(((i64)0x7fffffff)<<32))
-# define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
-
-/*
-** This macro is used in a single assert() within fts5 to check that an
-** allocation is aligned to an 8-byte boundary. But it is a complicated
-** macro to get right for multiple platforms without generating warnings.
-** So instead of reproducing the entire definition from sqliteInt.h, we
-** just do without this assert() for the rare non-amalgamation builds.
-*/
-#define EIGHT_BYTE_ALIGNMENT(x) 1
-
-/*
-** Macros needed to provide flexible arrays in a portable way
-*/
-#ifndef offsetof
-# define offsetof(ST,M) ((size_t)((char*)&((ST*)0)->M - (char*)0))
-#endif
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
-# define FLEXARRAY
-#else
-# define FLEXARRAY 1
-#endif
-
-#endif /* SQLITE_AMALGAMATION */
-
-/*
-** Constants for the largest and smallest possible 32-bit signed integers.
-*/
-# define LARGEST_INT32  ((int)(0x7fffffff))
-# define SMALLEST_INT32 ((int)((-1) - LARGEST_INT32))
-
-/* Truncate very long tokens to this many bytes. Hard limit is
-** (65536-1-1-4-9)==65521 bytes. The limiting factor is the 16-bit offset
-** field that occurs at the start of each leaf page (see fts5_index.c). */
-#define FTS5_MAX_TOKEN_SIZE 32768
-
-/*
-** Maximum number of prefix indexes on single FTS5 table. This must be
-** less than 32. If it is set to anything large than that, an #error
-** directive in fts5_index.c will cause the build to fail.
-*/
-#define FTS5_MAX_PREFIX_INDEXES 31
-
-/*
-** Maximum segments permitted in a single index
-*/
-#define FTS5_MAX_SEGMENT 2000
-
-#define FTS5_DEFAULT_NEARDIST 10
-#define FTS5_DEFAULT_RANK     "bm25"
-
-/* Name of rank and rowid columns */
-#define FTS5_RANK_NAME "rank"
-#define FTS5_ROWID_NAME "rowid"
-
-#ifdef SQLITE_DEBUG
-# define FTS5_CORRUPT sqlite3Fts5Corrupt()
-static int sqlite3Fts5Corrupt(void);
-#else
-# define FTS5_CORRUPT SQLITE_CORRUPT_VTAB
-#endif
-
-/*
-** The assert_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_fts5_may_be_corrupt;
-# define assert_nc(x) assert(sqlite3_fts5_may_be_corrupt || (x))
-#else
-# define assert_nc(x) assert(x)
-#endif
-
-/*
-** A version of memcmp() that does not cause asan errors if one of the pointer
-** parameters is NULL and the number of bytes to compare is zero.
-*/
-#define fts5Memcmp(s1, s2, n) ((n)<=0 ? 0 : memcmp((s1), (s2), (n)))
-
-/* Mark a function parameter as unused, to suppress nuisance compiler
-** warnings. */
-#ifndef UNUSED_PARAM
-# define UNUSED_PARAM(X)  (void)(X)
-#endif
-
-#ifndef UNUSED_PARAM2
-# define UNUSED_PARAM2(X, Y)  (void)(X), (void)(Y)
-#endif
-
-typedef struct Fts5Global Fts5Global;
-typedef struct Fts5Colset Fts5Colset;
-
-/* If a NEAR() clump or phrase may only match a specific set of columns,
-** then an object of the following type is used to record the set of columns.
-** Each entry in the aiCol[] array is a column that may be matched.
-**
-** This object is used by fts5_expr.c and fts5_index.c.
-*/
-struct Fts5Colset {
-  int nCol;
-  int aiCol[FLEXARRAY];
-};
-
-/* Size (int bytes) of a complete Fts5Colset object with N columns. */
-#define SZ_FTS5COLSET(N) (sizeof(i64)*((N+2)/2))
-
-/**************************************************************************
-** Interface to code in fts5_config.c. fts5_config.c contains contains code
-** to parse the arguments passed to the CREATE VIRTUAL TABLE statement.
-*/
-
-typedef struct Fts5Config Fts5Config;
-typedef struct Fts5TokenizerConfig Fts5TokenizerConfig;
-
-struct Fts5TokenizerConfig {
-  Fts5Tokenizer *pTok;
-  fts5_tokenizer_v2 *pApi2;
-  fts5_tokenizer *pApi1;
-  const char **azArg;
-  int nArg;
-  int ePattern;                   /* FTS_PATTERN_XXX constant */
-  const char *pLocale;            /* Current locale to use */
-  int nLocale;                    /* Size of pLocale in bytes */
-};
-
-/*
-** An instance of the following structure encodes all information that can
-** be gleaned from the CREATE VIRTUAL TABLE statement.
-**
-** And all information loaded from the %_config table.
-**
-** nAutomerge:
-**   The minimum number of segments that an auto-merge operation should
-**   attempt to merge together. A value of 1 sets the object to use the
-**   compile time default. Zero disables auto-merge altogether.
-**
-** bContentlessDelete:
-**   True if the contentless_delete option was present in the CREATE
-**   VIRTUAL TABLE statement.
-**
-** zContent:
-**
-** zContentRowid:
-**   The value of the content_rowid= option, if one was specified. Or
-**   the string "rowid" otherwise. This text is not quoted - if it is
-**   used as part of an SQL statement it needs to be quoted appropriately.
-**
-** zContentExprlist:
-**
-** pzErrmsg:
-**   This exists in order to allow the fts5_index.c module to return a
-**   decent error message if it encounters a file-format version it does
-**   not understand.
-**
-** bColumnsize:
-**   True if the %_docsize table is created.
-**
-** bPrefixIndex:
-**   This is only used for debugging. If set to false, any prefix indexes
-**   are ignored. This value is configured using:
-**
-**       INSERT INTO tbl(tbl, rank) VALUES('prefix-index', $bPrefixIndex);
-**
-** bLocale:
-**   Set to true if locale=1 was specified when the table was created.
-*/
-struct Fts5Config {
-  sqlite3 *db;                    /* Database handle */
-  Fts5Global *pGlobal;            /* Global fts5 object for handle db */
-  char *zDb;                      /* Database holding FTS index (e.g. "main") */
-  char *zName;                    /* Name of FTS index */
-  int nCol;                       /* Number of columns */
-  char **azCol;                   /* Column names */
-  u8 *abUnindexed;                /* True for unindexed columns */
-  int nPrefix;                    /* Number of prefix indexes */
-  int *aPrefix;                   /* Sizes in bytes of nPrefix prefix indexes */
-  int eContent;                   /* An FTS5_CONTENT value */
-  int bContentlessDelete;         /* "contentless_delete=" option (dflt==0) */
-  int bContentlessUnindexed;      /* "contentless_unindexed=" option (dflt=0) */
-  char *zContent;                 /* content table */
-  char *zContentRowid;            /* "content_rowid=" option value */
-  int bColumnsize;                /* "columnsize=" option value (dflt==1) */
-  int bTokendata;                 /* "tokendata=" option value (dflt==0) */
-  int bLocale;                    /* "locale=" option value (dflt==0) */
-  int eDetail;                    /* FTS5_DETAIL_XXX value */
-  char *zContentExprlist;
-  Fts5TokenizerConfig t;
-  int bLock;                      /* True when table is preparing statement */
-
-
-  /* Values loaded from the %_config table */
-  int iVersion;                   /* fts5 file format 'version' */
-  int iCookie;                    /* Incremented when %_config is modified */
-  int pgsz;                       /* Approximate page size used in %_data */
-  int nAutomerge;                 /* 'automerge' setting */
-  int nCrisisMerge;               /* Maximum allowed segments per level */
-  int nUsermerge;                 /* 'usermerge' setting */
-  int nHashSize;                  /* Bytes of memory for in-memory hash */
-  char *zRank;                    /* Name of rank function */
-  char *zRankArgs;                /* Arguments to rank function */
-  int bSecureDelete;              /* 'secure-delete' */
-  int nDeleteMerge;               /* 'deletemerge' */
-  int bPrefixInsttoken;           /* 'prefix-insttoken' */
-
-  /* If non-NULL, points to sqlite3_vtab.base.zErrmsg. Often NULL. */
-  char **pzErrmsg;
-
-#ifdef SQLITE_DEBUG
-  int bPrefixIndex;               /* True to use prefix-indexes */
-#endif
-};
-
-/* Current expected value of %_config table 'version' field. And
-** the expected version if the 'secure-delete' option has ever been
-** set on the table.  */
-#define FTS5_CURRENT_VERSION               4
-#define FTS5_CURRENT_VERSION_SECUREDELETE  5
-
-#define FTS5_CONTENT_NORMAL    0
-#define FTS5_CONTENT_NONE      1
-#define FTS5_CONTENT_EXTERNAL  2
-#define FTS5_CONTENT_UNINDEXED 3
-
-#define FTS5_DETAIL_FULL      0
-#define FTS5_DETAIL_NONE      1
-#define FTS5_DETAIL_COLUMNS   2
-
-#define FTS5_PATTERN_NONE     0
-#define FTS5_PATTERN_LIKE     65  /* matches SQLITE_INDEX_CONSTRAINT_LIKE */
-#define FTS5_PATTERN_GLOB     66  /* matches SQLITE_INDEX_CONSTRAINT_GLOB */
-
-static int sqlite3Fts5ConfigParse(
-    Fts5Global*, sqlite3*, int, const char **, Fts5Config**, char**
-);
-static void sqlite3Fts5ConfigFree(Fts5Config*);
-
-static int sqlite3Fts5ConfigDeclareVtab(Fts5Config *pConfig);
-
-static int sqlite3Fts5Tokenize(
-  Fts5Config *pConfig,            /* FTS5 Configuration object */
-  int flags,                      /* FTS5_TOKENIZE_* flags */
-  const char *pText, int nText,   /* Text to tokenize */
-  void *pCtx,                     /* Context passed to xToken() */
-  int (*xToken)(void*, int, const char*, int, int, int)    /* Callback */
-);
-
-static void sqlite3Fts5Dequote(char *z);
-
-/* Load the contents of the %_config table */
-static int sqlite3Fts5ConfigLoad(Fts5Config*, int);
-
-/* Set the value of a single config attribute */
-static int sqlite3Fts5ConfigSetValue(Fts5Config*, const char*, sqlite3_value*, int*);
-
-static int sqlite3Fts5ConfigParseRank(const char*, char**, char**);
-
-static void sqlite3Fts5ConfigErrmsg(Fts5Config *pConfig, const char *zFmt, ...);
-
-/*
-** End of interface to code in fts5_config.c.
-**************************************************************************/
-
-/**************************************************************************
-** Interface to code in fts5_buffer.c.
-*/
-
-/*
-** Buffer object for the incremental building of string data.
-*/
-typedef struct Fts5Buffer Fts5Buffer;
-struct Fts5Buffer {
-  u8 *p;
-  int n;
-  int nSpace;
-};
-
-static int sqlite3Fts5BufferSize(int*, Fts5Buffer*, u32);
-static void sqlite3Fts5BufferAppendVarint(int*, Fts5Buffer*, i64);
-static void sqlite3Fts5BufferAppendBlob(int*, Fts5Buffer*, u32, const u8*);
-static void sqlite3Fts5BufferAppendString(int *, Fts5Buffer*, const char*);
-static void sqlite3Fts5BufferFree(Fts5Buffer*);
-static void sqlite3Fts5BufferZero(Fts5Buffer*);
-static void sqlite3Fts5BufferSet(int*, Fts5Buffer*, int, const u8*);
-static void sqlite3Fts5BufferAppendPrintf(int *, Fts5Buffer*, char *zFmt, ...);
-
-static char *sqlite3Fts5Mprintf(int *pRc, const char *zFmt, ...);
-
-#define fts5BufferZero(x)             sqlite3Fts5BufferZero(x)
-#define fts5BufferAppendVarint(a,b,c) sqlite3Fts5BufferAppendVarint(a,b,(i64)c)
-#define fts5BufferFree(a)             sqlite3Fts5BufferFree(a)
-#define fts5BufferAppendBlob(a,b,c,d) sqlite3Fts5BufferAppendBlob(a,b,c,d)
-#define fts5BufferSet(a,b,c,d)        sqlite3Fts5BufferSet(a,b,c,d)
-
-#define fts5BufferGrow(pRc,pBuf,nn) ( \
-  (u32)((pBuf)->n) + (u32)(nn) <= (u32)((pBuf)->nSpace) ? 0 : \
-    sqlite3Fts5BufferSize((pRc),(pBuf),(nn)+(pBuf)->n) \
-)
-
-/* Write and decode big-endian 32-bit integer values */
-static void sqlite3Fts5Put32(u8*, int);
-static int sqlite3Fts5Get32(const u8*);
-
-#define FTS5_POS2COLUMN(iPos) (int)((iPos >> 32) & 0x7FFFFFFF)
-#define FTS5_POS2OFFSET(iPos) (int)(iPos & 0x7FFFFFFF)
-
-typedef struct Fts5PoslistReader Fts5PoslistReader;
-struct Fts5PoslistReader {
-  /* Variables used only by sqlite3Fts5PoslistIterXXX() functions. */
-  const u8 *a;                    /* Position list to iterate through */
-  int n;                          /* Size of buffer at a[] in bytes */
-  int i;                          /* Current offset in a[] */
-
-  u8 bFlag;                       /* For client use (any custom purpose) */
-
-  /* Output variables */
-  u8 bEof;                        /* Set to true at EOF */
-  i64 iPos;                       /* (iCol<<32) + iPos */
-};
-static int sqlite3Fts5PoslistReaderInit(
-  const u8 *a, int n,             /* Poslist buffer to iterate through */
-  Fts5PoslistReader *pIter        /* Iterator object to initialize */
-);
-static int sqlite3Fts5PoslistReaderNext(Fts5PoslistReader*);
-
-typedef struct Fts5PoslistWriter Fts5PoslistWriter;
-struct Fts5PoslistWriter {
-  i64 iPrev;
-};
-static int sqlite3Fts5PoslistWriterAppend(Fts5Buffer*, Fts5PoslistWriter*, i64);
-static void sqlite3Fts5PoslistSafeAppend(Fts5Buffer*, i64*, i64);
-
-static int sqlite3Fts5PoslistNext64(
-  const u8 *a, int n,             /* Buffer containing poslist */
-  int *pi,                        /* IN/OUT: Offset within a[] */
-  i64 *piOff                      /* IN/OUT: Current offset */
-);
-
-/* Malloc utility */
-static void *sqlite3Fts5MallocZero(int *pRc, sqlite3_int64 nByte);
-static char *sqlite3Fts5Strndup(int *pRc, const char *pIn, int nIn);
-
-/* Character set tests (like isspace(), isalpha() etc.) */
-static int sqlite3Fts5IsBareword(char t);
-
-
-/* Bucket of terms object used by the integrity-check in offsets=0 mode. */
-typedef struct Fts5Termset Fts5Termset;
-static int sqlite3Fts5TermsetNew(Fts5Termset**);
-static int sqlite3Fts5TermsetAdd(Fts5Termset*, int, const char*, int, int *pbPresent);
-static void sqlite3Fts5TermsetFree(Fts5Termset*);
-
-/*
-** End of interface to code in fts5_buffer.c.
-**************************************************************************/
-
-/**************************************************************************
-** Interface to code in fts5_index.c. fts5_index.c contains contains code
-** to access the data stored in the %_data table.
-*/
-
-typedef struct Fts5Index Fts5Index;
-typedef struct Fts5IndexIter Fts5IndexIter;
-
-struct Fts5IndexIter {
-  i64 iRowid;
-  const u8 *pData;
-  int nData;
-  u8 bEof;
-};
-
-#define sqlite3Fts5IterEof(x) ((x)->bEof)
-
-/*
-** Values used as part of the flags argument passed to IndexQuery().
-*/
-#define FTS5INDEX_QUERY_PREFIX      0x0001  /* Prefix query */
-#define FTS5INDEX_QUERY_DESC        0x0002  /* Docs in descending rowid order */
-#define FTS5INDEX_QUERY_TEST_NOIDX  0x0004  /* Do not use prefix index */
-#define FTS5INDEX_QUERY_SCAN        0x0008  /* Scan query (fts5vocab) */
-
-/* The following are used internally by the fts5_index.c module. They are
-** defined here only to make it easier to avoid clashes with the flags
-** above. */
-#define FTS5INDEX_QUERY_SKIPEMPTY   0x0010
-#define FTS5INDEX_QUERY_NOOUTPUT    0x0020
-#define FTS5INDEX_QUERY_SKIPHASH    0x0040
-#define FTS5INDEX_QUERY_NOTOKENDATA 0x0080
-#define FTS5INDEX_QUERY_SCANONETERM 0x0100
-
-/*
-** Create/destroy an Fts5Index object.
-*/
-static int sqlite3Fts5IndexOpen(Fts5Config *pConfig, int bCreate, Fts5Index**, char**);
-static int sqlite3Fts5IndexClose(Fts5Index *p);
-
-/*
-** Return a simple checksum value based on the arguments.
-*/
-static u64 sqlite3Fts5IndexEntryCksum(
-  i64 iRowid,
-  int iCol,
-  int iPos,
-  int iIdx,
-  const char *pTerm,
-  int nTerm
-);
-
-/*
-** Argument p points to a buffer containing utf-8 text that is n bytes in
-** size. Return the number of bytes in the nChar character prefix of the
-** buffer, or 0 if there are less than nChar characters in total.
-*/
-static int sqlite3Fts5IndexCharlenToBytelen(
-  const char *p,
-  int nByte,
-  int nChar
-);
-
-/*
-** Open a new iterator to iterate though all rowids that match the
-** specified token or token prefix.
-*/
-static int sqlite3Fts5IndexQuery(
-  Fts5Index *p,                   /* FTS index to query */
-  const char *pToken, int nToken, /* Token (or prefix) to query for */
-  int flags,                      /* Mask of FTS5INDEX_QUERY_X flags */
-  Fts5Colset *pColset,            /* Match these columns only */
-  Fts5IndexIter **ppIter          /* OUT: New iterator object */
-);
-
-/*
-** The various operations on open token or token prefix iterators opened
-** using sqlite3Fts5IndexQuery().
-*/
-static int sqlite3Fts5IterNext(Fts5IndexIter*);
-static int sqlite3Fts5IterNextFrom(Fts5IndexIter*, i64 iMatch);
-
-/*
-** Close an iterator opened by sqlite3Fts5IndexQuery().
-*/
-static void sqlite3Fts5IterClose(Fts5IndexIter*);
-
-/*
-** Close the reader blob handle, if it is open.
-*/
-static void sqlite3Fts5IndexCloseReader(Fts5Index*);
-
-/*
-** This interface is used by the fts5vocab module.
-*/
-static const char *sqlite3Fts5IterTerm(Fts5IndexIter*, int*);
-static int sqlite3Fts5IterNextScan(Fts5IndexIter*);
-static void *sqlite3Fts5StructureRef(Fts5Index*);
-static void sqlite3Fts5StructureRelease(void*);
-static int sqlite3Fts5StructureTest(Fts5Index*, void*);
-
-/*
-** Used by xInstToken():
-*/
-static int sqlite3Fts5IterToken(
-  Fts5IndexIter *pIndexIter,
-  const char *pToken, int nToken,
-  i64 iRowid,
-  int iCol,
-  int iOff,
-  const char **ppOut, int *pnOut
-);
-
-/*
-** Insert or remove data to or from the index. Each time a document is
-** added to or removed from the index, this function is called one or more
-** times.
-**
-** For an insert, it must be called once for each token in the new document.
-** If the operation is a delete, it must be called (at least) once for each
-** unique token in the document with an iCol value less than zero. The iPos
-** argument is ignored for a delete.
-*/
-static int sqlite3Fts5IndexWrite(
-  Fts5Index *p,                   /* Index to write to */
-  int iCol,                       /* Column token appears in (-ve -> delete) */
-  int iPos,                       /* Position of token within column */
-  const char *pToken, int nToken  /* Token to add or remove to or from index */
-);
-
-/*
-** Indicate that subsequent calls to sqlite3Fts5IndexWrite() pertain to
-** document iDocid.
-*/
-static int sqlite3Fts5IndexBeginWrite(
-  Fts5Index *p,                   /* Index to write to */
-  int bDelete,                    /* True if current operation is a delete */
-  i64 iDocid                      /* Docid to add or remove data from */
-);
-
-/*
-** Flush any data stored in the in-memory hash tables to the database.
-** Also close any open blob handles.
-*/
-static int sqlite3Fts5IndexSync(Fts5Index *p);
-
-/*
-** Discard any data stored in the in-memory hash tables. Do not write it
-** to the database. Additionally, assume that the contents of the %_data
-** table may have changed on disk. So any in-memory caches of %_data
-** records must be invalidated.
-*/
-static int sqlite3Fts5IndexRollback(Fts5Index *p);
-
-/*
-** Get or set the "averages" values.
-*/
-static int sqlite3Fts5IndexGetAverages(Fts5Index *p, i64 *pnRow, i64 *anSize);
-static int sqlite3Fts5IndexSetAverages(Fts5Index *p, const u8*, int);
-
-/*
-** Functions called by the storage module as part of integrity-check.
-*/
-static int sqlite3Fts5IndexIntegrityCheck(Fts5Index*, u64 cksum, int bUseCksum);
-
-/*
-** Called during virtual module initialization to register UDF
-** fts5_decode() with SQLite
-*/
-static int sqlite3Fts5IndexInit(sqlite3*);
-
-static int sqlite3Fts5IndexSetCookie(Fts5Index*, int);
-
-/*
-** Return the total number of entries read from the %_data table by
-** this connection since it was created.
-*/
-static int sqlite3Fts5IndexReads(Fts5Index *p);
-
-static int sqlite3Fts5IndexReinit(Fts5Index *p);
-static int sqlite3Fts5IndexOptimize(Fts5Index *p);
-static int sqlite3Fts5IndexMerge(Fts5Index *p, int nMerge);
-static int sqlite3Fts5IndexReset(Fts5Index *p);
-
-static int sqlite3Fts5IndexLoadConfig(Fts5Index *p);
-
-static int sqlite3Fts5IndexGetOrigin(Fts5Index *p, i64 *piOrigin);
-static int sqlite3Fts5IndexContentlessDelete(Fts5Index *p, i64 iOrigin, i64 iRowid);
-
-static void sqlite3Fts5IndexIterClearTokendata(Fts5IndexIter*);
-
-/* Used to populate hash tables for xInstToken in detail=none/column mode. */
-static int sqlite3Fts5IndexIterWriteTokendata(
-    Fts5IndexIter*, const char*, int, i64 iRowid, int iCol, int iOff
-);
-
-/*
-** End of interface to code in fts5_index.c.
-**************************************************************************/
-
-/**************************************************************************
-** Interface to code in fts5_varint.c.
-*/
-static int sqlite3Fts5GetVarint32(const unsigned char *p, u32 *v);
-static int sqlite3Fts5GetVarintLen(u32 iVal);
-static u8 sqlite3Fts5GetVarint(const unsigned char*, u64*);
-static int sqlite3Fts5PutVarint(unsigned char *p, u64 v);
-
-#define fts5GetVarint32(a,b) sqlite3Fts5GetVarint32(a,(u32*)&(b))
-#define fts5GetVarint    sqlite3Fts5GetVarint
-
-#define fts5FastGetVarint32(a, iOff, nVal) {      \
-  nVal = (a)[iOff++];                             \
-  if( nVal & 0x80 ){                              \
-    iOff--;                                       \
-    iOff += fts5GetVarint32(&(a)[iOff], nVal);    \
-  }                                               \
-}
-
-
-/*
-** End of interface to code in fts5_varint.c.
-**************************************************************************/
-
-
-/**************************************************************************
-** Interface to code in fts5_main.c.
-*/
-
-/*
-** Virtual-table object.
-*/
-typedef struct Fts5Table Fts5Table;
-struct Fts5Table {
-  sqlite3_vtab base;              /* Base class used by SQLite core */
-  Fts5Config *pConfig;            /* Virtual table configuration */
-  Fts5Index *pIndex;              /* Full-text index */
-};
-
-static int sqlite3Fts5LoadTokenizer(Fts5Config *pConfig);
-
-static Fts5Table *sqlite3Fts5TableFromCsrid(Fts5Global*, i64);
-
-static int sqlite3Fts5FlushToDisk(Fts5Table*);
-
-static void sqlite3Fts5ClearLocale(Fts5Config *pConfig);
-static void sqlite3Fts5SetLocale(Fts5Config *pConfig, const char *pLoc, int nLoc);
-
-static int sqlite3Fts5IsLocaleValue(Fts5Config *pConfig, sqlite3_value *pVal);
-static int sqlite3Fts5DecodeLocaleValue(sqlite3_value *pVal,
-    const char **ppText, int *pnText, const char **ppLoc, int *pnLoc
-);
-
-/*
-** End of interface to code in fts5.c.
-**************************************************************************/
-
-/**************************************************************************
-** Interface to code in fts5_hash.c.
-*/
-typedef struct Fts5Hash Fts5Hash;
-
-/*
-** Create a hash table, free a hash table.
-*/
-static int sqlite3Fts5HashNew(Fts5Config*, Fts5Hash**, int *pnSize);
-static void sqlite3Fts5HashFree(Fts5Hash*);
-
-static int sqlite3Fts5HashWrite(
-  Fts5Hash*,
-  i64 iRowid,                     /* Rowid for this entry */
-  int iCol,                       /* Column token appears in (-ve -> delete) */
-  int iPos,                       /* Position of token within column */
-  char bByte,
-  const char *pToken, int nToken  /* Token to add or remove to or from index */
-);
-
-/*
-** Empty (but do not delete) a hash table.
-*/
-static void sqlite3Fts5HashClear(Fts5Hash*);
-
-/*
-** Return true if the hash is empty, false otherwise.
-*/
-static int sqlite3Fts5HashIsEmpty(Fts5Hash*);
-
-static int sqlite3Fts5HashQuery(
-  Fts5Hash*,                      /* Hash table to query */
-  int nPre,
-  const char *pTerm, int nTerm,   /* Query term */
-  void **ppObj,                   /* OUT: Pointer to doclist for pTerm */
-  int *pnDoclist                  /* OUT: Size of doclist in bytes */
-);
-
-static int sqlite3Fts5HashScanInit(
-  Fts5Hash*,                      /* Hash table to query */
-  const char *pTerm, int nTerm    /* Query prefix */
-);
-static void sqlite3Fts5HashScanNext(Fts5Hash*);
-static int sqlite3Fts5HashScanEof(Fts5Hash*);
-static void sqlite3Fts5HashScanEntry(Fts5Hash *,
-  const char **pzTerm,            /* OUT: term (nul-terminated) */
-  int *pnTerm,                    /* OUT: Size of term in bytes */
-  const u8 **ppDoclist,           /* OUT: pointer to doclist */
-  int *pnDoclist                  /* OUT: size of doclist in bytes */
-);
-
-
-
-/*
-** End of interface to code in fts5_hash.c.
-**************************************************************************/
-
-/**************************************************************************
-** Interface to code in fts5_storage.c. fts5_storage.c contains contains
-** code to access the data stored in the %_content and %_docsize tables.
-*/
-
-#define FTS5_STMT_SCAN_ASC  0     /* SELECT rowid, * FROM ... ORDER BY 1 ASC */
-#define FTS5_STMT_SCAN_DESC 1     /* SELECT rowid, * FROM ... ORDER BY 1 DESC */
-#define FTS5_STMT_LOOKUP    2     /* SELECT rowid, * FROM ... WHERE rowid=? */
-
-typedef struct Fts5Storage Fts5Storage;
-
-static int sqlite3Fts5StorageOpen(Fts5Config*, Fts5Index*, int, Fts5Storage**, char**);
-static int sqlite3Fts5StorageClose(Fts5Storage *p);
-static int sqlite3Fts5StorageRename(Fts5Storage*, const char *zName);
-
-static int sqlite3Fts5DropAll(Fts5Config*);
-static int sqlite3Fts5CreateTable(Fts5Config*, const char*, const char*, int, char **);
-
-static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64, sqlite3_value**, int);
-static int sqlite3Fts5StorageContentInsert(Fts5Storage *p, int, sqlite3_value**, i64*);
-static int sqlite3Fts5StorageIndexInsert(Fts5Storage *p, sqlite3_value**, i64);
-
-static int sqlite3Fts5StorageIntegrity(Fts5Storage *p, int iArg);
-
-static int sqlite3Fts5StorageStmt(Fts5Storage *p, int eStmt, sqlite3_stmt**, char**);
-static void sqlite3Fts5StorageStmtRelease(Fts5Storage *p, int eStmt, sqlite3_stmt*);
-
-static int sqlite3Fts5StorageDocsize(Fts5Storage *p, i64 iRowid, int *aCol);
-static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnAvg);
-static int sqlite3Fts5StorageRowCount(Fts5Storage *p, i64 *pnRow);
-
-static int sqlite3Fts5StorageSync(Fts5Storage *p);
-static int sqlite3Fts5StorageRollback(Fts5Storage *p);
-
-static int sqlite3Fts5StorageConfigValue(
-    Fts5Storage *p, const char*, sqlite3_value*, int
-);
-
-static int sqlite3Fts5StorageDeleteAll(Fts5Storage *p);
-static int sqlite3Fts5StorageRebuild(Fts5Storage *p);
-static int sqlite3Fts5StorageOptimize(Fts5Storage *p);
-static int sqlite3Fts5StorageMerge(Fts5Storage *p, int nMerge);
-static int sqlite3Fts5StorageReset(Fts5Storage *p);
-
-static void sqlite3Fts5StorageReleaseDeleteRow(Fts5Storage*);
-static int sqlite3Fts5StorageFindDeleteRow(Fts5Storage *p, i64 iDel);
-
-/*
-** End of interface to code in fts5_storage.c.
-**************************************************************************/
-
-
-/**************************************************************************
-** Interface to code in fts5_expr.c.
-*/
-typedef struct Fts5Expr Fts5Expr;
-typedef struct Fts5ExprNode Fts5ExprNode;
-typedef struct Fts5Parse Fts5Parse;
-typedef struct Fts5Token Fts5Token;
-typedef struct Fts5ExprPhrase Fts5ExprPhrase;
-typedef struct Fts5ExprNearset Fts5ExprNearset;
-
-struct Fts5Token {
-  const char *p;                  /* Token text (not NULL terminated) */
-  int n;                          /* Size of buffer p in bytes */
-};
-
-/* Parse a MATCH expression. */
-static int sqlite3Fts5ExprNew(
-  Fts5Config *pConfig,
-  int bPhraseToAnd,
-  int iCol,                       /* Column on LHS of MATCH operator */
-  const char *zExpr,
-  Fts5Expr **ppNew,
-  char **pzErr
-);
-static int sqlite3Fts5ExprPattern(
-  Fts5Config *pConfig,
-  int bGlob,
-  int iCol,
-  const char *zText,
-  Fts5Expr **pp
-);
-
-/*
-** for(rc = sqlite3Fts5ExprFirst(pExpr, pIdx, bDesc);
-**     rc==SQLITE_OK && 0==sqlite3Fts5ExprEof(pExpr);
-**     rc = sqlite3Fts5ExprNext(pExpr)
-** ){
-**   // The document with rowid iRowid matches the expression!
-**   i64 iRowid = sqlite3Fts5ExprRowid(pExpr);
-** }
-*/
-static int sqlite3Fts5ExprFirst(Fts5Expr*, Fts5Index *pIdx, i64 iMin, i64, int bDesc);
-static int sqlite3Fts5ExprNext(Fts5Expr*, i64 iMax);
-static int sqlite3Fts5ExprEof(Fts5Expr*);
-static i64 sqlite3Fts5ExprRowid(Fts5Expr*);
-
-static void sqlite3Fts5ExprFree(Fts5Expr*);
-static int sqlite3Fts5ExprAnd(Fts5Expr **pp1, Fts5Expr *p2);
-
-/* Called during startup to register a UDF with SQLite */
-static int sqlite3Fts5ExprInit(Fts5Global*, sqlite3*);
-
-static int sqlite3Fts5ExprPhraseCount(Fts5Expr*);
-static int sqlite3Fts5ExprPhraseSize(Fts5Expr*, int iPhrase);
-static int sqlite3Fts5ExprPoslist(Fts5Expr*, int, const u8 **);
-
-typedef struct Fts5PoslistPopulator Fts5PoslistPopulator;
-static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr*, int);
-static int sqlite3Fts5ExprPopulatePoslists(
-    Fts5Config*, Fts5Expr*, Fts5PoslistPopulator*, int, const char*, int
-);
-static void sqlite3Fts5ExprCheckPoslists(Fts5Expr*, i64);
-
-static int sqlite3Fts5ExprClonePhrase(Fts5Expr*, int, Fts5Expr**);
-
-static int sqlite3Fts5ExprPhraseCollist(Fts5Expr *, int, const u8 **, int *);
-
-static int sqlite3Fts5ExprQueryToken(Fts5Expr*, int, int, const char**, int*);
-static int sqlite3Fts5ExprInstToken(Fts5Expr*, i64, int, int, int, int, const char**, int*);
-static void sqlite3Fts5ExprClearTokens(Fts5Expr*);
-
-/*******************************************
-** The fts5_expr.c API above this point is used by the other hand-written
-** C code in this module. The interfaces below this point are called by
-** the parser code in fts5parse.y.  */
-
-static void sqlite3Fts5ParseError(Fts5Parse *pParse, const char *zFmt, ...);
-
-static Fts5ExprNode *sqlite3Fts5ParseNode(
-  Fts5Parse *pParse,
-  int eType,
-  Fts5ExprNode *pLeft,
-  Fts5ExprNode *pRight,
-  Fts5ExprNearset *pNear
-);
-
-static Fts5ExprNode *sqlite3Fts5ParseImplicitAnd(
-  Fts5Parse *pParse,
-  Fts5ExprNode *pLeft,
-  Fts5ExprNode *pRight
-);
-
-static Fts5ExprPhrase *sqlite3Fts5ParseTerm(
-  Fts5Parse *pParse,
-  Fts5ExprPhrase *pPhrase,
-  Fts5Token *pToken,
-  int bPrefix
-);
-
-static void sqlite3Fts5ParseSetCaret(Fts5ExprPhrase*);
-
-static Fts5ExprNearset *sqlite3Fts5ParseNearset(
-  Fts5Parse*,
-  Fts5ExprNearset*,
-  Fts5ExprPhrase*
-);
-
-static Fts5Colset *sqlite3Fts5ParseColset(
-  Fts5Parse*,
-  Fts5Colset*,
-  Fts5Token *
-);
-
-static void sqlite3Fts5ParsePhraseFree(Fts5ExprPhrase*);
-static void sqlite3Fts5ParseNearsetFree(Fts5ExprNearset*);
-static void sqlite3Fts5ParseNodeFree(Fts5ExprNode*);
-
-static void sqlite3Fts5ParseSetDistance(Fts5Parse*, Fts5ExprNearset*, Fts5Token*);
-static void sqlite3Fts5ParseSetColset(Fts5Parse*, Fts5ExprNode*, Fts5Colset*);
-static Fts5Colset *sqlite3Fts5ParseColsetInvert(Fts5Parse*, Fts5Colset*);
-static void sqlite3Fts5ParseFinished(Fts5Parse *pParse, Fts5ExprNode *p);
-static void sqlite3Fts5ParseNear(Fts5Parse *pParse, Fts5Token*);
-
-/*
-** End of interface to code in fts5_expr.c.
-**************************************************************************/
-
-
-
-/**************************************************************************
-** Interface to code in fts5_aux.c.
-*/
-
-static int sqlite3Fts5AuxInit(fts5_api*);
-/*
-** End of interface to code in fts5_aux.c.
-**************************************************************************/
-
-/**************************************************************************
-** Interface to code in fts5_tokenizer.c.
-*/
-
-static int sqlite3Fts5TokenizerInit(fts5_api*);
-static int sqlite3Fts5TokenizerPattern(
-    int (*xCreate)(void*, const char**, int, Fts5Tokenizer**),
-    Fts5Tokenizer *pTok
-);
-static int sqlite3Fts5TokenizerPreload(Fts5TokenizerConfig*);
-/*
-** End of interface to code in fts5_tokenizer.c.
-**************************************************************************/
-
-/**************************************************************************
-** Interface to code in fts5_vocab.c.
-*/
-
-static int sqlite3Fts5VocabInit(Fts5Global*, sqlite3*);
-
-/*
-** End of interface to code in fts5_vocab.c.
-**************************************************************************/
-
-
-/**************************************************************************
-** Interface to automatically generated code in fts5_unicode2.c.
-*/
-static int sqlite3Fts5UnicodeIsdiacritic(int c);
-static int sqlite3Fts5UnicodeFold(int c, int bRemoveDiacritic);
-
-static int sqlite3Fts5UnicodeCatParse(const char*, u8*);
-static int sqlite3Fts5UnicodeCategory(u32 iCode);
-static void sqlite3Fts5UnicodeAscii(u8*, u8*);
-/*
-** End of interface to code in fts5_unicode2.c.
-**************************************************************************/
-
-#endif
-
-#define FTS5_OR                               1
-#define FTS5_AND                              2
-#define FTS5_NOT                              3
-#define FTS5_TERM                             4
-#define FTS5_COLON                            5
-#define FTS5_MINUS                            6
-#define FTS5_LCP                              7
-#define FTS5_RCP                              8
-#define FTS5_STRING                           9
-#define FTS5_LP                              10
-#define FTS5_RP                              11
-#define FTS5_CARET                           12
-#define FTS5_COMMA                           13
-#define FTS5_PLUS                            14
-#define FTS5_STAR                            15
-
-/* This file is automatically generated by Lemon from input grammar
-** source file "fts5parse.y".
-*/
-/*
-** 2000-05-29
-**
-** 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.
-**
-*************************************************************************
-** Driver template for the LEMON parser generator.
-**
-** The "lemon" program processes an LALR(1) input grammar file, then uses
-** this template to construct a parser.  The "lemon" program inserts text
-** at each "%%" line.  Also, any "P-a-r-s-e" identifier prefix (without the
-** interstitial "-" characters) contained in this template is changed into
-** the value of the %name directive from the grammar.  Otherwise, the content
-** of this template is copied straight through into the generate parser
-** source file.
-**
-** The following is the concatenation of all %include directives from the
-** input grammar file:
-*/
-/************ Begin %include sections from the grammar ************************/
-
-/* #include "fts5Int.h" */
-/* #include "fts5parse.h" */
-
-/*
-** Disable all error recovery processing in the parser push-down
-** automaton.
-*/
-#define fts5YYNOERRORRECOVERY 1
-
-/*
-** Make fts5yytestcase() the same as testcase()
-*/
-#define fts5yytestcase(X) testcase(X)
-
-/*
-** Indicate that sqlite3ParserFree() will never be called with a null
-** pointer.
-*/
-#define fts5YYPARSEFREENOTNULL 1
-
-/*
-** Alternative datatype for the argument to the malloc() routine passed
-** into sqlite3ParserAlloc().  The default is size_t.
-*/
-#define fts5YYMALLOCARGTYPE  u64
-
-/**************** End of %include directives **********************************/
-/* These constants specify the various numeric values for terminal symbols.
-***************** Begin token definitions *************************************/
-#ifndef FTS5_OR
-#define FTS5_OR                              1
-#define FTS5_AND                             2
-#define FTS5_NOT                             3
-#define FTS5_TERM                            4
-#define FTS5_COLON                           5
-#define FTS5_MINUS                           6
-#define FTS5_LCP                             7
-#define FTS5_RCP                             8
-#define FTS5_STRING                          9
-#define FTS5_LP                             10
-#define FTS5_RP                             11
-#define FTS5_CARET                          12
-#define FTS5_COMMA                          13
-#define FTS5_PLUS                           14
-#define FTS5_STAR                           15
-#endif
-/**************** End token definitions ***************************************/
-
-/* The next sections is a series of control #defines.
-** various aspects of the generated parser.
-**    fts5YYCODETYPE         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.
-**    fts5YYNOCODE           is a number of type fts5YYCODETYPE that is not used for
-**                       any terminal or nonterminal symbol.
-**    fts5YYFALLBACK         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.
-**    fts5YYACTIONTYPE       is the data type used for "action codes" - numbers
-**                       that indicate what to do in response to the next
-**                       token.
-**    sqlite3Fts5ParserFTS5TOKENTYPE     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.
-**    fts5YYMINORTYPE        is the data type used for all minor types.
-**                       This is typically a union of many types, one of
-**                       which is sqlite3Fts5ParserFTS5TOKENTYPE.  The entry in the union
-**                       for terminal symbols is called "fts5yy0".
-**    fts5YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
-**                       zero the stack is dynamically sized using realloc()
-**    sqlite3Fts5ParserARG_SDECL     A static variable declaration for the %extra_argument
-**    sqlite3Fts5ParserARG_PDECL     A parameter declaration for the %extra_argument
-**    sqlite3Fts5ParserARG_PARAM     Code to pass %extra_argument as a subroutine parameter
-**    sqlite3Fts5ParserARG_STORE     Code to store %extra_argument into fts5yypParser
-**    sqlite3Fts5ParserARG_FETCH     Code to extract %extra_argument from fts5yypParser
-**    sqlite3Fts5ParserCTX_*         As sqlite3Fts5ParserARG_ except for %extra_context
-**    fts5YYREALLOC          Name of the realloc() function to use
-**    fts5YYFREE             Name of the free() function to use
-**    fts5YYDYNSTACK         True if stack space should be extended on heap
-**    fts5YYERRORSYMBOL      is the code number of the error symbol.  If not
-**                       defined, then do no error processing.
-**    fts5YYNSTATE           the combined number of states.
-**    fts5YYNRULE            the number of rules in the grammar
-**    fts5YYNFTS5TOKEN           Number of terminal symbols
-**    fts5YY_MAX_SHIFT       Maximum value for shift actions
-**    fts5YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
-**    fts5YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
-**    fts5YY_ERROR_ACTION    The fts5yy_action[] code for syntax error
-**    fts5YY_ACCEPT_ACTION   The fts5yy_action[] code for accept
-**    fts5YY_NO_ACTION       The fts5yy_action[] code for no-op
-**    fts5YY_MIN_REDUCE      Minimum value for reduce actions
-**    fts5YY_MAX_REDUCE      Maximum value for reduce actions
-**    fts5YY_MIN_DSTRCTR     Minimum symbol value that has a destructor
-**    fts5YY_MAX_DSTRCTR     Maximum symbol value that has a destructor
-*/
-#ifndef INTERFACE
-# define INTERFACE 1
-#endif
-/************* Begin control #defines *****************************************/
-#define fts5YYCODETYPE unsigned char
-#define fts5YYNOCODE 27
-#define fts5YYACTIONTYPE unsigned char
-#define sqlite3Fts5ParserFTS5TOKENTYPE Fts5Token
-typedef union {
-  int fts5yyinit;
-  sqlite3Fts5ParserFTS5TOKENTYPE fts5yy0;
-  int fts5yy4;
-  Fts5Colset* fts5yy11;
-  Fts5ExprNode* fts5yy24;
-  Fts5ExprNearset* fts5yy46;
-  Fts5ExprPhrase* fts5yy53;
-} fts5YYMINORTYPE;
-#ifndef fts5YYSTACKDEPTH
-#define fts5YYSTACKDEPTH 100
-#endif
-#define sqlite3Fts5ParserARG_SDECL Fts5Parse *pParse;
-#define sqlite3Fts5ParserARG_PDECL ,Fts5Parse *pParse
-#define sqlite3Fts5ParserARG_PARAM ,pParse
-#define sqlite3Fts5ParserARG_FETCH Fts5Parse *pParse=fts5yypParser->pParse;
-#define sqlite3Fts5ParserARG_STORE fts5yypParser->pParse=pParse;
-#undef fts5YYREALLOC
-#define fts5YYREALLOC realloc
-#undef fts5YYFREE
-#define fts5YYFREE free
-#undef fts5YYDYNSTACK
-#define fts5YYDYNSTACK 0
-#undef fts5YYSIZELIMIT
-#define sqlite3Fts5ParserCTX(P) 0
-#define sqlite3Fts5ParserCTX_SDECL
-#define sqlite3Fts5ParserCTX_PDECL
-#define sqlite3Fts5ParserCTX_PARAM
-#define sqlite3Fts5ParserCTX_FETCH
-#define sqlite3Fts5ParserCTX_STORE
-#undef fts5YYERRORSYMBOL
-#undef fts5YYERRSYMDT
-#undef fts5YYFALLBACK
-#define fts5YYNSTATE             35
-#define fts5YYNRULE              28
-#define fts5YYNRULE_WITH_ACTION  28
-#define fts5YYNFTS5TOKEN             16
-#define fts5YY_MAX_SHIFT         34
-#define fts5YY_MIN_SHIFTREDUCE   52
-#define fts5YY_MAX_SHIFTREDUCE   79
-#define fts5YY_ERROR_ACTION      80
-#define fts5YY_ACCEPT_ACTION     81
-#define fts5YY_NO_ACTION         82
-#define fts5YY_MIN_REDUCE        83
-#define fts5YY_MAX_REDUCE        110
-#define fts5YY_MIN_DSTRCTR       16
-#define fts5YY_MAX_DSTRCTR       24
-/************* End control #defines *******************************************/
-#define fts5YY_NLOOKAHEAD ((int)(sizeof(fts5yy_lookahead)/sizeof(fts5yy_lookahead[0])))
-
-/* Define the fts5yytestcase() macro to be a no-op if is not already defined
-** otherwise.
-**
-** Applications can choose to define fts5yytestcase() in the %include section
-** to a macro that can assist in verifying code coverage.  For production
-** code the fts5yytestcase() macro should be turned off.  But it is useful
-** for testing.
-*/
-#ifndef fts5yytestcase
-# define fts5yytestcase(X)
-#endif
-
-/* Macro to determine if stack space has the ability to grow using
-** heap memory.
-*/
-#if fts5YYSTACKDEPTH<=0 || fts5YYDYNSTACK
-# define fts5YYGROWABLESTACK 1
-#else
-# define fts5YYGROWABLESTACK 0
-#endif
-
-/* Guarantee a minimum number of initial stack slots.
-*/
-#if fts5YYSTACKDEPTH<=0
-# undef fts5YYSTACKDEPTH
-# define fts5YYSTACKDEPTH 2  /* Need a minimum stack size */
-#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 <= fts5YY_MAX_SHIFT             Shift N.  That is, push the lookahead
-**                                      token onto the stack and goto state N.
-**
-**   N between fts5YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then
-**     and fts5YY_MAX_SHIFTREDUCE           reduce by rule N-fts5YY_MIN_SHIFTREDUCE.
-**
-**   N == fts5YY_ERROR_ACTION               A syntax error has occurred.
-**
-**   N == fts5YY_ACCEPT_ACTION              The parser accepts its input.
-**
-**   N == fts5YY_NO_ACTION                  No such action.  Denotes unused
-**                                      slots in the fts5yy_action[] table.
-**
-**   N between fts5YY_MIN_REDUCE            Reduce by rule N-fts5YY_MIN_REDUCE
-**     and fts5YY_MAX_REDUCE
-**
-** The action table is constructed as a single large table named fts5yy_action[].
-** Given state S and lookahead X, the action is computed as either:
-**
-**    (A)   N = fts5yy_action[ fts5yy_shift_ofst[S] + X ]
-**    (B)   N = fts5yy_default[S]
-**
-** The (A) formula is preferred.  The B formula is used instead if
-** fts5yy_lookahead[fts5yy_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 fts5yy_reduce_ofst[] array is used in place of
-** the fts5yy_shift_ofst[] array.
-**
-** The following are the tables generated in this section:
-**
-**  fts5yy_action[]        A single table containing all actions.
-**  fts5yy_lookahead[]     A table containing the lookahead for each entry in
-**                     fts5yy_action.  Used to detect hash collisions.
-**  fts5yy_shift_ofst[]    For each state, the offset into fts5yy_action for
-**                     shifting terminals.
-**  fts5yy_reduce_ofst[]   For each state, the offset into fts5yy_action for
-**                     shifting non-terminals after a reduce.
-**  fts5yy_default[]       Default action for each state.
-**
-*********** Begin parsing tables **********************************************/
-#define fts5YY_ACTTAB_COUNT (105)
-static const fts5YYACTIONTYPE fts5yy_action[] = {
- /*     0 */    81,   20,   96,    6,   28,   99,   98,   26,   26,   18,
- /*    10 */    96,    6,   28,   17,   98,   56,   26,   19,   96,    6,
- /*    20 */    28,   14,   98,   14,   26,   31,   92,   96,    6,   28,
- /*    30 */   108,   98,   25,   26,   21,   96,    6,   28,   78,   98,
- /*    40 */    58,   26,   29,   96,    6,   28,  107,   98,   22,   26,
- /*    50 */    24,   16,   12,   11,    1,   13,   13,   24,   16,   23,
- /*    60 */    11,   33,   34,   13,   97,    8,   27,   32,   98,    7,
- /*    70 */    26,    3,    4,    5,    3,    4,    5,    3,   83,    4,
- /*    80 */     5,    3,   63,    5,    3,   62,   12,    2,   86,   13,
- /*    90 */     9,   30,   10,   10,   54,   57,   75,   78,   78,   53,
- /*   100 */    57,   15,   82,   82,   71,
-};
-static const fts5YYCODETYPE fts5yy_lookahead[] = {
- /*     0 */    16,   17,   18,   19,   20,   22,   22,   24,   24,   17,
- /*    10 */    18,   19,   20,    7,   22,    9,   24,   17,   18,   19,
- /*    20 */    20,    9,   22,    9,   24,   13,   17,   18,   19,   20,
- /*    30 */    26,   22,   24,   24,   17,   18,   19,   20,   15,   22,
- /*    40 */     9,   24,   17,   18,   19,   20,   26,   22,   21,   24,
- /*    50 */     6,    7,    9,    9,   10,   12,   12,    6,    7,   21,
- /*    60 */     9,   24,   25,   12,   18,    5,   20,   14,   22,    5,
- /*    70 */    24,    3,    1,    2,    3,    1,    2,    3,    0,    1,
- /*    80 */     2,    3,   11,    2,    3,   11,    9,   10,    5,   12,
- /*    90 */    23,   24,   10,   10,    8,    9,    9,   15,   15,    8,
- /*   100 */     9,    9,   27,   27,   11,   27,   27,   27,   27,   27,
- /*   110 */    27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
- /*   120 */    27,
-};
-#define fts5YY_SHIFT_COUNT    (34)
-#define fts5YY_SHIFT_MIN      (0)
-#define fts5YY_SHIFT_MAX      (93)
-static const unsigned char fts5yy_shift_ofst[] = {
- /*     0 */    44,   44,   44,   44,   44,   44,   51,   77,   43,   12,
- /*    10 */    14,   83,   82,   14,   23,   23,   31,   31,   71,   74,
- /*    20 */    78,   81,   86,   91,    6,   53,   53,   60,   64,   68,
- /*    30 */    53,   87,   92,   53,   93,
-};
-#define fts5YY_REDUCE_COUNT (17)
-#define fts5YY_REDUCE_MIN   (-17)
-#define fts5YY_REDUCE_MAX   (67)
-static const signed char fts5yy_reduce_ofst[] = {
- /*     0 */   -16,   -8,    0,    9,   17,   25,   46,  -17,  -17,   37,
- /*    10 */    67,    4,    4,    8,    4,   20,   27,   38,
-};
-static const fts5YYACTIONTYPE fts5yy_default[] = {
- /*     0 */    80,   80,   80,   80,   80,   80,   95,   80,   80,  105,
- /*    10 */    80,  110,  110,   80,  110,  110,   80,   80,   80,   80,
- /*    20 */    80,   91,   80,   80,   80,  101,  100,   80,   80,   90,
- /*    30 */   103,   80,   80,  104,   80,
-};
-/********** 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 fts5YYFALLBACK
-static const fts5YYCODETYPE fts5yyFallback[] = {
-};
-#endif /* fts5YYFALLBACK */
-
-/* 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 fts5yyStackEntry {
-  fts5YYACTIONTYPE stateno;  /* The state-number, or reduce action in SHIFTREDUCE */
-  fts5YYCODETYPE major;      /* The major token value.  This is the code
-                         ** number for the token at this stack level */
-  fts5YYMINORTYPE minor;     /* The user-supplied minor token value.  This
-                         ** is the value of the token  */
-};
-typedef struct fts5yyStackEntry fts5yyStackEntry;
-
-/* The state of the parser is completely contained in an instance of
-** the following structure */
-struct fts5yyParser {
-  fts5yyStackEntry *fts5yytos;          /* Pointer to top element of the stack */
-#ifdef fts5YYTRACKMAXSTACKDEPTH
-  int fts5yyhwm;                    /* High-water mark of the stack */
-#endif
-#ifndef fts5YYNOERRORRECOVERY
-  int fts5yyerrcnt;                 /* Shifts left before out of the error */
-#endif
-  sqlite3Fts5ParserARG_SDECL                /* A place to hold %extra_argument */
-  sqlite3Fts5ParserCTX_SDECL                /* A place to hold %extra_context */
-  fts5yyStackEntry *fts5yystackEnd;           /* Last entry in the stack */
-  fts5yyStackEntry *fts5yystack;              /* The parser stack */
-  fts5yyStackEntry fts5yystk0[fts5YYSTACKDEPTH];  /* Initial stack space */
-};
-typedef struct fts5yyParser fts5yyParser;
-
-/* #include <assert.h> */
-#ifndef NDEBUG
-/* #include <stdio.h> */
-static FILE *fts5yyTraceFILE = 0;
-static char *fts5yyTracePrompt = 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:
-** <ul>
-** <li> A FILE* to which trace output should be written.
-**      If NULL, then tracing is turned off.
-** <li> A prefix string written at the beginning of every
-**      line of trace output.  If NULL, then tracing is
-**      turned off.
-** </ul>
-**
-** Outputs:
-** None.
-*/
-static void sqlite3Fts5ParserTrace(FILE *TraceFILE, char *zTracePrompt){
-  fts5yyTraceFILE = TraceFILE;
-  fts5yyTracePrompt = zTracePrompt;
-  if( fts5yyTraceFILE==0 ) fts5yyTracePrompt = 0;
-  else if( fts5yyTracePrompt==0 ) fts5yyTraceFILE = 0;
-}
-#endif /* NDEBUG */
-
-#if defined(fts5YYCOVERAGE) || !defined(NDEBUG)
-/* For tracing shifts, the names of all terminals and nonterminals
-** are required.  The following table supplies these names */
-static const char *const fts5yyTokenName[] = {
-  /*    0 */ "$",
-  /*    1 */ "OR",
-  /*    2 */ "AND",
-  /*    3 */ "NOT",
-  /*    4 */ "TERM",
-  /*    5 */ "COLON",
-  /*    6 */ "MINUS",
-  /*    7 */ "LCP",
-  /*    8 */ "RCP",
-  /*    9 */ "STRING",
-  /*   10 */ "LP",
-  /*   11 */ "RP",
-  /*   12 */ "CARET",
-  /*   13 */ "COMMA",
-  /*   14 */ "PLUS",
-  /*   15 */ "STAR",
-  /*   16 */ "input",
-  /*   17 */ "expr",
-  /*   18 */ "cnearset",
-  /*   19 */ "exprlist",
-  /*   20 */ "colset",
-  /*   21 */ "colsetlist",
-  /*   22 */ "nearset",
-  /*   23 */ "nearphrases",
-  /*   24 */ "phrase",
-  /*   25 */ "neardist_opt",
-  /*   26 */ "star_opt",
-};
-#endif /* defined(fts5YYCOVERAGE) || !defined(NDEBUG) */
-
-#ifndef NDEBUG
-/* For tracing reduce actions, the names of all rules are required.
-*/
-static const char *const fts5yyRuleName[] = {
- /*   0 */ "input ::= expr",
- /*   1 */ "colset ::= MINUS LCP colsetlist RCP",
- /*   2 */ "colset ::= LCP colsetlist RCP",
- /*   3 */ "colset ::= STRING",
- /*   4 */ "colset ::= MINUS STRING",
- /*   5 */ "colsetlist ::= colsetlist STRING",
- /*   6 */ "colsetlist ::= STRING",
- /*   7 */ "expr ::= expr AND expr",
- /*   8 */ "expr ::= expr OR expr",
- /*   9 */ "expr ::= expr NOT expr",
- /*  10 */ "expr ::= colset COLON LP expr RP",
- /*  11 */ "expr ::= LP expr RP",
- /*  12 */ "expr ::= exprlist",
- /*  13 */ "exprlist ::= cnearset",
- /*  14 */ "exprlist ::= exprlist cnearset",
- /*  15 */ "cnearset ::= nearset",
- /*  16 */ "cnearset ::= colset COLON nearset",
- /*  17 */ "nearset ::= phrase",
- /*  18 */ "nearset ::= CARET phrase",
- /*  19 */ "nearset ::= STRING LP nearphrases neardist_opt RP",
- /*  20 */ "nearphrases ::= phrase",
- /*  21 */ "nearphrases ::= nearphrases phrase",
- /*  22 */ "neardist_opt ::=",
- /*  23 */ "neardist_opt ::= COMMA STRING",
- /*  24 */ "phrase ::= phrase PLUS STRING star_opt",
- /*  25 */ "phrase ::= STRING star_opt",
- /*  26 */ "star_opt ::= STAR",
- /*  27 */ "star_opt ::=",
-};
-#endif /* NDEBUG */
-
-
-#if fts5YYGROWABLESTACK
-/*
-** Try to increase the size of the parser stack.  Return the number
-** of errors.  Return 0 on success.
-*/
-static int fts5yyGrowStack(fts5yyParser *p){
-  int oldSize = 1 + (int)(p->fts5yystackEnd - p->fts5yystack);
-  int newSize;
-  int idx;
-  fts5yyStackEntry *pNew;
-#ifdef fts5YYSIZELIMIT
-  int nLimit = fts5YYSIZELIMIT(sqlite3Fts5ParserCTX(p));
-#endif
-
-  newSize = oldSize*2 + 100;
-#ifdef fts5YYSIZELIMIT
-  if( newSize>nLimit ){
-    newSize = nLimit;
-    if( newSize<=oldSize ) return 1;
-  }
-#endif
-  idx = (int)(p->fts5yytos - p->fts5yystack);
-  if( p->fts5yystack==p->fts5yystk0 ){
-    pNew = fts5YYREALLOC(0, newSize*sizeof(pNew[0]), sqlite3Fts5ParserCTX(p));
-    if( pNew==0 ) return 1;
-    memcpy(pNew, p->fts5yystack, oldSize*sizeof(pNew[0]));
-  }else{
-    pNew = fts5YYREALLOC(p->fts5yystack, newSize*sizeof(pNew[0]), sqlite3Fts5ParserCTX(p));
-    if( pNew==0 ) return 1;
-  }
-  p->fts5yystack = pNew;
-  p->fts5yytos = &p->fts5yystack[idx];
-#ifndef NDEBUG
-  if( fts5yyTraceFILE ){
-    fprintf(fts5yyTraceFILE,"%sStack grows from %d to %d entries.\n",
-            fts5yyTracePrompt, oldSize, newSize);
-  }
-#endif
-  p->fts5yystackEnd = &p->fts5yystack[newSize-1];
-  return 0;
-}
-#endif /* fts5YYGROWABLESTACK */
-
-#if !fts5YYGROWABLESTACK
-/* For builds that do no have a growable stack, fts5yyGrowStack always
-** returns an error.
-*/
-# define fts5yyGrowStack(X) 1
-#endif
-
-/* Datatype of the argument to the memory allocated passed as the
-** second argument to sqlite3Fts5ParserAlloc() below.  This can be changed by
-** putting an appropriate #define in the %include section of the input
-** grammar.
-*/
-#ifndef fts5YYMALLOCARGTYPE
-# define fts5YYMALLOCARGTYPE size_t
-#endif
-
-/* Initialize a new parser that has already been allocated.
-*/
-static void sqlite3Fts5ParserInit(void *fts5yypRawParser sqlite3Fts5ParserCTX_PDECL){
-  fts5yyParser *fts5yypParser = (fts5yyParser*)fts5yypRawParser;
-  sqlite3Fts5ParserCTX_STORE
-#ifdef fts5YYTRACKMAXSTACKDEPTH
-  fts5yypParser->fts5yyhwm = 0;
-#endif
-  fts5yypParser->fts5yystack = fts5yypParser->fts5yystk0;
-  fts5yypParser->fts5yystackEnd = &fts5yypParser->fts5yystack[fts5YYSTACKDEPTH-1];
-#ifndef fts5YYNOERRORRECOVERY
-  fts5yypParser->fts5yyerrcnt = -1;
-#endif
-  fts5yypParser->fts5yytos = fts5yypParser->fts5yystack;
-  fts5yypParser->fts5yystack[0].stateno = 0;
-  fts5yypParser->fts5yystack[0].major = 0;
-}
-
-#ifndef sqlite3Fts5Parser_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 sqlite3Fts5Parser and sqlite3Fts5ParserFree.
-*/
-static void *sqlite3Fts5ParserAlloc(void *(*mallocProc)(fts5YYMALLOCARGTYPE) sqlite3Fts5ParserCTX_PDECL){
-  fts5yyParser *fts5yypParser;
-  fts5yypParser = (fts5yyParser*)(*mallocProc)( (fts5YYMALLOCARGTYPE)sizeof(fts5yyParser) );
-  if( fts5yypParser ){
-    sqlite3Fts5ParserCTX_STORE
-    sqlite3Fts5ParserInit(fts5yypParser sqlite3Fts5ParserCTX_PARAM);
-  }
-  return (void*)fts5yypParser;
-}
-#endif /* sqlite3Fts5Parser_ENGINEALWAYSONSTACK */
-
-
-/* The following function deletes the "minor type" or semantic value
-** associated with a symbol.  The symbol can be either a terminal
-** or nonterminal. "fts5yymajor" is the symbol code, and "fts5yypminor" 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 fts5yy_destructor(
-  fts5yyParser *fts5yypParser,    /* The parser */
-  fts5YYCODETYPE fts5yymajor,     /* Type code for object to destroy */
-  fts5YYMINORTYPE *fts5yypminor   /* The object to be destroyed */
-){
-  sqlite3Fts5ParserARG_FETCH
-  sqlite3Fts5ParserCTX_FETCH
-  switch( fts5yymajor ){
-    /* 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 16: /* input */
-{
- (void)pParse;
-}
-      break;
-    case 17: /* expr */
-    case 18: /* cnearset */
-    case 19: /* exprlist */
-{
- sqlite3Fts5ParseNodeFree((fts5yypminor->fts5yy24));
-}
-      break;
-    case 20: /* colset */
-    case 21: /* colsetlist */
-{
- sqlite3_free((fts5yypminor->fts5yy11));
-}
-      break;
-    case 22: /* nearset */
-    case 23: /* nearphrases */
-{
- sqlite3Fts5ParseNearsetFree((fts5yypminor->fts5yy46));
-}
-      break;
-    case 24: /* phrase */
-{
- sqlite3Fts5ParsePhraseFree((fts5yypminor->fts5yy53));
-}
-      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 fts5yy_pop_parser_stack(fts5yyParser *pParser){
-  fts5yyStackEntry *fts5yytos;
-  assert( pParser->fts5yytos!=0 );
-  assert( pParser->fts5yytos > pParser->fts5yystack );
-  fts5yytos = pParser->fts5yytos--;
-#ifndef NDEBUG
-  if( fts5yyTraceFILE ){
-    fprintf(fts5yyTraceFILE,"%sPopping %s\n",
-      fts5yyTracePrompt,
-      fts5yyTokenName[fts5yytos->major]);
-  }
-#endif
-  fts5yy_destructor(pParser, fts5yytos->major, &fts5yytos->minor);
-}
-
-/*
-** Clear all secondary memory allocations from the parser
-*/
-static void sqlite3Fts5ParserFinalize(void *p){
-  fts5yyParser *pParser = (fts5yyParser*)p;
-
-  /* In-lined version of calling fts5yy_pop_parser_stack() for each
-  ** element left in the stack */
-  fts5yyStackEntry *fts5yytos = pParser->fts5yytos;
-  while( fts5yytos>pParser->fts5yystack ){
-#ifndef NDEBUG
-    if( fts5yyTraceFILE ){
-      fprintf(fts5yyTraceFILE,"%sPopping %s\n",
-        fts5yyTracePrompt,
-        fts5yyTokenName[fts5yytos->major]);
-    }
-#endif
-    if( fts5yytos->major>=fts5YY_MIN_DSTRCTR ){
-      fts5yy_destructor(pParser, fts5yytos->major, &fts5yytos->minor);
-    }
-    fts5yytos--;
-  }
-
-#if fts5YYGROWABLESTACK
-  if( pParser->fts5yystack!=pParser->fts5yystk0 ){
-    fts5YYFREE(pParser->fts5yystack, sqlite3Fts5ParserCTX(pParser));
-  }
-#endif
-}
-
-#ifndef sqlite3Fts5Parser_ENGINEALWAYSONSTACK
-/*
-** Deallocate and destroy a parser.  Destructors are called for
-** all stack elements before shutting the parser down.
-**
-** If the fts5YYPARSEFREENEVERNULL 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.
-*/
-static void sqlite3Fts5ParserFree(
-  void *p,                    /* The parser to be deleted */
-  void (*freeProc)(void*)     /* Function used to reclaim memory */
-){
-#ifndef fts5YYPARSEFREENEVERNULL
-  if( p==0 ) return;
-#endif
-  sqlite3Fts5ParserFinalize(p);
-  (*freeProc)(p);
-}
-#endif /* sqlite3Fts5Parser_ENGINEALWAYSONSTACK */
-
-/*
-** Return the peak depth of the stack for a parser.
-*/
-#ifdef fts5YYTRACKMAXSTACKDEPTH
-static int sqlite3Fts5ParserStackPeak(void *p){
-  fts5yyParser *pParser = (fts5yyParser*)p;
-  return pParser->fts5yyhwm;
-}
-#endif
-
-/* This array of booleans keeps track of the parser statement
-** coverage.  The element fts5yycoverage[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(fts5YYCOVERAGE)
-static unsigned char fts5yycoverage[fts5YYNSTATE][fts5YYNFTS5TOKEN];
-#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(fts5YYCOVERAGE)
-static int sqlite3Fts5ParserCoverage(FILE *out){
-  int stateno, iLookAhead, i;
-  int nMissed = 0;
-  for(stateno=0; stateno<fts5YYNSTATE; stateno++){
-    i = fts5yy_shift_ofst[stateno];
-    for(iLookAhead=0; iLookAhead<fts5YYNFTS5TOKEN; iLookAhead++){
-      if( fts5yy_lookahead[i+iLookAhead]!=iLookAhead ) continue;
-      if( fts5yycoverage[stateno][iLookAhead]==0 ) nMissed++;
-      if( out ){
-        fprintf(out,"State %d lookahead %s %s\n", stateno,
-                fts5yyTokenName[iLookAhead],
-                fts5yycoverage[stateno][iLookAhead] ? "ok" : "missed");
-      }
-    }
-  }
-  return nMissed;
-}
-#endif
-
-/*
-** Find the appropriate action for a parser given the terminal
-** look-ahead token iLookAhead.
-*/
-static fts5YYACTIONTYPE fts5yy_find_shift_action(
-  fts5YYCODETYPE iLookAhead,    /* The look-ahead token */
-  fts5YYACTIONTYPE stateno      /* Current state number */
-){
-  int i;
-
-  if( stateno>fts5YY_MAX_SHIFT ) return stateno;
-  assert( stateno <= fts5YY_SHIFT_COUNT );
-#if defined(fts5YYCOVERAGE)
-  fts5yycoverage[stateno][iLookAhead] = 1;
-#endif
-  do{
-    i = fts5yy_shift_ofst[stateno];
-    assert( i>=0 );
-    assert( i<=fts5YY_ACTTAB_COUNT );
-    assert( i+fts5YYNFTS5TOKEN<=(int)fts5YY_NLOOKAHEAD );
-    assert( iLookAhead!=fts5YYNOCODE );
-    assert( iLookAhead < fts5YYNFTS5TOKEN );
-    i += iLookAhead;
-    assert( i<(int)fts5YY_NLOOKAHEAD );
-    if( fts5yy_lookahead[i]!=iLookAhead ){
-#ifdef fts5YYFALLBACK
-      fts5YYCODETYPE iFallback;            /* Fallback token */
-      assert( iLookAhead<sizeof(fts5yyFallback)/sizeof(fts5yyFallback[0]) );
-      iFallback = fts5yyFallback[iLookAhead];
-      if( iFallback!=0 ){
-#ifndef NDEBUG
-        if( fts5yyTraceFILE ){
-          fprintf(fts5yyTraceFILE, "%sFALLBACK %s => %s\n",
-             fts5yyTracePrompt, fts5yyTokenName[iLookAhead], fts5yyTokenName[iFallback]);
-        }
-#endif
-        assert( fts5yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
-        iLookAhead = iFallback;
-        continue;
-      }
-#endif
-#ifdef fts5YYWILDCARD
-      {
-        int j = i - iLookAhead + fts5YYWILDCARD;
-        assert( j<(int)(sizeof(fts5yy_lookahead)/sizeof(fts5yy_lookahead[0])) );
-        if( fts5yy_lookahead[j]==fts5YYWILDCARD && iLookAhead>0 ){
-#ifndef NDEBUG
-          if( fts5yyTraceFILE ){
-            fprintf(fts5yyTraceFILE, "%sWILDCARD %s => %s\n",
-               fts5yyTracePrompt, fts5yyTokenName[iLookAhead],
-               fts5yyTokenName[fts5YYWILDCARD]);
-          }
-#endif /* NDEBUG */
-          return fts5yy_action[j];
-        }
-      }
-#endif /* fts5YYWILDCARD */
-      return fts5yy_default[stateno];
-    }else{
-      assert( i>=0 && i<(int)(sizeof(fts5yy_action)/sizeof(fts5yy_action[0])) );
-      return fts5yy_action[i];
-    }
-  }while(1);
-}
-
-/*
-** Find the appropriate action for a parser given the non-terminal
-** look-ahead token iLookAhead.
-*/
-static fts5YYACTIONTYPE fts5yy_find_reduce_action(
-  fts5YYACTIONTYPE stateno,     /* Current state number */
-  fts5YYCODETYPE iLookAhead     /* The look-ahead token */
-){
-  int i;
-#ifdef fts5YYERRORSYMBOL
-  if( stateno>fts5YY_REDUCE_COUNT ){
-    return fts5yy_default[stateno];
-  }
-#else
-  assert( stateno<=fts5YY_REDUCE_COUNT );
-#endif
-  i = fts5yy_reduce_ofst[stateno];
-  assert( iLookAhead!=fts5YYNOCODE );
-  i += iLookAhead;
-#ifdef fts5YYERRORSYMBOL
-  if( i<0 || i>=fts5YY_ACTTAB_COUNT || fts5yy_lookahead[i]!=iLookAhead ){
-    return fts5yy_default[stateno];
-  }
-#else
-  assert( i>=0 && i<fts5YY_ACTTAB_COUNT );
-  assert( fts5yy_lookahead[i]==iLookAhead );
-#endif
-  return fts5yy_action[i];
-}
-
-/*
-** The following routine is called if the stack overflows.
-*/
-static void fts5yyStackOverflow(fts5yyParser *fts5yypParser){
-   sqlite3Fts5ParserARG_FETCH
-   sqlite3Fts5ParserCTX_FETCH
-#ifndef NDEBUG
-   if( fts5yyTraceFILE ){
-     fprintf(fts5yyTraceFILE,"%sStack Overflow!\n",fts5yyTracePrompt);
-   }
-#endif
-   while( fts5yypParser->fts5yytos>fts5yypParser->fts5yystack ) fts5yy_pop_parser_stack(fts5yypParser);
-   /* Here code is inserted which will execute if the parser
-   ** stack every overflows */
-/******** Begin %stack_overflow code ******************************************/
-
-  sqlite3Fts5ParseError(pParse, "fts5: parser stack overflow");
-/******** End %stack_overflow code ********************************************/
-   sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument var */
-   sqlite3Fts5ParserCTX_STORE
-}
-
-/*
-** Print tracing information for a SHIFT action
-*/
-#ifndef NDEBUG
-static void fts5yyTraceShift(fts5yyParser *fts5yypParser, int fts5yyNewState, const char *zTag){
-  if( fts5yyTraceFILE ){
-    if( fts5yyNewState<fts5YYNSTATE ){
-      fprintf(fts5yyTraceFILE,"%s%s '%s', go to state %d\n",
-         fts5yyTracePrompt, zTag, fts5yyTokenName[fts5yypParser->fts5yytos->major],
-         fts5yyNewState);
-    }else{
-      fprintf(fts5yyTraceFILE,"%s%s '%s', pending reduce %d\n",
-         fts5yyTracePrompt, zTag, fts5yyTokenName[fts5yypParser->fts5yytos->major],
-         fts5yyNewState - fts5YY_MIN_REDUCE);
-    }
-  }
-}
-#else
-# define fts5yyTraceShift(X,Y,Z)
-#endif
-
-/*
-** Perform a shift action.
-*/
-static void fts5yy_shift(
-  fts5yyParser *fts5yypParser,          /* The parser to be shifted */
-  fts5YYACTIONTYPE fts5yyNewState,      /* The new state to shift in */
-  fts5YYCODETYPE fts5yyMajor,           /* The major token to shift in */
-  sqlite3Fts5ParserFTS5TOKENTYPE fts5yyMinor        /* The minor token to shift in */
-){
-  fts5yyStackEntry *fts5yytos;
-  fts5yypParser->fts5yytos++;
-#ifdef fts5YYTRACKMAXSTACKDEPTH
-  if( (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack)>fts5yypParser->fts5yyhwm ){
-    fts5yypParser->fts5yyhwm++;
-    assert( fts5yypParser->fts5yyhwm == (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack) );
-  }
-#endif
-  fts5yytos = fts5yypParser->fts5yytos;
-  if( fts5yytos>fts5yypParser->fts5yystackEnd ){
-    if( fts5yyGrowStack(fts5yypParser) ){
-      fts5yypParser->fts5yytos--;
-      fts5yyStackOverflow(fts5yypParser);
-      return;
-    }
-    fts5yytos = fts5yypParser->fts5yytos;
-    assert( fts5yytos <= fts5yypParser->fts5yystackEnd );
-  }
-  if( fts5yyNewState > fts5YY_MAX_SHIFT ){
-    fts5yyNewState += fts5YY_MIN_REDUCE - fts5YY_MIN_SHIFTREDUCE;
-  }
-  fts5yytos->stateno = fts5yyNewState;
-  fts5yytos->major = fts5yyMajor;
-  fts5yytos->minor.fts5yy0 = fts5yyMinor;
-  fts5yyTraceShift(fts5yypParser, fts5yyNewState, "Shift");
-}
-
-/* For rule J, fts5yyRuleInfoLhs[J] contains the symbol on the left-hand side
-** of that rule */
-static const fts5YYCODETYPE fts5yyRuleInfoLhs[] = {
-    16,  /* (0) input ::= expr */
-    20,  /* (1) colset ::= MINUS LCP colsetlist RCP */
-    20,  /* (2) colset ::= LCP colsetlist RCP */
-    20,  /* (3) colset ::= STRING */
-    20,  /* (4) colset ::= MINUS STRING */
-    21,  /* (5) colsetlist ::= colsetlist STRING */
-    21,  /* (6) colsetlist ::= STRING */
-    17,  /* (7) expr ::= expr AND expr */
-    17,  /* (8) expr ::= expr OR expr */
-    17,  /* (9) expr ::= expr NOT expr */
-    17,  /* (10) expr ::= colset COLON LP expr RP */
-    17,  /* (11) expr ::= LP expr RP */
-    17,  /* (12) expr ::= exprlist */
-    19,  /* (13) exprlist ::= cnearset */
-    19,  /* (14) exprlist ::= exprlist cnearset */
-    18,  /* (15) cnearset ::= nearset */
-    18,  /* (16) cnearset ::= colset COLON nearset */
-    22,  /* (17) nearset ::= phrase */
-    22,  /* (18) nearset ::= CARET phrase */
-    22,  /* (19) nearset ::= STRING LP nearphrases neardist_opt RP */
-    23,  /* (20) nearphrases ::= phrase */
-    23,  /* (21) nearphrases ::= nearphrases phrase */
-    25,  /* (22) neardist_opt ::= */
-    25,  /* (23) neardist_opt ::= COMMA STRING */
-    24,  /* (24) phrase ::= phrase PLUS STRING star_opt */
-    24,  /* (25) phrase ::= STRING star_opt */
-    26,  /* (26) star_opt ::= STAR */
-    26,  /* (27) star_opt ::= */
-};
-
-/* For rule J, fts5yyRuleInfoNRhs[J] contains the negative of the number
-** of symbols on the right-hand side of that rule. */
-static const signed char fts5yyRuleInfoNRhs[] = {
-   -1,  /* (0) input ::= expr */
-   -4,  /* (1) colset ::= MINUS LCP colsetlist RCP */
-   -3,  /* (2) colset ::= LCP colsetlist RCP */
-   -1,  /* (3) colset ::= STRING */
-   -2,  /* (4) colset ::= MINUS STRING */
-   -2,  /* (5) colsetlist ::= colsetlist STRING */
-   -1,  /* (6) colsetlist ::= STRING */
-   -3,  /* (7) expr ::= expr AND expr */
-   -3,  /* (8) expr ::= expr OR expr */
-   -3,  /* (9) expr ::= expr NOT expr */
-   -5,  /* (10) expr ::= colset COLON LP expr RP */
-   -3,  /* (11) expr ::= LP expr RP */
-   -1,  /* (12) expr ::= exprlist */
-   -1,  /* (13) exprlist ::= cnearset */
-   -2,  /* (14) exprlist ::= exprlist cnearset */
-   -1,  /* (15) cnearset ::= nearset */
-   -3,  /* (16) cnearset ::= colset COLON nearset */
-   -1,  /* (17) nearset ::= phrase */
-   -2,  /* (18) nearset ::= CARET phrase */
-   -5,  /* (19) nearset ::= STRING LP nearphrases neardist_opt RP */
-   -1,  /* (20) nearphrases ::= phrase */
-   -2,  /* (21) nearphrases ::= nearphrases phrase */
-    0,  /* (22) neardist_opt ::= */
-   -2,  /* (23) neardist_opt ::= COMMA STRING */
-   -4,  /* (24) phrase ::= phrase PLUS STRING star_opt */
-   -2,  /* (25) phrase ::= STRING star_opt */
-   -1,  /* (26) star_opt ::= STAR */
-    0,  /* (27) star_opt ::= */
-};
-
-static void fts5yy_accept(fts5yyParser*);  /* Forward Declaration */
-
-/*
-** Perform a reduce action and the shift that must immediately
-** follow the reduce.
-**
-** The fts5yyLookahead and fts5yyLookaheadToken parameters provide reduce actions
-** access to the lookahead token (if any).  The fts5yyLookahead will be fts5YYNOCODE
-** 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 fts5YYACTIONTYPE fts5yy_reduce(
-  fts5yyParser *fts5yypParser,         /* The parser */
-  unsigned int fts5yyruleno,       /* Number of the rule by which to reduce */
-  int fts5yyLookahead,             /* Lookahead token, or fts5YYNOCODE if none */
-  sqlite3Fts5ParserFTS5TOKENTYPE fts5yyLookaheadToken  /* Value of the lookahead token */
-  sqlite3Fts5ParserCTX_PDECL                   /* %extra_context */
-){
-  int fts5yygoto;                     /* The next state */
-  fts5YYACTIONTYPE fts5yyact;             /* The next action */
-  fts5yyStackEntry *fts5yymsp;            /* The top of the parser's stack */
-  int fts5yysize;                     /* Amount to pop the stack */
-  sqlite3Fts5ParserARG_FETCH
-  (void)fts5yyLookahead;
-  (void)fts5yyLookaheadToken;
-  fts5yymsp = fts5yypParser->fts5yytos;
-
-  switch( fts5yyruleno ){
-  /* Beginning here are the reduction cases.  A typical example
-  ** follows:
-  **   case 0:
-  **  #line <lineno> <grammarfile>
-  **     { ... }           // User supplied code
-  **  #line <lineno> <thisfile>
-  **     break;
-  */
-/********** Begin reduce actions **********************************************/
-        fts5YYMINORTYPE fts5yylhsminor;
-      case 0: /* input ::= expr */
-{ sqlite3Fts5ParseFinished(pParse, fts5yymsp[0].minor.fts5yy24); }
-        break;
-      case 1: /* colset ::= MINUS LCP colsetlist RCP */
-{
-    fts5yymsp[-3].minor.fts5yy11 = sqlite3Fts5ParseColsetInvert(pParse, fts5yymsp[-1].minor.fts5yy11);
-}
-        break;
-      case 2: /* colset ::= LCP colsetlist RCP */
-{ fts5yymsp[-2].minor.fts5yy11 = fts5yymsp[-1].minor.fts5yy11; }
-        break;
-      case 3: /* colset ::= STRING */
-{
-  fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0);
-}
-  fts5yymsp[0].minor.fts5yy11 = fts5yylhsminor.fts5yy11;
-        break;
-      case 4: /* colset ::= MINUS STRING */
-{
-  fts5yymsp[-1].minor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0);
-  fts5yymsp[-1].minor.fts5yy11 = sqlite3Fts5ParseColsetInvert(pParse, fts5yymsp[-1].minor.fts5yy11);
-}
-        break;
-      case 5: /* colsetlist ::= colsetlist STRING */
-{
-  fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, fts5yymsp[-1].minor.fts5yy11, &fts5yymsp[0].minor.fts5yy0); }
-  fts5yymsp[-1].minor.fts5yy11 = fts5yylhsminor.fts5yy11;
-        break;
-      case 6: /* colsetlist ::= STRING */
-{
-  fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0);
-}
-  fts5yymsp[0].minor.fts5yy11 = fts5yylhsminor.fts5yy11;
-        break;
-      case 7: /* expr ::= expr AND expr */
-{
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_AND, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0);
-}
-  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
-        break;
-      case 8: /* expr ::= expr OR expr */
-{
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_OR, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0);
-}
-  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
-        break;
-      case 9: /* expr ::= expr NOT expr */
-{
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_NOT, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0);
-}
-  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
-        break;
-      case 10: /* expr ::= colset COLON LP expr RP */
-{
-  sqlite3Fts5ParseSetColset(pParse, fts5yymsp[-1].minor.fts5yy24, fts5yymsp[-4].minor.fts5yy11);
-  fts5yylhsminor.fts5yy24 = fts5yymsp[-1].minor.fts5yy24;
-}
-  fts5yymsp[-4].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
-        break;
-      case 11: /* expr ::= LP expr RP */
-{fts5yymsp[-2].minor.fts5yy24 = fts5yymsp[-1].minor.fts5yy24;}
-        break;
-      case 12: /* expr ::= exprlist */
-      case 13: /* exprlist ::= cnearset */ fts5yytestcase(fts5yyruleno==13);
-{fts5yylhsminor.fts5yy24 = fts5yymsp[0].minor.fts5yy24;}
-  fts5yymsp[0].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
-        break;
-      case 14: /* exprlist ::= exprlist cnearset */
-{
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseImplicitAnd(pParse, fts5yymsp[-1].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24);
-}
-  fts5yymsp[-1].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
-        break;
-      case 15: /* cnearset ::= nearset */
-{
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_STRING, 0, 0, fts5yymsp[0].minor.fts5yy46);
-}
-  fts5yymsp[0].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
-        break;
-      case 16: /* cnearset ::= colset COLON nearset */
-{
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_STRING, 0, 0, fts5yymsp[0].minor.fts5yy46);
-  sqlite3Fts5ParseSetColset(pParse, fts5yylhsminor.fts5yy24, fts5yymsp[-2].minor.fts5yy11);
-}
-  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
-        break;
-      case 17: /* nearset ::= phrase */
-{ fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53); }
-  fts5yymsp[0].minor.fts5yy46 = fts5yylhsminor.fts5yy46;
-        break;
-      case 18: /* nearset ::= CARET phrase */
-{
-  sqlite3Fts5ParseSetCaret(fts5yymsp[0].minor.fts5yy53);
-  fts5yymsp[-1].minor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53);
-}
-        break;
-      case 19: /* nearset ::= STRING LP nearphrases neardist_opt RP */
-{
-  sqlite3Fts5ParseNear(pParse, &fts5yymsp[-4].minor.fts5yy0);
-  sqlite3Fts5ParseSetDistance(pParse, fts5yymsp[-2].minor.fts5yy46, &fts5yymsp[-1].minor.fts5yy0);
-  fts5yylhsminor.fts5yy46 = fts5yymsp[-2].minor.fts5yy46;
-}
-  fts5yymsp[-4].minor.fts5yy46 = fts5yylhsminor.fts5yy46;
-        break;
-      case 20: /* nearphrases ::= phrase */
-{
-  fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53);
-}
-  fts5yymsp[0].minor.fts5yy46 = fts5yylhsminor.fts5yy46;
-        break;
-      case 21: /* nearphrases ::= nearphrases phrase */
-{
-  fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, fts5yymsp[-1].minor.fts5yy46, fts5yymsp[0].minor.fts5yy53);
-}
-  fts5yymsp[-1].minor.fts5yy46 = fts5yylhsminor.fts5yy46;
-        break;
-      case 22: /* neardist_opt ::= */
-{ fts5yymsp[1].minor.fts5yy0.p = 0; fts5yymsp[1].minor.fts5yy0.n = 0; }
-        break;
-      case 23: /* neardist_opt ::= COMMA STRING */
-{ fts5yymsp[-1].minor.fts5yy0 = fts5yymsp[0].minor.fts5yy0; }
-        break;
-      case 24: /* phrase ::= phrase PLUS STRING star_opt */
-{
-  fts5yylhsminor.fts5yy53 = sqlite3Fts5ParseTerm(pParse, fts5yymsp[-3].minor.fts5yy53, &fts5yymsp[-1].minor.fts5yy0, fts5yymsp[0].minor.fts5yy4);
-}
-  fts5yymsp[-3].minor.fts5yy53 = fts5yylhsminor.fts5yy53;
-        break;
-      case 25: /* phrase ::= STRING star_opt */
-{
-  fts5yylhsminor.fts5yy53 = sqlite3Fts5ParseTerm(pParse, 0, &fts5yymsp[-1].minor.fts5yy0, fts5yymsp[0].minor.fts5yy4);
-}
-  fts5yymsp[-1].minor.fts5yy53 = fts5yylhsminor.fts5yy53;
-        break;
-      case 26: /* star_opt ::= STAR */
-{ fts5yymsp[0].minor.fts5yy4 = 1; }
-        break;
-      case 27: /* star_opt ::= */
-{ fts5yymsp[1].minor.fts5yy4 = 0; }
-        break;
-      default:
-        break;
-/********** End reduce actions ************************************************/
-  };
-  assert( fts5yyruleno<sizeof(fts5yyRuleInfoLhs)/sizeof(fts5yyRuleInfoLhs[0]) );
-  fts5yygoto = fts5yyRuleInfoLhs[fts5yyruleno];
-  fts5yysize = fts5yyRuleInfoNRhs[fts5yyruleno];
-  fts5yyact = fts5yy_find_reduce_action(fts5yymsp[fts5yysize].stateno,(fts5YYCODETYPE)fts5yygoto);
-
-  /* There are no SHIFTREDUCE actions on nonterminals because the table
-  ** generator has simplified them to pure REDUCE actions. */
-  assert( !(fts5yyact>fts5YY_MAX_SHIFT && fts5yyact<=fts5YY_MAX_SHIFTREDUCE) );
-
-  /* It is not possible for a REDUCE to be followed by an error */
-  assert( fts5yyact!=fts5YY_ERROR_ACTION );
-
-  fts5yymsp += fts5yysize+1;
-  fts5yypParser->fts5yytos = fts5yymsp;
-  fts5yymsp->stateno = (fts5YYACTIONTYPE)fts5yyact;
-  fts5yymsp->major = (fts5YYCODETYPE)fts5yygoto;
-  fts5yyTraceShift(fts5yypParser, fts5yyact, "... then shift");
-  return fts5yyact;
-}
-
-/*
-** The following code executes when the parse fails
-*/
-#ifndef fts5YYNOERRORRECOVERY
-static void fts5yy_parse_failed(
-  fts5yyParser *fts5yypParser           /* The parser */
-){
-  sqlite3Fts5ParserARG_FETCH
-  sqlite3Fts5ParserCTX_FETCH
-#ifndef NDEBUG
-  if( fts5yyTraceFILE ){
-    fprintf(fts5yyTraceFILE,"%sFail!\n",fts5yyTracePrompt);
-  }
-#endif
-  while( fts5yypParser->fts5yytos>fts5yypParser->fts5yystack ) fts5yy_pop_parser_stack(fts5yypParser);
-  /* Here code is inserted which will be executed whenever the
-  ** parser fails */
-/************ Begin %parse_failure code ***************************************/
-/************ End %parse_failure code *****************************************/
-  sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
-  sqlite3Fts5ParserCTX_STORE
-}
-#endif /* fts5YYNOERRORRECOVERY */
-
-/*
-** The following code executes when a syntax error first occurs.
-*/
-static void fts5yy_syntax_error(
-  fts5yyParser *fts5yypParser,           /* The parser */
-  int fts5yymajor,                   /* The major type of the error token */
-  sqlite3Fts5ParserFTS5TOKENTYPE fts5yyminor         /* The minor type of the error token */
-){
-  sqlite3Fts5ParserARG_FETCH
-  sqlite3Fts5ParserCTX_FETCH
-#define FTS5TOKEN fts5yyminor
-/************ Begin %syntax_error code ****************************************/
-
-  UNUSED_PARAM(fts5yymajor); /* Silence a compiler warning */
-  sqlite3Fts5ParseError(
-    pParse, "fts5: syntax error near \"%.*s\"",FTS5TOKEN.n,FTS5TOKEN.p
-  );
-/************ End %syntax_error code ******************************************/
-  sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
-  sqlite3Fts5ParserCTX_STORE
-}
-
-/*
-** The following is executed when the parser accepts
-*/
-static void fts5yy_accept(
-  fts5yyParser *fts5yypParser           /* The parser */
-){
-  sqlite3Fts5ParserARG_FETCH
-  sqlite3Fts5ParserCTX_FETCH
-#ifndef NDEBUG
-  if( fts5yyTraceFILE ){
-    fprintf(fts5yyTraceFILE,"%sAccept!\n",fts5yyTracePrompt);
-  }
-#endif
-#ifndef fts5YYNOERRORRECOVERY
-  fts5yypParser->fts5yyerrcnt = -1;
-#endif
-  assert( fts5yypParser->fts5yytos==fts5yypParser->fts5yystack );
-  /* Here code is inserted which will be executed whenever the
-  ** parser accepts */
-/*********** Begin %parse_accept code *****************************************/
-/*********** End %parse_accept code *******************************************/
-  sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
-  sqlite3Fts5ParserCTX_STORE
-}
-
-/* The main parser program.
-** The first argument is a pointer to a structure obtained from
-** "sqlite3Fts5ParserAlloc" 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:
-** <ul>
-** <li> A pointer to the parser (an opaque structure.)
-** <li> The major token number.
-** <li> The minor token number.
-** <li> An option argument of a grammar-specified type.
-** </ul>
-**
-** Outputs:
-** None.
-*/
-static void sqlite3Fts5Parser(
-  void *fts5yyp,                   /* The parser */
-  int fts5yymajor,                 /* The major token code number */
-  sqlite3Fts5ParserFTS5TOKENTYPE fts5yyminor       /* The value for the token */
-  sqlite3Fts5ParserARG_PDECL               /* Optional %extra_argument parameter */
-){
-  fts5YYMINORTYPE fts5yyminorunion;
-  fts5YYACTIONTYPE fts5yyact;   /* The parser action. */
-#if !defined(fts5YYERRORSYMBOL) && !defined(fts5YYNOERRORRECOVERY)
-  int fts5yyendofinput;     /* True if we are at the end of input */
-#endif
-#ifdef fts5YYERRORSYMBOL
-  int fts5yyerrorhit = 0;   /* True if fts5yymajor has invoked an error */
-#endif
-  fts5yyParser *fts5yypParser = (fts5yyParser*)fts5yyp;  /* The parser */
-  sqlite3Fts5ParserCTX_FETCH
-  sqlite3Fts5ParserARG_STORE
-
-  assert( fts5yypParser->fts5yytos!=0 );
-#if !defined(fts5YYERRORSYMBOL) && !defined(fts5YYNOERRORRECOVERY)
-  fts5yyendofinput = (fts5yymajor==0);
-#endif
-
-  fts5yyact = fts5yypParser->fts5yytos->stateno;
-#ifndef NDEBUG
-  if( fts5yyTraceFILE ){
-    if( fts5yyact < fts5YY_MIN_REDUCE ){
-      fprintf(fts5yyTraceFILE,"%sInput '%s' in state %d\n",
-              fts5yyTracePrompt,fts5yyTokenName[fts5yymajor],fts5yyact);
-    }else{
-      fprintf(fts5yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
-              fts5yyTracePrompt,fts5yyTokenName[fts5yymajor],fts5yyact-fts5YY_MIN_REDUCE);
-    }
-  }
-#endif
-
-  while(1){ /* Exit by "break" */
-    assert( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystack );
-    assert( fts5yyact==fts5yypParser->fts5yytos->stateno );
-    fts5yyact = fts5yy_find_shift_action((fts5YYCODETYPE)fts5yymajor,fts5yyact);
-    if( fts5yyact >= fts5YY_MIN_REDUCE ){
-      unsigned int fts5yyruleno = fts5yyact - fts5YY_MIN_REDUCE; /* Reduce by this rule */
-#ifndef NDEBUG
-      assert( fts5yyruleno<(int)(sizeof(fts5yyRuleName)/sizeof(fts5yyRuleName[0])) );
-      if( fts5yyTraceFILE ){
-        int fts5yysize = fts5yyRuleInfoNRhs[fts5yyruleno];
-        if( fts5yysize ){
-          fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
-            fts5yyTracePrompt,
-            fts5yyruleno, fts5yyRuleName[fts5yyruleno],
-            fts5yyruleno<fts5YYNRULE_WITH_ACTION ? "" : " without external action",
-            fts5yypParser->fts5yytos[fts5yysize].stateno);
-        }else{
-          fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s.\n",
-            fts5yyTracePrompt, fts5yyruleno, fts5yyRuleName[fts5yyruleno],
-            fts5yyruleno<fts5YYNRULE_WITH_ACTION ? "" : " without external action");
-        }
-      }
-#endif /* NDEBUG */
-
-      /* Check that the stack is large enough to grow by a single entry
-      ** if the RHS of the rule is empty.  This ensures that there is room
-      ** enough on the stack to push the LHS value */
-      if( fts5yyRuleInfoNRhs[fts5yyruleno]==0 ){
-#ifdef fts5YYTRACKMAXSTACKDEPTH
-        if( (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack)>fts5yypParser->fts5yyhwm ){
-          fts5yypParser->fts5yyhwm++;
-          assert( fts5yypParser->fts5yyhwm ==
-                  (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack));
-        }
-#endif
-        if( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystackEnd ){
-          if( fts5yyGrowStack(fts5yypParser) ){
-            fts5yyStackOverflow(fts5yypParser);
-            break;
-          }
-        }
-      }
-      fts5yyact = fts5yy_reduce(fts5yypParser,fts5yyruleno,fts5yymajor,fts5yyminor sqlite3Fts5ParserCTX_PARAM);
-    }else if( fts5yyact <= fts5YY_MAX_SHIFTREDUCE ){
-      fts5yy_shift(fts5yypParser,fts5yyact,(fts5YYCODETYPE)fts5yymajor,fts5yyminor);
-#ifndef fts5YYNOERRORRECOVERY
-      fts5yypParser->fts5yyerrcnt--;
-#endif
-      break;
-    }else if( fts5yyact==fts5YY_ACCEPT_ACTION ){
-      fts5yypParser->fts5yytos--;
-      fts5yy_accept(fts5yypParser);
-      return;
-    }else{
-      assert( fts5yyact == fts5YY_ERROR_ACTION );
-      fts5yyminorunion.fts5yy0 = fts5yyminor;
-#ifdef fts5YYERRORSYMBOL
-      int fts5yymx;
-#endif
-#ifndef NDEBUG
-      if( fts5yyTraceFILE ){
-        fprintf(fts5yyTraceFILE,"%sSyntax Error!\n",fts5yyTracePrompt);
-      }
-#endif
-#ifdef fts5YYERRORSYMBOL
-      /* 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( fts5yypParser->fts5yyerrcnt<0 ){
-        fts5yy_syntax_error(fts5yypParser,fts5yymajor,fts5yyminor);
-      }
-      fts5yymx = fts5yypParser->fts5yytos->major;
-      if( fts5yymx==fts5YYERRORSYMBOL || fts5yyerrorhit ){
-#ifndef NDEBUG
-        if( fts5yyTraceFILE ){
-          fprintf(fts5yyTraceFILE,"%sDiscard input token %s\n",
-             fts5yyTracePrompt,fts5yyTokenName[fts5yymajor]);
-        }
-#endif
-        fts5yy_destructor(fts5yypParser, (fts5YYCODETYPE)fts5yymajor, &fts5yyminorunion);
-        fts5yymajor = fts5YYNOCODE;
-      }else{
-        while( fts5yypParser->fts5yytos > fts5yypParser->fts5yystack ){
-          fts5yyact = fts5yy_find_reduce_action(fts5yypParser->fts5yytos->stateno,
-                                        fts5YYERRORSYMBOL);
-          if( fts5yyact<=fts5YY_MAX_SHIFTREDUCE ) break;
-          fts5yy_pop_parser_stack(fts5yypParser);
-        }
-        if( fts5yypParser->fts5yytos <= fts5yypParser->fts5yystack || fts5yymajor==0 ){
-          fts5yy_destructor(fts5yypParser,(fts5YYCODETYPE)fts5yymajor,&fts5yyminorunion);
-          fts5yy_parse_failed(fts5yypParser);
-#ifndef fts5YYNOERRORRECOVERY
-          fts5yypParser->fts5yyerrcnt = -1;
-#endif
-          fts5yymajor = fts5YYNOCODE;
-        }else if( fts5yymx!=fts5YYERRORSYMBOL ){
-          fts5yy_shift(fts5yypParser,fts5yyact,fts5YYERRORSYMBOL,fts5yyminor);
-        }
-      }
-      fts5yypParser->fts5yyerrcnt = 3;
-      fts5yyerrorhit = 1;
-      if( fts5yymajor==fts5YYNOCODE ) break;
-      fts5yyact = fts5yypParser->fts5yytos->stateno;
-#elif defined(fts5YYNOERRORRECOVERY)
-      /* If the fts5YYNOERRORRECOVERY 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.
-      */
-      fts5yy_syntax_error(fts5yypParser,fts5yymajor, fts5yyminor);
-      fts5yy_destructor(fts5yypParser,(fts5YYCODETYPE)fts5yymajor,&fts5yyminorunion);
-      break;
-#else  /* fts5YYERRORSYMBOL 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( fts5yypParser->fts5yyerrcnt<=0 ){
-        fts5yy_syntax_error(fts5yypParser,fts5yymajor, fts5yyminor);
-      }
-      fts5yypParser->fts5yyerrcnt = 3;
-      fts5yy_destructor(fts5yypParser,(fts5YYCODETYPE)fts5yymajor,&fts5yyminorunion);
-      if( fts5yyendofinput ){
-        fts5yy_parse_failed(fts5yypParser);
-#ifndef fts5YYNOERRORRECOVERY
-        fts5yypParser->fts5yyerrcnt = -1;
-#endif
-      }
-      break;
-#endif
-    }
-  }
-#ifndef NDEBUG
-  if( fts5yyTraceFILE ){
-    fts5yyStackEntry *i;
-    char cDiv = '[';
-    fprintf(fts5yyTraceFILE,"%sReturn. Stack=",fts5yyTracePrompt);
-    for(i=&fts5yypParser->fts5yystack[1]; i<=fts5yypParser->fts5yytos; i++){
-      fprintf(fts5yyTraceFILE,"%c%s", cDiv, fts5yyTokenName[i->major]);
-      cDiv = ' ';
-    }
-    fprintf(fts5yyTraceFILE,"]\n");
-  }
-#endif
-  return;
-}
-
-/*
-** Return the fallback token corresponding to canonical token iToken, or
-** 0 if iToken has no fallback.
-*/
-static int sqlite3Fts5ParserFallback(int iToken){
-#ifdef fts5YYFALLBACK
-  assert( iToken<(int)(sizeof(fts5yyFallback)/sizeof(fts5yyFallback[0])) );
-  return fts5yyFallback[iToken];
-#else
-  (void)iToken;
-  return 0;
-#endif
-}
-
-/*
-** 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.
-**
-******************************************************************************
-*/
-
-
-/* #include "fts5Int.h" */
-#include <math.h>                 /* amalgamator: keep */
-
-/*
-** Object used to iterate through all "coalesced phrase instances" in
-** a single column of the current row. If the phrase instances in the
-** column being considered do not overlap, this object simply iterates
-** through them. Or, if they do overlap (share one or more tokens in
-** common), each set of overlapping instances is treated as a single
-** match. See documentation for the highlight() auxiliary function for
-** details.
-**
-** Usage is:
-**
-**   for(rc = fts5CInstIterNext(pApi, pFts, iCol, &iter);
-**      (rc==SQLITE_OK && 0==fts5CInstIterEof(&iter);
-**      rc = fts5CInstIterNext(&iter)
-**   ){
-**     printf("instance starts at %d, ends at %d\n", iter.iStart, iter.iEnd);
-**   }
-**
-*/
-typedef struct CInstIter CInstIter;
-struct CInstIter {
-  const Fts5ExtensionApi *pApi;   /* API offered by current FTS version */
-  Fts5Context *pFts;              /* First arg to pass to pApi functions */
-  int iCol;                       /* Column to search */
-  int iInst;                      /* Next phrase instance index */
-  int nInst;                      /* Total number of phrase instances */
-
-  /* Output variables */
-  int iStart;                     /* First token in coalesced phrase instance */
-  int iEnd;                       /* Last token in coalesced phrase instance */
-};
-
-/*
-** Advance the iterator to the next coalesced phrase instance. Return
-** an SQLite error code if an error occurs, or SQLITE_OK otherwise.
-*/
-static int fts5CInstIterNext(CInstIter *pIter){
-  int rc = SQLITE_OK;
-  pIter->iStart = -1;
-  pIter->iEnd = -1;
-
-  while( rc==SQLITE_OK && pIter->iInst<pIter->nInst ){
-    int ip; int ic; int io;
-    rc = pIter->pApi->xInst(pIter->pFts, pIter->iInst, &ip, &ic, &io);
-    if( rc==SQLITE_OK ){
-      if( ic==pIter->iCol ){
-        int iEnd = io - 1 + pIter->pApi->xPhraseSize(pIter->pFts, ip);
-        if( pIter->iStart<0 ){
-          pIter->iStart = io;
-          pIter->iEnd = iEnd;
-        }else if( io<=pIter->iEnd ){
-          if( iEnd>pIter->iEnd ) pIter->iEnd = iEnd;
-        }else{
-          break;
-        }
-      }
-      pIter->iInst++;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Initialize the iterator object indicated by the final parameter to
-** iterate through coalesced phrase instances in column iCol.
-*/
-static int fts5CInstIterInit(
-  const Fts5ExtensionApi *pApi,
-  Fts5Context *pFts,
-  int iCol,
-  CInstIter *pIter
-){
-  int rc;
-
-  memset(pIter, 0, sizeof(CInstIter));
-  pIter->pApi = pApi;
-  pIter->pFts = pFts;
-  pIter->iCol = iCol;
-  rc = pApi->xInstCount(pFts, &pIter->nInst);
-
-  if( rc==SQLITE_OK ){
-    rc = fts5CInstIterNext(pIter);
-  }
-
-  return rc;
-}
-
-
-
-/*************************************************************************
-** Start of highlight() implementation.
-*/
-typedef struct HighlightContext HighlightContext;
-struct HighlightContext {
-  /* Constant parameters to fts5HighlightCb() */
-  int iRangeStart;                /* First token to include */
-  int iRangeEnd;                  /* If non-zero, last token to include */
-  const char *zOpen;              /* Opening highlight */
-  const char *zClose;             /* Closing highlight */
-  const char *zIn;                /* Input text */
-  int nIn;                        /* Size of input text in bytes */
-
-  /* Variables modified by fts5HighlightCb() */
-  CInstIter iter;                 /* Coalesced Instance Iterator */
-  int iPos;                       /* Current token offset in zIn[] */
-  int iOff;                       /* Have copied up to this offset in zIn[] */
-  int bOpen;                      /* True if highlight is open */
-  char *zOut;                     /* Output value */
-};
-
-/*
-** Append text to the HighlightContext output string - p->zOut. Argument
-** z points to a buffer containing n bytes of text to append. If n is
-** negative, everything up until the first '\0' is appended to the output.
-**
-** If *pRc is set to any value other than SQLITE_OK when this function is
-** called, it is a no-op. If an error (i.e. an OOM condition) is encountered,
-** *pRc is set to an error code before returning.
-*/
-static void fts5HighlightAppend(
-  int *pRc,
-  HighlightContext *p,
-  const char *z, int n
-){
-  if( *pRc==SQLITE_OK && z ){
-    if( n<0 ) n = (int)strlen(z);
-    p->zOut = sqlite3_mprintf("%z%.*s", p->zOut, n, z);
-    if( p->zOut==0 ) *pRc = SQLITE_NOMEM;
-  }
-}
-
-/*
-** Tokenizer callback used by implementation of highlight() function.
-*/
-static int fts5HighlightCb(
-  void *pContext,                 /* Pointer to HighlightContext object */
-  int tflags,                     /* Mask of FTS5_TOKEN_* flags */
-  const char *pToken,             /* Buffer containing token */
-  int nToken,                     /* Size of token in bytes */
-  int iStartOff,                  /* Start byte offset of token */
-  int iEndOff                     /* End byte offset of token */
-){
-  HighlightContext *p = (HighlightContext*)pContext;
-  int rc = SQLITE_OK;
-  int iPos;
-
-  UNUSED_PARAM2(pToken, nToken);
-
-  if( tflags & FTS5_TOKEN_COLOCATED ) return SQLITE_OK;
-  iPos = p->iPos++;
-
-  if( p->iRangeEnd>=0 ){
-    if( iPos<p->iRangeStart || iPos>p->iRangeEnd ) return SQLITE_OK;
-    if( p->iRangeStart && iPos==p->iRangeStart ) p->iOff = iStartOff;
-  }
-
-  /* If the parenthesis is open, and this token is not part of the current
-  ** phrase, and the starting byte offset of this token is past the point
-  ** that has currently been copied into the output buffer, close the
-  ** parenthesis. */
-  if( p->bOpen
-   && (iPos<=p->iter.iStart || p->iter.iStart<0)
-   && iStartOff>p->iOff
-  ){
-    fts5HighlightAppend(&rc, p, p->zClose, -1);
-    p->bOpen = 0;
-  }
-
-  /* If this is the start of a new phrase, and the highlight is not open:
-  **
-  **   * copy text from the input up to the start of the phrase, and
-  **   * open the highlight.
-  */
-  if( iPos==p->iter.iStart && p->bOpen==0 ){
-    fts5HighlightAppend(&rc, p, &p->zIn[p->iOff], iStartOff - p->iOff);
-    fts5HighlightAppend(&rc, p, p->zOpen, -1);
-    p->iOff = iStartOff;
-    p->bOpen = 1;
-  }
-
-  if( iPos==p->iter.iEnd ){
-    if( p->bOpen==0 ){
-      assert( p->iRangeEnd>=0 );
-      fts5HighlightAppend(&rc, p, p->zOpen, -1);
-      p->bOpen = 1;
-    }
-    fts5HighlightAppend(&rc, p, &p->zIn[p->iOff], iEndOff - p->iOff);
-    p->iOff = iEndOff;
-
-    if( rc==SQLITE_OK ){
-      rc = fts5CInstIterNext(&p->iter);
-    }
-  }
-
-  if( iPos==p->iRangeEnd ){
-    if( p->bOpen ){
-      if( p->iter.iStart>=0 && iPos>=p->iter.iStart ){
-        fts5HighlightAppend(&rc, p, &p->zIn[p->iOff], iEndOff - p->iOff);
-        p->iOff = iEndOff;
-      }
-      fts5HighlightAppend(&rc, p, p->zClose, -1);
-      p->bOpen = 0;
-    }
-    fts5HighlightAppend(&rc, p, &p->zIn[p->iOff], iEndOff - p->iOff);
-    p->iOff = iEndOff;
-  }
-
-  return rc;
-}
-
-
-/*
-** Implementation of highlight() function.
-*/
-static void fts5HighlightFunction(
-  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 */
-){
-  HighlightContext ctx;
-  int rc;
-  int iCol;
-
-  if( nVal!=3 ){
-    const char *zErr = "wrong number of arguments to function highlight()";
-    sqlite3_result_error(pCtx, zErr, -1);
-    return;
-  }
-
-  iCol = sqlite3_value_int(apVal[0]);
-  memset(&ctx, 0, sizeof(HighlightContext));
-  ctx.zOpen = (const char*)sqlite3_value_text(apVal[1]);
-  ctx.zClose = (const char*)sqlite3_value_text(apVal[2]);
-  ctx.iRangeEnd = -1;
-  rc = pApi->xColumnText(pFts, iCol, &ctx.zIn, &ctx.nIn);
-  if( rc==SQLITE_RANGE ){
-    sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
-    rc = SQLITE_OK;
-  }else if( ctx.zIn ){
-    const char *pLoc = 0;         /* Locale of column iCol */
-    int nLoc = 0;                 /* Size of pLoc in bytes */
-    if( rc==SQLITE_OK ){
-      rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
-    }
-
-    if( rc==SQLITE_OK ){
-      rc = pApi->xColumnLocale(pFts, iCol, &pLoc, &nLoc);
-    }
-    if( rc==SQLITE_OK ){
-      rc = pApi->xTokenize_v2(
-          pFts, ctx.zIn, ctx.nIn, pLoc, nLoc, (void*)&ctx, fts5HighlightCb
-      );
-    }
-    if( ctx.bOpen ){
-      fts5HighlightAppend(&rc, &ctx, ctx.zClose, -1);
-    }
-    fts5HighlightAppend(&rc, &ctx, &ctx.zIn[ctx.iOff], ctx.nIn - ctx.iOff);
-
-    if( rc==SQLITE_OK ){
-      sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
-    }
-    sqlite3_free(ctx.zOut);
-  }
-  if( rc!=SQLITE_OK ){
-    sqlite3_result_error_code(pCtx, rc);
-  }
-}
-/*
-** End of highlight() implementation.
-**************************************************************************/
-
-/*
-** Context object passed to the fts5SentenceFinderCb() function.
-*/
-typedef struct Fts5SFinder Fts5SFinder;
-struct Fts5SFinder {
-  int iPos;                       /* Current token position */
-  int nFirstAlloc;                /* Allocated size of aFirst[] */
-  int nFirst;                     /* Number of entries in aFirst[] */
-  int *aFirst;                    /* Array of first token in each sentence */
-  const char *zDoc;               /* Document being tokenized */
-};
-
-/*
-** Add an entry to the Fts5SFinder.aFirst[] array. Grow the array if
-** necessary. Return SQLITE_OK if successful, or SQLITE_NOMEM if an
-** error occurs.
-*/
-static int fts5SentenceFinderAdd(Fts5SFinder *p, int iAdd){
-  if( p->nFirstAlloc==p->nFirst ){
-    int nNew = p->nFirstAlloc ? p->nFirstAlloc*2 : 64;
-    int *aNew;
-
-    aNew = (int*)sqlite3_realloc64(p->aFirst, nNew*sizeof(int));
-    if( aNew==0 ) return SQLITE_NOMEM;
-    p->aFirst = aNew;
-    p->nFirstAlloc = nNew;
-  }
-  p->aFirst[p->nFirst++] = iAdd;
-  return SQLITE_OK;
-}
-
-/*
-** This function is an xTokenize() callback used by the auxiliary snippet()
-** function. Its job is to identify tokens that are the first in a sentence.
-** For each such token, an entry is added to the SFinder.aFirst[] array.
-*/
-static int fts5SentenceFinderCb(
-  void *pContext,                 /* Pointer to HighlightContext object */
-  int tflags,                     /* Mask of FTS5_TOKEN_* flags */
-  const char *pToken,             /* Buffer containing token */
-  int nToken,                     /* Size of token in bytes */
-  int iStartOff,                  /* Start offset of token */
-  int iEndOff                     /* End offset of token */
-){
-  int rc = SQLITE_OK;
-
-  UNUSED_PARAM2(pToken, nToken);
-  UNUSED_PARAM(iEndOff);
-
-  if( (tflags & FTS5_TOKEN_COLOCATED)==0 ){
-    Fts5SFinder *p = (Fts5SFinder*)pContext;
-    if( p->iPos>0 ){
-      int i;
-      char c = 0;
-      for(i=iStartOff-1; i>=0; i--){
-        c = p->zDoc[i];
-        if( c!=' ' && c!='\t' && c!='\n' && c!='\r' ) break;
-      }
-      if( i!=iStartOff-1 && (c=='.' || c==':') ){
-        rc = fts5SentenceFinderAdd(p, p->iPos);
-      }
-    }else{
-      rc = fts5SentenceFinderAdd(p, 0);
-    }
-    p->iPos++;
-  }
-  return rc;
-}
-
-static int fts5SnippetScore(
-  const Fts5ExtensionApi *pApi,   /* API offered by current FTS version */
-  Fts5Context *pFts,              /* First arg to pass to pApi functions */
-  int nDocsize,                   /* Size of column in tokens */
-  unsigned char *aSeen,           /* Array with one element per query phrase */
-  int iCol,                       /* Column to score */
-  int iPos,                       /* Starting offset to score */
-  int nToken,                     /* Max tokens per snippet */
-  int *pnScore,                   /* OUT: Score */
-  int *piPos                      /* OUT: Adjusted offset */
-){
-  int rc;
-  int i;
-  int ip = 0;
-  int ic = 0;
-  int iOff = 0;
-  int iFirst = -1;
-  int nInst;
-  int nScore = 0;
-  int iLast = 0;
-  sqlite3_int64 iEnd = (sqlite3_int64)iPos + nToken;
-
-  rc = pApi->xInstCount(pFts, &nInst);
-  for(i=0; i<nInst && rc==SQLITE_OK; i++){
-    rc = pApi->xInst(pFts, i, &ip, &ic, &iOff);
-    if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
-      nScore += (aSeen[ip] ? 1 : 1000);
-      aSeen[ip] = 1;
-      if( iFirst<0 ) iFirst = iOff;
-      iLast = iOff + pApi->xPhraseSize(pFts, ip);
-    }
-  }
-
-  *pnScore = nScore;
-  if( piPos ){
-    sqlite3_int64 iAdj = iFirst - (nToken - (iLast-iFirst)) / 2;
-    if( (iAdj+nToken)>nDocsize ) iAdj = nDocsize - nToken;
-    if( iAdj<0 ) iAdj = 0;
-    *piPos = (int)iAdj;
-  }
-
-  return rc;
-}
-
-/*
-** Return the value in pVal interpreted as utf-8 text. Except, if pVal
-** contains a NULL value, return a pointer to a static string zero
-** bytes in length instead of a NULL pointer.
-*/
-static const char *fts5ValueToText(sqlite3_value *pVal){
-  const char *zRet = (const char*)sqlite3_value_text(pVal);
-  return zRet ? zRet : "";
-}
-
-/*
-** Implementation of snippet() function.
-*/
-static void fts5SnippetFunction(
-  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 */
-){
-  HighlightContext ctx;
-  int rc = SQLITE_OK;             /* Return code */
-  int iCol;                       /* 1st argument to snippet() */
-  const char *zEllips;            /* 4th argument to snippet() */
-  int nToken;                     /* 5th argument to snippet() */
-  int nInst = 0;                  /* Number of instance matches this row */
-  int i;                          /* Used to iterate through instances */
-  int nPhrase;                    /* Number of phrases in query */
-  unsigned char *aSeen;           /* Array of "seen instance" flags */
-  int iBestCol;                   /* Column containing best snippet */
-  int iBestStart = 0;             /* First token of best snippet */
-  int nBestScore = 0;             /* Score of best snippet */
-  int nColSize = 0;               /* Total size of iBestCol in tokens */
-  Fts5SFinder sFinder;            /* Used to find the beginnings of sentences */
-  int nCol;
-
-  if( nVal!=5 ){
-    const char *zErr = "wrong number of arguments to function snippet()";
-    sqlite3_result_error(pCtx, zErr, -1);
-    return;
-  }
-
-  nCol = pApi->xColumnCount(pFts);
-  memset(&ctx, 0, sizeof(HighlightContext));
-  iCol = sqlite3_value_int(apVal[0]);
-  ctx.zOpen = fts5ValueToText(apVal[1]);
-  ctx.zClose = fts5ValueToText(apVal[2]);
-  ctx.iRangeEnd = -1;
-  zEllips = fts5ValueToText(apVal[3]);
-  nToken = sqlite3_value_int(apVal[4]);
-
-  iBestCol = (iCol>=0 ? iCol : 0);
-  nPhrase = pApi->xPhraseCount(pFts);
-  aSeen = sqlite3_malloc64(nPhrase);
-  if( aSeen==0 ){
-    rc = SQLITE_NOMEM;
-  }
-  if( rc==SQLITE_OK ){
-    rc = pApi->xInstCount(pFts, &nInst);
-  }
-
-  memset(&sFinder, 0, sizeof(Fts5SFinder));
-  for(i=0; i<nCol; i++){
-    if( iCol<0 || iCol==i ){
-      const char *pLoc = 0;       /* Locale of column iCol */
-      int nLoc = 0;               /* Size of pLoc in bytes */
-      int nDoc;
-      int nDocsize;
-      int ii;
-      sFinder.iPos = 0;
-      sFinder.nFirst = 0;
-      rc = pApi->xColumnText(pFts, i, &sFinder.zDoc, &nDoc);
-      if( rc!=SQLITE_OK ) break;
-      rc = pApi->xColumnLocale(pFts, i, &pLoc, &nLoc);
-      if( rc!=SQLITE_OK ) break;
-      rc = pApi->xTokenize_v2(pFts,
-          sFinder.zDoc, nDoc, pLoc, nLoc, (void*)&sFinder, fts5SentenceFinderCb
-      );
-      if( rc!=SQLITE_OK ) break;
-      rc = pApi->xColumnSize(pFts, i, &nDocsize);
-      if( rc!=SQLITE_OK ) break;
-
-      for(ii=0; rc==SQLITE_OK && ii<nInst; ii++){
-        int ip, ic, io;
-        int iAdj;
-        int nScore;
-        int jj;
-
-        rc = pApi->xInst(pFts, ii, &ip, &ic, &io);
-        if( ic!=i ) continue;
-        if( io>nDocsize ) rc = FTS5_CORRUPT;
-        if( rc!=SQLITE_OK ) continue;
-        memset(aSeen, 0, nPhrase);
-        rc = fts5SnippetScore(pApi, pFts, nDocsize, aSeen, i,
-            io, nToken, &nScore, &iAdj
-        );
-        if( rc==SQLITE_OK && nScore>nBestScore ){
-          nBestScore = nScore;
-          iBestCol = i;
-          iBestStart = iAdj;
-          nColSize = nDocsize;
-        }
-
-        if( rc==SQLITE_OK && sFinder.nFirst && nDocsize>nToken ){
-          for(jj=0; jj<(sFinder.nFirst-1); jj++){
-            if( sFinder.aFirst[jj+1]>io ) break;
-          }
-
-          if( sFinder.aFirst[jj]<io ){
-            memset(aSeen, 0, nPhrase);
-            rc = fts5SnippetScore(pApi, pFts, nDocsize, aSeen, i,
-              sFinder.aFirst[jj], nToken, &nScore, 0
-            );
-
-            nScore += (sFinder.aFirst[jj]==0 ? 120 : 100);
-            if( rc==SQLITE_OK && nScore>nBestScore ){
-              nBestScore = nScore;
-              iBestCol = i;
-              iBestStart = sFinder.aFirst[jj];
-              nColSize = nDocsize;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = pApi->xColumnText(pFts, iBestCol, &ctx.zIn, &ctx.nIn);
-  }
-  if( rc==SQLITE_OK && nColSize==0 ){
-    rc = pApi->xColumnSize(pFts, iBestCol, &nColSize);
-  }
-  if( ctx.zIn ){
-    const char *pLoc = 0;         /* Locale of column iBestCol */
-    int nLoc = 0;                 /* Bytes in pLoc */
-
-    if( rc==SQLITE_OK ){
-      rc = fts5CInstIterInit(pApi, pFts, iBestCol, &ctx.iter);
-    }
-
-    ctx.iRangeStart = iBestStart;
-    ctx.iRangeEnd = iBestStart + nToken - 1;
-
-    if( iBestStart>0 ){
-      fts5HighlightAppend(&rc, &ctx, zEllips, -1);
-    }
-
-    /* Advance iterator ctx.iter so that it points to the first coalesced
-    ** phrase instance at or following position iBestStart. */
-    while( ctx.iter.iStart>=0 && ctx.iter.iStart<iBestStart && rc==SQLITE_OK ){
-      rc = fts5CInstIterNext(&ctx.iter);
-    }
-
-    if( rc==SQLITE_OK ){
-      rc = pApi->xColumnLocale(pFts, iBestCol, &pLoc, &nLoc);
-    }
-    if( rc==SQLITE_OK ){
-      rc = pApi->xTokenize_v2(
-          pFts, ctx.zIn, ctx.nIn, pLoc, nLoc, (void*)&ctx,fts5HighlightCb
-      );
-    }
-    if( ctx.bOpen ){
-      fts5HighlightAppend(&rc, &ctx, ctx.zClose, -1);
-    }
-    if( ctx.iRangeEnd>=(nColSize-1) ){
-      fts5HighlightAppend(&rc, &ctx, &ctx.zIn[ctx.iOff], ctx.nIn - ctx.iOff);
-    }else{
-      fts5HighlightAppend(&rc, &ctx, zEllips, -1);
-    }
-  }
-  if( rc==SQLITE_OK ){
-    sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
-  }else{
-    sqlite3_result_error_code(pCtx, rc);
-  }
-  sqlite3_free(ctx.zOut);
-  sqlite3_free(aSeen);
-  sqlite3_free(sFinder.aFirst);
-}
-
-/************************************************************************/
-
-/*
-** The first time the bm25() function is called for a query, an instance
-** of the following structure is allocated and populated.
-*/
-typedef struct Fts5Bm25Data Fts5Bm25Data;
-struct Fts5Bm25Data {
-  int nPhrase;                    /* Number of phrases in query */
-  double avgdl;                   /* Average number of tokens in each row */
-  double *aIDF;                   /* IDF for each phrase */
-  double *aFreq;                  /* Array used to calculate phrase freq. */
-};
-
-/*
-** Callback used by fts5Bm25GetData() to count the number of rows in the
-** table matched by each individual phrase within the query.
-*/
-static int fts5CountCb(
-  const Fts5ExtensionApi *pApi,
-  Fts5Context *pFts,
-  void *pUserData                 /* Pointer to sqlite3_int64 variable */
-){
-  sqlite3_int64 *pn = (sqlite3_int64*)pUserData;
-  UNUSED_PARAM2(pApi, pFts);
-  (*pn)++;
-  return SQLITE_OK;
-}
-
-/*
-** Set *ppData to point to the Fts5Bm25Data object for the current query.
-** If the object has not already been allocated, allocate and populate it
-** now.
-*/
-static int fts5Bm25GetData(
-  const Fts5ExtensionApi *pApi,
-  Fts5Context *pFts,
-  Fts5Bm25Data **ppData           /* OUT: bm25-data object for this query */
-){
-  int rc = SQLITE_OK;             /* Return code */
-  Fts5Bm25Data *p;                /* Object to return */
-
-  p = (Fts5Bm25Data*)pApi->xGetAuxdata(pFts, 0);
-  if( p==0 ){
-    int nPhrase;                  /* Number of phrases in query */
-    sqlite3_int64 nRow = 0;       /* Number of rows in table */
-    sqlite3_int64 nToken = 0;     /* Number of tokens in table */
-    sqlite3_int64 nByte;          /* Bytes of space to allocate */
-    int i;
-
-    /* Allocate the Fts5Bm25Data object */
-    nPhrase = pApi->xPhraseCount(pFts);
-    nByte = sizeof(Fts5Bm25Data) + nPhrase*2*sizeof(double);
-    p = (Fts5Bm25Data*)sqlite3_malloc64(nByte);
-    if( p==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      memset(p, 0, (size_t)nByte);
-      p->nPhrase = nPhrase;
-      p->aIDF = (double*)&p[1];
-      p->aFreq = &p->aIDF[nPhrase];
-    }
-
-    /* Calculate the average document length for this FTS5 table */
-    if( rc==SQLITE_OK ) rc = pApi->xRowCount(pFts, &nRow);
-    assert( rc!=SQLITE_OK || nRow>0 );
-    if( rc==SQLITE_OK ) rc = pApi->xColumnTotalSize(pFts, -1, &nToken);
-    if( rc==SQLITE_OK ) p->avgdl = (double)nToken  / (double)nRow;
-
-    /* Calculate an IDF for each phrase in the query */
-    for(i=0; rc==SQLITE_OK && i<nPhrase; i++){
-      sqlite3_int64 nHit = 0;
-      rc = pApi->xQueryPhrase(pFts, i, (void*)&nHit, fts5CountCb);
-      if( rc==SQLITE_OK ){
-        /* Calculate the IDF (Inverse Document Frequency) for phrase i.
-        ** This is done using the standard BM25 formula as found on wikipedia:
-        **
-        **   IDF = log( (N - nHit + 0.5) / (nHit + 0.5) )
-        **
-        ** where "N" is the total number of documents in the set and nHit
-        ** is the number that contain at least one instance of the phrase
-        ** under consideration.
-        **
-        ** The problem with this is that if (N < 2*nHit), the IDF is
-        ** negative. Which is undesirable. So the minimum allowable IDF is
-        ** (1e-6) - roughly the same as a term that appears in just over
-        ** half of set of 5,000,000 documents.  */
-        double idf = log( (nRow - nHit + 0.5) / (nHit + 0.5) );
-        if( idf<=0.0 ) idf = 1e-6;
-        p->aIDF[i] = idf;
-      }
-    }
-
-    if( rc!=SQLITE_OK ){
-      sqlite3_free(p);
-    }else{
-      rc = pApi->xSetAuxdata(pFts, p, sqlite3_free);
-    }
-    if( rc!=SQLITE_OK ) p = 0;
-  }
-  *ppData = p;
-  return rc;
-}
-
-/*
-** Implementation of bm25() function.
-*/
-static void fts5Bm25Function(
-  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 */
-){
-  const double k1 = 1.2;          /* Constant "k1" from BM25 formula */
-  const double b = 0.75;          /* Constant "b" from BM25 formula */
-  int rc;                         /* Error code */
-  double score = 0.0;             /* SQL function return value */
-  Fts5Bm25Data *pData;            /* Values allocated/calculated once only */
-  int i;                          /* Iterator variable */
-  int nInst = 0;                  /* Value returned by xInstCount() */
-  double D = 0.0;                 /* Total number of tokens in row */
-  double *aFreq = 0;              /* Array of phrase freq. for current row */
-
-  /* Calculate the phrase frequency (symbol "f(qi,D)" in the documentation)
-  ** for each phrase in the query for the current row. */
-  rc = fts5Bm25GetData(pApi, pFts, &pData);
-  if( rc==SQLITE_OK ){
-    aFreq = pData->aFreq;
-    memset(aFreq, 0, sizeof(double) * pData->nPhrase);
-    rc = pApi->xInstCount(pFts, &nInst);
-  }
-  for(i=0; rc==SQLITE_OK && i<nInst; i++){
-    int ip; int ic; int io;
-    rc = pApi->xInst(pFts, i, &ip, &ic, &io);
-    if( rc==SQLITE_OK ){
-      double w = (nVal > ic) ? sqlite3_value_double(apVal[ic]) : 1.0;
-      aFreq[ip] += w;
-    }
-  }
-
-  /* Figure out the total size of the current row in tokens. */
-  if( rc==SQLITE_OK ){
-    int nTok;
-    rc = pApi->xColumnSize(pFts, -1, &nTok);
-    D = (double)nTok;
-  }
-
-  /* Determine and return the BM25 score for the current row. Or, if an
-  ** error has occurred, throw an exception. */
-  if( rc==SQLITE_OK ){
-    for(i=0; i<pData->nPhrase; i++){
-      score += pData->aIDF[i] * (
-          ( aFreq[i] * (k1 + 1.0) ) /
-          ( aFreq[i] + k1 * (1 - b + b * D / pData->avgdl) )
-      );
-    }
-    sqlite3_result_double(pCtx, -1.0 * score);
-  }else{
-    sqlite3_result_error_code(pCtx, rc);
-  }
-}
-
-/*
-** Implementation of fts5_get_locale() function.
-*/
-static void fts5GetLocaleFunction(
-  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 */
-){
-  int iCol = 0;
-  int eType = 0;
-  int rc = SQLITE_OK;
-  const char *zLocale = 0;
-  int nLocale = 0;
-
-  /* xColumnLocale() must be available */
-  assert( pApi->iVersion>=4 );
-
-  if( nVal!=1 ){
-    const char *z = "wrong number of arguments to function fts5_get_locale()";
-    sqlite3_result_error(pCtx, z, -1);
-    return;
-  }
-
-  eType = sqlite3_value_numeric_type(apVal[0]);
-  if( eType!=SQLITE_INTEGER ){
-    const char *z = "non-integer argument passed to function fts5_get_locale()";
-    sqlite3_result_error(pCtx, z, -1);
-    return;
-  }
-
-  iCol = sqlite3_value_int(apVal[0]);
-  if( iCol<0 || iCol>=pApi->xColumnCount(pFts) ){
-    sqlite3_result_error_code(pCtx, SQLITE_RANGE);
-    return;
-  }
-
-  rc = pApi->xColumnLocale(pFts, iCol, &zLocale, &nLocale);
-  if( rc!=SQLITE_OK ){
-    sqlite3_result_error_code(pCtx, rc);
-    return;
-  }
-
-  sqlite3_result_text(pCtx, zLocale, nLocale, SQLITE_TRANSIENT);
-}
-
-static int sqlite3Fts5AuxInit(fts5_api *pApi){
-  struct Builtin {
-    const char *zFunc;            /* Function name (nul-terminated) */
-    void *pUserData;              /* User-data pointer */
-    fts5_extension_function xFunc;/* Callback function */
-    void (*xDestroy)(void*);      /* Destructor function */
-  } aBuiltin [] = {
-    { "snippet",         0, fts5SnippetFunction,   0 },
-    { "highlight",       0, fts5HighlightFunction, 0 },
-    { "bm25",            0, fts5Bm25Function,      0 },
-    { "fts5_get_locale", 0, fts5GetLocaleFunction, 0 },
-  };
-  int rc = SQLITE_OK;             /* Return code */
-  int i;                          /* To iterate through builtin functions */
-
-  for(i=0; rc==SQLITE_OK && i<ArraySize(aBuiltin); i++){
-    rc = pApi->xCreateFunction(pApi,
-        aBuiltin[i].zFunc,
-        aBuiltin[i].pUserData,
-        aBuiltin[i].xFunc,
-        aBuiltin[i].xDestroy
-    );
-  }
-
-  return rc;
-}
-
-/*
-** 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.
-**
-******************************************************************************
-*/
-
-
-
-/* #include "fts5Int.h" */
-
-static int sqlite3Fts5BufferSize(int *pRc, Fts5Buffer *pBuf, u32 nByte){
-  if( (u32)pBuf->nSpace<nByte ){
-    u64 nNew = pBuf->nSpace ? pBuf->nSpace : 64;
-    u8 *pNew;
-    while( nNew<nByte ){
-      nNew = nNew * 2;
-    }
-    pNew = sqlite3_realloc64(pBuf->p, nNew);
-    if( pNew==0 ){
-      *pRc = SQLITE_NOMEM;
-      return 1;
-    }else{
-      pBuf->nSpace = (int)nNew;
-      pBuf->p = pNew;
-    }
-  }
-  return 0;
-}
-
-
-/*
-** Encode value iVal as an SQLite varint and append it to the buffer object
-** pBuf. If an OOM error occurs, set the error code in p.
-*/
-static void sqlite3Fts5BufferAppendVarint(int *pRc, Fts5Buffer *pBuf, i64 iVal){
-  if( fts5BufferGrow(pRc, pBuf, 9) ) return;
-  pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], iVal);
-}
-
-static void sqlite3Fts5Put32(u8 *aBuf, int iVal){
-  aBuf[0] = (iVal>>24) & 0x00FF;
-  aBuf[1] = (iVal>>16) & 0x00FF;
-  aBuf[2] = (iVal>> 8) & 0x00FF;
-  aBuf[3] = (iVal>> 0) & 0x00FF;
-}
-
-static int sqlite3Fts5Get32(const u8 *aBuf){
-  return (int)((((u32)aBuf[0])<<24) + (aBuf[1]<<16) + (aBuf[2]<<8) + aBuf[3]);
-}
-
-/*
-** Append buffer nData/pData to buffer pBuf. If an OOM error occurs, set
-** the error code in p. If an error has already occurred when this function
-** is called, it is a no-op.
-*/
-static void sqlite3Fts5BufferAppendBlob(
-  int *pRc,
-  Fts5Buffer *pBuf,
-  u32 nData,
-  const u8 *pData
-){
-  if( nData ){
-    if( fts5BufferGrow(pRc, pBuf, nData) ) return;
-    assert( pBuf->p!=0 );
-    memcpy(&pBuf->p[pBuf->n], pData, nData);
-    pBuf->n += nData;
-  }
-}
-
-/*
-** Append the nul-terminated string zStr to the buffer pBuf. This function
-** ensures that the byte following the buffer data is set to 0x00, even
-** though this byte is not included in the pBuf->n count.
-*/
-static void sqlite3Fts5BufferAppendString(
-  int *pRc,
-  Fts5Buffer *pBuf,
-  const char *zStr
-){
-  int nStr = (int)strlen(zStr);
-  sqlite3Fts5BufferAppendBlob(pRc, pBuf, nStr+1, (const u8*)zStr);
-  pBuf->n--;
-}
-
-/*
-** Argument zFmt is a printf() style format string. This function performs
-** the printf() style processing, then appends the results to buffer pBuf.
-**
-** Like sqlite3Fts5BufferAppendString(), this function ensures that the byte
-** following the buffer data is set to 0x00, even though this byte is not
-** included in the pBuf->n count.
-*/
-static void sqlite3Fts5BufferAppendPrintf(
-  int *pRc,
-  Fts5Buffer *pBuf,
-  char *zFmt, ...
-){
-  if( *pRc==SQLITE_OK ){
-    char *zTmp;
-    va_list ap;
-    va_start(ap, zFmt);
-    zTmp = sqlite3_vmprintf(zFmt, ap);
-    va_end(ap);
-
-    if( zTmp==0 ){
-      *pRc = SQLITE_NOMEM;
-    }else{
-      sqlite3Fts5BufferAppendString(pRc, pBuf, zTmp);
-      sqlite3_free(zTmp);
-    }
-  }
-}
-
-static char *sqlite3Fts5Mprintf(int *pRc, const char *zFmt, ...){
-  char *zRet = 0;
-  if( *pRc==SQLITE_OK ){
-    va_list ap;
-    va_start(ap, zFmt);
-    zRet = sqlite3_vmprintf(zFmt, ap);
-    va_end(ap);
-    if( zRet==0 ){
-      *pRc = SQLITE_NOMEM;
-    }
-  }
-  return zRet;
-}
-
-
-/*
-** Free any buffer allocated by pBuf. Zero the structure before returning.
-*/
-static void sqlite3Fts5BufferFree(Fts5Buffer *pBuf){
-  sqlite3_free(pBuf->p);
-  memset(pBuf, 0, sizeof(Fts5Buffer));
-}
-
-/*
-** Zero the contents of the buffer object. But do not free the associated
-** memory allocation.
-*/
-static void sqlite3Fts5BufferZero(Fts5Buffer *pBuf){
-  pBuf->n = 0;
-}
-
-/*
-** Set the buffer to contain nData/pData. If an OOM error occurs, leave an
-** the error code in p. If an error has already occurred when this function
-** is called, it is a no-op.
-*/
-static void sqlite3Fts5BufferSet(
-  int *pRc,
-  Fts5Buffer *pBuf,
-  int nData,
-  const u8 *pData
-){
-  pBuf->n = 0;
-  sqlite3Fts5BufferAppendBlob(pRc, pBuf, nData, pData);
-}
-
-static int sqlite3Fts5PoslistNext64(
-  const u8 *a, int n,             /* Buffer containing poslist */
-  int *pi,                        /* IN/OUT: Offset within a[] */
-  i64 *piOff                      /* IN/OUT: Current offset */
-){
-  int i = *pi;
-  assert( a!=0 || i==0 );
-  if( i>=n ){
-    /* EOF */
-    *piOff = -1;
-    return 1;
-  }else{
-    i64 iOff = *piOff;
-    u32 iVal;
-    assert( a!=0 );
-    fts5FastGetVarint32(a, i, iVal);
-    if( iVal<=1 ){
-      if( iVal==0 ){
-        *pi = i;
-        return 0;
-      }
-      fts5FastGetVarint32(a, i, iVal);
-      iOff = ((i64)iVal) << 32;
-      assert( iOff>=0 );
-      fts5FastGetVarint32(a, i, iVal);
-      if( iVal<2 ){
-        /* This is a corrupt record. So stop parsing it here. */
-        *piOff = -1;
-        return 1;
-      }
-      *piOff = iOff + ((iVal-2) & 0x7FFFFFFF);
-    }else{
-      *piOff = (iOff & (i64)0x7FFFFFFF<<32)+((iOff + (iVal-2)) & 0x7FFFFFFF);
-    }
-    *pi = i;
-    assert_nc( *piOff>=iOff );
-    return 0;
-  }
-}
-
-
-/*
-** Advance the iterator object passed as the only argument. Return true
-** if the iterator reaches EOF, or false otherwise.
-*/
-static int sqlite3Fts5PoslistReaderNext(Fts5PoslistReader *pIter){
-  if( sqlite3Fts5PoslistNext64(pIter->a, pIter->n, &pIter->i, &pIter->iPos) ){
-    pIter->bEof = 1;
-  }
-  return pIter->bEof;
-}
-
-static int sqlite3Fts5PoslistReaderInit(
-  const u8 *a, int n,             /* Poslist buffer to iterate through */
-  Fts5PoslistReader *pIter        /* Iterator object to initialize */
-){
-  memset(pIter, 0, sizeof(*pIter));
-  pIter->a = a;
-  pIter->n = n;
-  sqlite3Fts5PoslistReaderNext(pIter);
-  return pIter->bEof;
-}
-
-/*
-** Append position iPos to the position list being accumulated in buffer
-** pBuf, which must be already be large enough to hold the new data.
-** The previous position written to this list is *piPrev. *piPrev is set
-** to iPos before returning.
-*/
-static void sqlite3Fts5PoslistSafeAppend(
-  Fts5Buffer *pBuf,
-  i64 *piPrev,
-  i64 iPos
-){
-  if( iPos>=*piPrev ){
-    static const i64 colmask = ((i64)(0x7FFFFFFF)) << 32;
-    if( (iPos & colmask) != (*piPrev & colmask) ){
-      pBuf->p[pBuf->n++] = 1;
-      pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32));
-      *piPrev = (iPos & colmask);
-    }
-    pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-*piPrev)+2);
-    *piPrev = iPos;
-  }
-}
-
-static int sqlite3Fts5PoslistWriterAppend(
-  Fts5Buffer *pBuf,
-  Fts5PoslistWriter *pWriter,
-  i64 iPos
-){
-  int rc = 0;   /* Initialized only to suppress erroneous warning from Clang */
-  if( fts5BufferGrow(&rc, pBuf, 5+5+5) ) return rc;
-  sqlite3Fts5PoslistSafeAppend(pBuf, &pWriter->iPrev, iPos);
-  return SQLITE_OK;
-}
-
-static void *sqlite3Fts5MallocZero(int *pRc, sqlite3_int64 nByte){
-  void *pRet = 0;
-  if( *pRc==SQLITE_OK ){
-    pRet = sqlite3_malloc64(nByte);
-    if( pRet==0 ){
-      if( nByte>0 ) *pRc = SQLITE_NOMEM;
-    }else{
-      memset(pRet, 0, (size_t)nByte);
-    }
-  }
-  return pRet;
-}
-
-/*
-** Return a nul-terminated copy of the string indicated by pIn. If nIn
-** is non-negative, then it is the length of the string in bytes. Otherwise,
-** the length of the string is determined using strlen().
-**
-** It is the responsibility of the caller to eventually free the returned
-** buffer using sqlite3_free(). If an OOM error occurs, NULL is returned.
-*/
-static char *sqlite3Fts5Strndup(int *pRc, const char *pIn, int nIn){
-  char *zRet = 0;
-  if( *pRc==SQLITE_OK ){
-    if( nIn<0 ){
-      nIn = (int)strlen(pIn);
-    }
-    zRet = (char*)sqlite3_malloc64((i64)nIn+1);
-    if( zRet ){
-      memcpy(zRet, pIn, nIn);
-      zRet[nIn] = '\0';
-    }else{
-      *pRc = SQLITE_NOMEM;
-    }
-  }
-  return zRet;
-}
-
-
-/*
-** Return true if character 't' may be part of an FTS5 bareword, or false
-** otherwise. Characters that may be part of barewords:
-**
-**   * All non-ASCII characters,
-**   * The 52 upper and lower case ASCII characters, and
-**   * The 10 integer ASCII characters.
-**   * The underscore character "_" (0x5F).
-**   * The unicode "substitute" character (0x1A).
-*/
-static int sqlite3Fts5IsBareword(char t){
-  u8 aBareword[128] = {
-    0, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0, 0, 0,   /* 0x00 .. 0x0F */
-    0, 0, 0, 0, 0, 0, 0, 0,    0, 0, 1, 0, 0, 0, 0, 0,   /* 0x10 .. 0x1F */
-    0, 0, 0, 0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0, 0, 0,   /* 0x20 .. 0x2F */
-    1, 1, 1, 1, 1, 1, 1, 1,    1, 1, 0, 0, 0, 0, 0, 0,   /* 0x30 .. 0x3F */
-    0, 1, 1, 1, 1, 1, 1, 1,    1, 1, 1, 1, 1, 1, 1, 1,   /* 0x40 .. 0x4F */
-    1, 1, 1, 1, 1, 1, 1, 1,    1, 1, 1, 0, 0, 0, 0, 1,   /* 0x50 .. 0x5F */
-    0, 1, 1, 1, 1, 1, 1, 1,    1, 1, 1, 1, 1, 1, 1, 1,   /* 0x60 .. 0x6F */
-    1, 1, 1, 1, 1, 1, 1, 1,    1, 1, 1, 0, 0, 0, 0, 0    /* 0x70 .. 0x7F */
-  };
-
-  return (t & 0x80) || aBareword[(int)t];
-}
-
-
-/*************************************************************************
-*/
-typedef struct Fts5TermsetEntry Fts5TermsetEntry;
-struct Fts5TermsetEntry {
-  char *pTerm;
-  int nTerm;
-  int iIdx;                       /* Index (main or aPrefix[] entry) */
-  Fts5TermsetEntry *pNext;
-};
-
-struct Fts5Termset {
-  Fts5TermsetEntry *apHash[512];
-};
-
-static int sqlite3Fts5TermsetNew(Fts5Termset **pp){
-  int rc = SQLITE_OK;
-  *pp = sqlite3Fts5MallocZero(&rc, sizeof(Fts5Termset));
-  return rc;
-}
-
-static int sqlite3Fts5TermsetAdd(
-  Fts5Termset *p,
-  int iIdx,
-  const char *pTerm, int nTerm,
-  int *pbPresent
-){
-  int rc = SQLITE_OK;
-  *pbPresent = 0;
-  if( p ){
-    int i;
-    u32 hash = 13;
-    Fts5TermsetEntry *pEntry;
-
-    /* Calculate a hash value for this term. This is the same hash checksum
-    ** used by the fts5_hash.c module. This is not important for correct
-    ** operation of the module, but is necessary to ensure that some tests
-    ** designed to produce hash table collisions really do work.  */
-    for(i=nTerm-1; i>=0; i--){
-      hash = (hash << 3) ^ hash ^ pTerm[i];
-    }
-    hash = (hash << 3) ^ hash ^ iIdx;
-    hash = hash % ArraySize(p->apHash);
-
-    for(pEntry=p->apHash[hash]; pEntry; pEntry=pEntry->pNext){
-      if( pEntry->iIdx==iIdx
-          && pEntry->nTerm==nTerm
-          && memcmp(pEntry->pTerm, pTerm, nTerm)==0
-      ){
-        *pbPresent = 1;
-        break;
-      }
-    }
-
-    if( pEntry==0 ){
-      pEntry = sqlite3Fts5MallocZero(&rc, sizeof(Fts5TermsetEntry) + nTerm);
-      if( pEntry ){
-        pEntry->pTerm = (char*)&pEntry[1];
-        pEntry->nTerm = nTerm;
-        pEntry->iIdx = iIdx;
-        memcpy(pEntry->pTerm, pTerm, nTerm);
-        pEntry->pNext = p->apHash[hash];
-        p->apHash[hash] = pEntry;
-      }
-    }
-  }
-
-  return rc;
-}
-
-static void sqlite3Fts5TermsetFree(Fts5Termset *p){
-  if( p ){
-    u32 i;
-    for(i=0; i<ArraySize(p->apHash); i++){
-      Fts5TermsetEntry *pEntry = p->apHash[i];
-      while( pEntry ){
-        Fts5TermsetEntry *pDel = pEntry;
-        pEntry = pEntry->pNext;
-        sqlite3_free(pDel);
-      }
-    }
-    sqlite3_free(p);
-  }
-}
-
-/*
-** 2014 Jun 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 is an SQLite module implementing full-text search.
-*/
-
-
-/* #include "fts5Int.h" */
-
-#define FTS5_DEFAULT_PAGE_SIZE   4050
-#define FTS5_DEFAULT_AUTOMERGE      4
-#define FTS5_DEFAULT_USERMERGE      4
-#define FTS5_DEFAULT_CRISISMERGE   16
-#define FTS5_DEFAULT_HASHSIZE    (1024*1024)
-
-#define FTS5_DEFAULT_DELETE_AUTOMERGE 10      /* default 10% */
-
-/* Maximum allowed page size */
-#define FTS5_MAX_PAGE_SIZE (64*1024)
-
-static int fts5_iswhitespace(char x){
-  return (x==' ');
-}
-
-static int fts5_isopenquote(char x){
-  return (x=='"' || x=='\'' || x=='[' || x=='`');
-}
-
-/*
-** Argument pIn points to a character that is part of a nul-terminated
-** string. Return a pointer to the first character following *pIn in
-** the string that is not a white-space character.
-*/
-static const char *fts5ConfigSkipWhitespace(const char *pIn){
-  const char *p = pIn;
-  if( p ){
-    while( fts5_iswhitespace(*p) ){ p++; }
-  }
-  return p;
-}
-
-/*
-** Argument pIn points to a character that is part of a nul-terminated
-** string. Return a pointer to the first character following *pIn in
-** the string that is not a "bareword" character.
-*/
-static const char *fts5ConfigSkipBareword(const char *pIn){
-  const char *p = pIn;
-  while ( sqlite3Fts5IsBareword(*p) ) p++;
-  if( p==pIn ) p = 0;
-  return p;
-}
-
-static int fts5_isdigit(char a){
-  return (a>='0' && a<='9');
-}
-
-
-
-static const char *fts5ConfigSkipLiteral(const char *pIn){
-  const char *p = pIn;
-  switch( *p ){
-    case 'n': case 'N':
-      if( sqlite3_strnicmp("null", p, 4)==0 ){
-        p = &p[4];
-      }else{
-        p = 0;
-      }
-      break;
-
-    case 'x': case 'X':
-      p++;
-      if( *p=='\'' ){
-        p++;
-        while( (*p>='a' && *p<='f')
-            || (*p>='A' && *p<='F')
-            || (*p>='0' && *p<='9')
-            ){
-          p++;
-        }
-        if( *p=='\'' && 0==((p-pIn)%2) ){
-          p++;
-        }else{
-          p = 0;
-        }
-      }else{
-        p = 0;
-      }
-      break;
-
-    case '\'':
-      p++;
-      while( p ){
-        if( *p=='\'' ){
-          p++;
-          if( *p!='\'' ) break;
-        }
-        p++;
-        if( *p==0 ) p = 0;
-      }
-      break;
-
-    default:
-      /* maybe a number */
-      if( *p=='+' || *p=='-' ) p++;
-      while( fts5_isdigit(*p) ) p++;
-
-      /* At this point, if the literal was an integer, the parse is
-      ** finished. Or, if it is a floating point value, it may continue
-      ** with either a decimal point or an 'E' character. */
-      if( *p=='.' && fts5_isdigit(p[1]) ){
-        p += 2;
-        while( fts5_isdigit(*p) ) p++;
-      }
-      if( p==pIn ) p = 0;
-
-      break;
-  }
-
-  return p;
-}
-
-/*
-** The first character of the string pointed to by argument z is guaranteed
-** to be an open-quote character (see function fts5_isopenquote()).
-**
-** This function searches for the corresponding close-quote character within
-** the string and, if found, dequotes the string in place and adds a new
-** nul-terminator byte.
-**
-** If the close-quote is found, the value returned is the byte offset of
-** the character immediately following it. Or, if the close-quote is not
-** found, -1 is returned. If -1 is returned, the buffer is left in an
-** undefined state.
-*/
-static int fts5Dequote(char *z){
-  char q;
-  int iIn = 1;
-  int iOut = 0;
-  q = z[0];
-
-  /* Set stack variable q to the close-quote character */
-  assert( q=='[' || q=='\'' || q=='"' || q=='`' );
-  if( q=='[' ) q = ']';
-
-  while( z[iIn] ){
-    if( z[iIn]==q ){
-      if( z[iIn+1]!=q ){
-        /* Character iIn was the close quote. */
-        iIn++;
-        break;
-      }else{
-        /* Character iIn and iIn+1 form an escaped quote character. Skip
-        ** the input cursor past both and copy a single quote character
-        ** to the output buffer. */
-        iIn += 2;
-        z[iOut++] = q;
-      }
-    }else{
-      z[iOut++] = z[iIn++];
-    }
-  }
-
-  z[iOut] = '\0';
-  return iIn;
-}
-
-/*
-** 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
-*/
-static void sqlite3Fts5Dequote(char *z){
-  char quote;                     /* Quote character (if any ) */
-
-  assert( 0==fts5_iswhitespace(z[0]) );
-  quote = z[0];
-  if( quote=='[' || quote=='\'' || quote=='"' || quote=='`' ){
-    fts5Dequote(z);
-  }
-}
-
-
-struct Fts5Enum {
-  const char *zName;
-  int eVal;
-};
-typedef struct Fts5Enum Fts5Enum;
-
-static int fts5ConfigSetEnum(
-  const Fts5Enum *aEnum,
-  const char *zEnum,
-  int *peVal
-){
-  int nEnum = (int)strlen(zEnum);
-  int i;
-  int iVal = -1;
-
-  for(i=0; aEnum[i].zName; i++){
-    if( sqlite3_strnicmp(aEnum[i].zName, zEnum, nEnum)==0 ){
-      if( iVal>=0 ) return SQLITE_ERROR;
-      iVal = aEnum[i].eVal;
-    }
-  }
-
-  *peVal = iVal;
-  return iVal<0 ? SQLITE_ERROR : SQLITE_OK;
-}
-
-/*
-** Parse a "special" CREATE VIRTUAL TABLE directive and update
-** configuration object pConfig as appropriate.
-**
-** If successful, object pConfig is updated and SQLITE_OK returned. If
-** an error occurs, an SQLite error code is returned and an error message
-** may be left in *pzErr. It is the responsibility of the caller to
-** eventually free any such error message using sqlite3_free().
-*/
-static int fts5ConfigParseSpecial(
-  Fts5Config *pConfig,            /* Configuration object to update */
-  const char *zCmd,               /* Special command to parse */
-  const char *zArg,               /* Argument to parse */
-  char **pzErr                    /* OUT: Error message */
-){
-  int rc = SQLITE_OK;
-  int nCmd = (int)strlen(zCmd);
-
-  if( sqlite3_strnicmp("prefix", zCmd, nCmd)==0 ){
-    const int nByte = sizeof(int) * FTS5_MAX_PREFIX_INDEXES;
-    const char *p;
-    int bFirst = 1;
-    if( pConfig->aPrefix==0 ){
-      pConfig->aPrefix = sqlite3Fts5MallocZero(&rc, nByte);
-      if( rc ) return rc;
-    }
-
-    p = zArg;
-    while( 1 ){
-      int nPre = 0;
-
-      while( p[0]==' ' ) p++;
-      if( bFirst==0 && p[0]==',' ){
-        p++;
-        while( p[0]==' ' ) p++;
-      }else if( p[0]=='\0' ){
-        break;
-      }
-      if( p[0]<'0' || p[0]>'9' ){
-        *pzErr = sqlite3_mprintf("malformed prefix=... directive");
-        rc = SQLITE_ERROR;
-        break;
-      }
-
-      if( pConfig->nPrefix==FTS5_MAX_PREFIX_INDEXES ){
-        *pzErr = sqlite3_mprintf(
-            "too many prefix indexes (max %d)", FTS5_MAX_PREFIX_INDEXES
-        );
-        rc = SQLITE_ERROR;
-        break;
-      }
-
-      while( p[0]>='0' && p[0]<='9' && nPre<1000 ){
-        nPre = nPre*10 + (p[0] - '0');
-        p++;
-      }
-
-      if( nPre<=0 || nPre>=1000 ){
-        *pzErr = sqlite3_mprintf("prefix length out of range (max 999)");
-        rc = SQLITE_ERROR;
-        break;
-      }
-
-      pConfig->aPrefix[pConfig->nPrefix] = nPre;
-      pConfig->nPrefix++;
-      bFirst = 0;
-    }
-    assert( pConfig->nPrefix<=FTS5_MAX_PREFIX_INDEXES );
-    return rc;
-  }
-
-  if( sqlite3_strnicmp("tokenize", zCmd, nCmd)==0 ){
-    const char *p = (const char*)zArg;
-    sqlite3_int64 nArg = strlen(zArg) + 1;
-    char **azArg = sqlite3Fts5MallocZero(&rc, (sizeof(char*) + 2) * nArg);
-
-    if( azArg ){
-      char *pSpace = (char*)&azArg[nArg];
-      if( pConfig->t.azArg ){
-        *pzErr = sqlite3_mprintf("multiple tokenize=... directives");
-        rc = SQLITE_ERROR;
-      }else{
-        for(nArg=0; p && *p; nArg++){
-          const char *p2 = fts5ConfigSkipWhitespace(p);
-          if( *p2=='\'' ){
-            p = fts5ConfigSkipLiteral(p2);
-          }else{
-            p = fts5ConfigSkipBareword(p2);
-          }
-          if( p ){
-            memcpy(pSpace, p2, p-p2);
-            azArg[nArg] = pSpace;
-            sqlite3Fts5Dequote(pSpace);
-            pSpace += (p - p2) + 1;
-            p = fts5ConfigSkipWhitespace(p);
-          }
-        }
-        if( p==0 ){
-          *pzErr = sqlite3_mprintf("parse error in tokenize directive");
-          rc = SQLITE_ERROR;
-        }else{
-          pConfig->t.azArg = (const char**)azArg;
-          pConfig->t.nArg = nArg;
-          azArg = 0;
-        }
-      }
-    }
-    sqlite3_free(azArg);
-
-    return rc;
-  }
-
-  if( sqlite3_strnicmp("content", zCmd, nCmd)==0 ){
-    if( pConfig->eContent!=FTS5_CONTENT_NORMAL ){
-      *pzErr = sqlite3_mprintf("multiple content=... directives");
-      rc = SQLITE_ERROR;
-    }else{
-      if( zArg[0] ){
-        pConfig->eContent = FTS5_CONTENT_EXTERNAL;
-        pConfig->zContent = sqlite3Fts5Mprintf(&rc, "%Q.%Q", pConfig->zDb,zArg);
-      }else{
-        pConfig->eContent = FTS5_CONTENT_NONE;
-      }
-    }
-    return rc;
-  }
-
-  if( sqlite3_strnicmp("contentless_delete", zCmd, nCmd)==0 ){
-    if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1]!='\0' ){
-      *pzErr = sqlite3_mprintf("malformed contentless_delete=... directive");
-      rc = SQLITE_ERROR;
-    }else{
-      pConfig->bContentlessDelete = (zArg[0]=='1');
-    }
-    return rc;
-  }
-
-  if( sqlite3_strnicmp("contentless_unindexed", zCmd, nCmd)==0 ){
-    if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1]!='\0' ){
-      *pzErr = sqlite3_mprintf("malformed contentless_delete=... directive");
-      rc = SQLITE_ERROR;
-    }else{
-      pConfig->bContentlessUnindexed = (zArg[0]=='1');
-    }
-    return rc;
-  }
-
-  if( sqlite3_strnicmp("content_rowid", zCmd, nCmd)==0 ){
-    if( pConfig->zContentRowid ){
-      *pzErr = sqlite3_mprintf("multiple content_rowid=... directives");
-      rc = SQLITE_ERROR;
-    }else{
-      pConfig->zContentRowid = sqlite3Fts5Strndup(&rc, zArg, -1);
-    }
-    return rc;
-  }
-
-  if( sqlite3_strnicmp("columnsize", zCmd, nCmd)==0 ){
-    if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1]!='\0' ){
-      *pzErr = sqlite3_mprintf("malformed columnsize=... directive");
-      rc = SQLITE_ERROR;
-    }else{
-      pConfig->bColumnsize = (zArg[0]=='1');
-    }
-    return rc;
-  }
-
-  if( sqlite3_strnicmp("locale", zCmd, nCmd)==0 ){
-    if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1]!='\0' ){
-      *pzErr = sqlite3_mprintf("malformed locale=... directive");
-      rc = SQLITE_ERROR;
-    }else{
-      pConfig->bLocale = (zArg[0]=='1');
-    }
-    return rc;
-  }
-
-  if( sqlite3_strnicmp("detail", zCmd, nCmd)==0 ){
-    const Fts5Enum aDetail[] = {
-      { "none", FTS5_DETAIL_NONE },
-      { "full", FTS5_DETAIL_FULL },
-      { "columns", FTS5_DETAIL_COLUMNS },
-      { 0, 0 }
-    };
-
-    if( (rc = fts5ConfigSetEnum(aDetail, zArg, &pConfig->eDetail)) ){
-      *pzErr = sqlite3_mprintf("malformed detail=... directive");
-    }
-    return rc;
-  }
-
-  if( sqlite3_strnicmp("tokendata", zCmd, nCmd)==0 ){
-    if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1]!='\0' ){
-      *pzErr = sqlite3_mprintf("malformed tokendata=... directive");
-      rc = SQLITE_ERROR;
-    }else{
-      pConfig->bTokendata = (zArg[0]=='1');
-    }
-    return rc;
-  }
-
-  *pzErr = sqlite3_mprintf("unrecognized option: \"%.*s\"", nCmd, zCmd);
-  return SQLITE_ERROR;
-}
-
-/*
-** Gobble up the first bareword or quoted word from the input buffer zIn.
-** Return a pointer to the character immediately following the last in
-** the gobbled word if successful, or a NULL pointer otherwise (failed
-** to find close-quote character).
-**
-** Before returning, set pzOut to point to a new buffer containing a
-** nul-terminated, dequoted copy of the gobbled word. If the word was
-** quoted, *pbQuoted is also set to 1 before returning.
-**
-** If *pRc is other than SQLITE_OK when this function is called, it is
-** a no-op (NULL is returned). Otherwise, if an OOM occurs within this
-** function, *pRc is set to SQLITE_NOMEM before returning. *pRc is *not*
-** set if a parse error (failed to find close quote) occurs.
-*/
-static const char *fts5ConfigGobbleWord(
-  int *pRc,                       /* IN/OUT: Error code */
-  const char *zIn,                /* Buffer to gobble string/bareword from */
-  char **pzOut,                   /* OUT: malloc'd buffer containing str/bw */
-  int *pbQuoted                   /* OUT: Set to true if dequoting required */
-){
-  const char *zRet = 0;
-
-  sqlite3_int64 nIn = strlen(zIn);
-  char *zOut = sqlite3_malloc64(nIn+1);
-
-  assert( *pRc==SQLITE_OK );
-  *pbQuoted = 0;
-  *pzOut = 0;
-
-  if( zOut==0 ){
-    *pRc = SQLITE_NOMEM;
-  }else{
-    memcpy(zOut, zIn, (size_t)(nIn+1));
-    if( fts5_isopenquote(zOut[0]) ){
-      int ii = fts5Dequote(zOut);
-      zRet = &zIn[ii];
-      *pbQuoted = 1;
-    }else{
-      zRet = fts5ConfigSkipBareword(zIn);
-      if( zRet ){
-        zOut[zRet-zIn] = '\0';
-      }
-    }
-  }
-
-  if( zRet==0 ){
-    sqlite3_free(zOut);
-  }else{
-    *pzOut = zOut;
-  }
-
-  return zRet;
-}
-
-static int fts5ConfigParseColumn(
-  Fts5Config *p,
-  char *zCol,
-  char *zArg,
-  char **pzErr,
-  int *pbUnindexed
-){
-  int rc = SQLITE_OK;
-  if( 0==sqlite3_stricmp(zCol, FTS5_RANK_NAME)
-   || 0==sqlite3_stricmp(zCol, FTS5_ROWID_NAME)
-  ){
-    *pzErr = sqlite3_mprintf("reserved fts5 column name: %s", zCol);
-    rc = SQLITE_ERROR;
-  }else if( zArg ){
-    if( 0==sqlite3_stricmp(zArg, "unindexed") ){
-      p->abUnindexed[p->nCol] = 1;
-      *pbUnindexed = 1;
-    }else{
-      *pzErr = sqlite3_mprintf("unrecognized column option: %s", zArg);
-      rc = SQLITE_ERROR;
-    }
-  }
-
-  p->azCol[p->nCol++] = zCol;
-  return rc;
-}
-
-/*
-** Populate the Fts5Config.zContentExprlist string.
-*/
-static int fts5ConfigMakeExprlist(Fts5Config *p){
-  int i;
-  int rc = SQLITE_OK;
-  Fts5Buffer buf = {0, 0, 0};
-
-  sqlite3Fts5BufferAppendPrintf(&rc, &buf, "T.%Q", p->zContentRowid);
-  if( p->eContent!=FTS5_CONTENT_NONE ){
-    assert( p->eContent==FTS5_CONTENT_EXTERNAL
-         || p->eContent==FTS5_CONTENT_NORMAL
-         || p->eContent==FTS5_CONTENT_UNINDEXED
-    );
-    for(i=0; i<p->nCol; i++){
-      if( p->eContent==FTS5_CONTENT_EXTERNAL ){
-        sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", T.%Q", p->azCol[i]);
-      }else if( p->eContent==FTS5_CONTENT_NORMAL || p->abUnindexed[i] ){
-        sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", T.c%d", i);
-      }else{
-        sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", NULL");
-      }
-    }
-  }
-  if( p->eContent==FTS5_CONTENT_NORMAL && p->bLocale ){
-    for(i=0; i<p->nCol; i++){
-      if( p->abUnindexed[i]==0 ){
-        sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", T.l%d", i);
-      }else{
-        sqlite3Fts5BufferAppendPrintf(&rc, &buf, ", NULL");
-      }
-    }
-  }
-
-  assert( p->zContentExprlist==0 );
-  p->zContentExprlist = (char*)buf.p;
-  return rc;
-}
-
-/*
-** Arguments nArg/azArg contain the string arguments passed to the xCreate
-** or xConnect method of the virtual table. This function attempts to
-** allocate an instance of Fts5Config containing the results of parsing
-** those arguments.
-**
-** If successful, SQLITE_OK is returned and *ppOut is set to point to the
-** new Fts5Config object. If an error occurs, an SQLite error code is
-** returned, *ppOut is set to NULL and an error message may be left in
-** *pzErr. It is the responsibility of the caller to eventually free any
-** such error message using sqlite3_free().
-*/
-static int sqlite3Fts5ConfigParse(
-  Fts5Global *pGlobal,
-  sqlite3 *db,
-  int nArg,                       /* Number of arguments */
-  const char **azArg,             /* Array of nArg CREATE VIRTUAL TABLE args */
-  Fts5Config **ppOut,             /* OUT: Results of parse */
-  char **pzErr                    /* OUT: Error message */
-){
-  int rc = SQLITE_OK;             /* Return code */
-  Fts5Config *pRet;               /* New object to return */
-  int i;
-  sqlite3_int64 nByte;
-  int bUnindexed = 0;             /* True if there are one or more UNINDEXED */
-
-  *ppOut = pRet = (Fts5Config*)sqlite3_malloc64(sizeof(Fts5Config));
-  if( pRet==0 ) return SQLITE_NOMEM;
-  memset(pRet, 0, sizeof(Fts5Config));
-  pRet->pGlobal = pGlobal;
-  pRet->db = db;
-  pRet->iCookie = -1;
-
-  nByte = nArg * (sizeof(char*) + sizeof(u8));
-  pRet->azCol = (char**)sqlite3Fts5MallocZero(&rc, nByte);
-  pRet->abUnindexed = pRet->azCol ? (u8*)&pRet->azCol[nArg] : 0;
-  pRet->zDb = sqlite3Fts5Strndup(&rc, azArg[1], -1);
-  pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1);
-  pRet->bColumnsize = 1;
-  pRet->eDetail = FTS5_DETAIL_FULL;
-#ifdef SQLITE_DEBUG
-  pRet->bPrefixIndex = 1;
-#endif
-  if( rc==SQLITE_OK && sqlite3_stricmp(pRet->zName, FTS5_RANK_NAME)==0 ){
-    *pzErr = sqlite3_mprintf("reserved fts5 table name: %s", pRet->zName);
-    rc = SQLITE_ERROR;
-  }
-
-  assert( (pRet->abUnindexed && pRet->azCol) || rc!=SQLITE_OK );
-  for(i=3; rc==SQLITE_OK && i<nArg; i++){
-    const char *zOrig = azArg[i];
-    const char *z;
-    char *zOne = 0;
-    char *zTwo = 0;
-    int bOption = 0;
-    int bMustBeCol = 0;
-
-    z = fts5ConfigGobbleWord(&rc, zOrig, &zOne, &bMustBeCol);
-    z = fts5ConfigSkipWhitespace(z);
-    if( z && *z=='=' ){
-      bOption = 1;
-      assert( zOne!=0 );
-      z++;
-      if( bMustBeCol ) z = 0;
-    }
-    z = fts5ConfigSkipWhitespace(z);
-    if( z && z[0] ){
-      int bDummy;
-      z = fts5ConfigGobbleWord(&rc, z, &zTwo, &bDummy);
-      if( z && z[0] ) z = 0;
-    }
-
-    if( rc==SQLITE_OK ){
-      if( z==0 ){
-        *pzErr = sqlite3_mprintf("parse error in \"%s\"", zOrig);
-        rc = SQLITE_ERROR;
-      }else{
-        if( bOption ){
-          rc = fts5ConfigParseSpecial(pRet,
-            ALWAYS(zOne)?zOne:"",
-            zTwo?zTwo:"",
-            pzErr
-          );
-        }else{
-          rc = fts5ConfigParseColumn(pRet, zOne, zTwo, pzErr, &bUnindexed);
-          zOne = 0;
-        }
-      }
-    }
-
-    sqlite3_free(zOne);
-    sqlite3_free(zTwo);
-  }
-
-  /* We only allow contentless_delete=1 if the table is indeed contentless. */
-  if( rc==SQLITE_OK
-   && pRet->bContentlessDelete
-   && pRet->eContent!=FTS5_CONTENT_NONE
-  ){
-    *pzErr = sqlite3_mprintf(
-        "contentless_delete=1 requires a contentless table"
-    );
-    rc = SQLITE_ERROR;
-  }
-
-  /* We only allow contentless_delete=1 if columnsize=0 is not present.
-  **
-  ** This restriction may be removed at some point.
-  */
-  if( rc==SQLITE_OK && pRet->bContentlessDelete && pRet->bColumnsize==0 ){
-    *pzErr = sqlite3_mprintf(
-        "contentless_delete=1 is incompatible with columnsize=0"
-    );
-    rc = SQLITE_ERROR;
-  }
-
-  /* We only allow contentless_unindexed=1 if the table is actually a
-  ** contentless one.
-  */
-  if( rc==SQLITE_OK
-   && pRet->bContentlessUnindexed
-   && pRet->eContent!=FTS5_CONTENT_NONE
-  ){
-    *pzErr = sqlite3_mprintf(
-        "contentless_unindexed=1 requires a contentless table"
-    );
-    rc = SQLITE_ERROR;
-  }
-
-  /* If no zContent option was specified, fill in the default values. */
-  if( rc==SQLITE_OK && pRet->zContent==0 ){
-    const char *zTail = 0;
-    assert( pRet->eContent==FTS5_CONTENT_NORMAL
-         || pRet->eContent==FTS5_CONTENT_NONE
-    );
-    if( pRet->eContent==FTS5_CONTENT_NORMAL ){
-      zTail = "content";
-    }else if( bUnindexed && pRet->bContentlessUnindexed ){
-      pRet->eContent = FTS5_CONTENT_UNINDEXED;
-      zTail = "content";
-    }else if( pRet->bColumnsize ){
-      zTail = "docsize";
-    }
-
-    if( zTail ){
-      pRet->zContent = sqlite3Fts5Mprintf(
-          &rc, "%Q.'%q_%s'", pRet->zDb, pRet->zName, zTail
-      );
-    }
-  }
-
-  if( rc==SQLITE_OK && pRet->zContentRowid==0 ){
-    pRet->zContentRowid = sqlite3Fts5Strndup(&rc, "rowid", -1);
-  }
-
-  /* Formulate the zContentExprlist text */
-  if( rc==SQLITE_OK ){
-    rc = fts5ConfigMakeExprlist(pRet);
-  }
-
-  if( rc!=SQLITE_OK ){
-    sqlite3Fts5ConfigFree(pRet);
-    *ppOut = 0;
-  }
-  return rc;
-}
-
-/*
-** Free the configuration object passed as the only argument.
-*/
-static void sqlite3Fts5ConfigFree(Fts5Config *pConfig){
-  if( pConfig ){
-    int i;
-    if( pConfig->t.pTok ){
-      if( pConfig->t.pApi1 ){
-        pConfig->t.pApi1->xDelete(pConfig->t.pTok);
-      }else{
-        pConfig->t.pApi2->xDelete(pConfig->t.pTok);
-      }
-    }
-    sqlite3_free((char*)pConfig->t.azArg);
-    sqlite3_free(pConfig->zDb);
-    sqlite3_free(pConfig->zName);
-    for(i=0; i<pConfig->nCol; i++){
-      sqlite3_free(pConfig->azCol[i]);
-    }
-    sqlite3_free(pConfig->azCol);
-    sqlite3_free(pConfig->aPrefix);
-    sqlite3_free(pConfig->zRank);
-    sqlite3_free(pConfig->zRankArgs);
-    sqlite3_free(pConfig->zContent);
-    sqlite3_free(pConfig->zContentRowid);
-    sqlite3_free(pConfig->zContentExprlist);
-    sqlite3_free(pConfig);
-  }
-}
-
-/*
-** Call sqlite3_declare_vtab() based on the contents of the configuration
-** object passed as the only argument. Return SQLITE_OK if successful, or
-** an SQLite error code if an error occurs.
-*/
-static int sqlite3Fts5ConfigDeclareVtab(Fts5Config *pConfig){
-  int i;
-  int rc = SQLITE_OK;
-  char *zSql;
-
-  zSql = sqlite3Fts5Mprintf(&rc, "CREATE TABLE x(");
-  for(i=0; zSql && i<pConfig->nCol; i++){
-    const char *zSep = (i==0?"":", ");
-    zSql = sqlite3Fts5Mprintf(&rc, "%z%s%Q", zSql, zSep, pConfig->azCol[i]);
-  }
-  zSql = sqlite3Fts5Mprintf(&rc, "%z, %Q HIDDEN, %s HIDDEN)",
-      zSql, pConfig->zName, FTS5_RANK_NAME
-  );
-
-  assert( zSql || rc==SQLITE_NOMEM );
-  if( zSql ){
-    rc = sqlite3_declare_vtab(pConfig->db, zSql);
-    sqlite3_free(zSql);
-  }
-
-  return rc;
-}
-
-/*
-** Tokenize the text passed via the second and third arguments.
-**
-** The callback is invoked once for each token in the input text. The
-** arguments passed to it are, in order:
-**
-**     void *pCtx          // Copy of 4th argument to sqlite3Fts5Tokenize()
-**     const char *pToken  // Pointer to buffer containing token
-**     int nToken          // Size of token in bytes
-**     int iStart          // Byte offset of start of token within input text
-**     int iEnd            // Byte offset of end of token within input text
-**     int iPos            // Position of token in input (first token is 0)
-**
-** If the callback returns a non-zero value the tokenization is abandoned
-** and no further callbacks are issued.
-**
-** This function returns SQLITE_OK if successful or an SQLite error code
-** if an error occurs. If the tokenization was abandoned early because
-** the callback returned SQLITE_DONE, this is not an error and this function
-** still returns SQLITE_OK. Or, if the tokenization was abandoned early
-** because the callback returned another non-zero value, it is assumed
-** to be an SQLite error code and returned to the caller.
-*/
-static int sqlite3Fts5Tokenize(
-  Fts5Config *pConfig,            /* FTS5 Configuration object */
-  int flags,                      /* FTS5_TOKENIZE_* flags */
-  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 rc = SQLITE_OK;
-  if( pText ){
-    if( pConfig->t.pTok==0 ){
-      rc = sqlite3Fts5LoadTokenizer(pConfig);
-    }
-    if( rc==SQLITE_OK ){
-      if( pConfig->t.pApi1 ){
-        rc = pConfig->t.pApi1->xTokenize(
-            pConfig->t.pTok, pCtx, flags, pText, nText, xToken
-        );
-      }else{
-        rc = pConfig->t.pApi2->xTokenize(pConfig->t.pTok, pCtx, flags,
-            pText, nText, pConfig->t.pLocale, pConfig->t.nLocale, xToken
-        );
-      }
-    }
-  }
-  return rc;
-}
-
-/*
-** Argument pIn points to the first character in what is expected to be
-** a comma-separated list of SQL literals followed by a ')' character.
-** If it actually is this, return a pointer to the ')'. Otherwise, return
-** NULL to indicate a parse error.
-*/
-static const char *fts5ConfigSkipArgs(const char *pIn){
-  const char *p = pIn;
-
-  while( 1 ){
-    p = fts5ConfigSkipWhitespace(p);
-    p = fts5ConfigSkipLiteral(p);
-    p = fts5ConfigSkipWhitespace(p);
-    if( p==0 || *p==')' ) break;
-    if( *p!=',' ){
-      p = 0;
-      break;
-    }
-    p++;
-  }
-
-  return p;
-}
-
-/*
-** Parameter zIn contains a rank() function specification. The format of
-** this is:
-**
-**   + Bareword (function name)
-**   + Open parenthesis - "("
-**   + Zero or more SQL literals in a comma separated list
-**   + Close parenthesis - ")"
-*/
-static int sqlite3Fts5ConfigParseRank(
-  const char *zIn,                /* Input string */
-  char **pzRank,                  /* OUT: Rank function name */
-  char **pzRankArgs               /* OUT: Rank function arguments */
-){
-  const char *p = zIn;
-  const char *pRank;
-  char *zRank = 0;
-  char *zRankArgs = 0;
-  int rc = SQLITE_OK;
-
-  *pzRank = 0;
-  *pzRankArgs = 0;
-
-  if( p==0 ){
-    rc = SQLITE_ERROR;
-  }else{
-    p = fts5ConfigSkipWhitespace(p);
-    pRank = p;
-    p = fts5ConfigSkipBareword(p);
-
-    if( p ){
-      zRank = sqlite3Fts5MallocZero(&rc, 1 + p - pRank);
-      if( zRank ) memcpy(zRank, pRank, p-pRank);
-    }else{
-      rc = SQLITE_ERROR;
-    }
-
-    if( rc==SQLITE_OK ){
-      p = fts5ConfigSkipWhitespace(p);
-      if( *p!='(' ) rc = SQLITE_ERROR;
-      p++;
-    }
-    if( rc==SQLITE_OK ){
-      const char *pArgs;
-      p = fts5ConfigSkipWhitespace(p);
-      pArgs = p;
-      if( *p!=')' ){
-        p = fts5ConfigSkipArgs(p);
-        if( p==0 ){
-          rc = SQLITE_ERROR;
-        }else{
-          zRankArgs = sqlite3Fts5MallocZero(&rc, 1 + p - pArgs);
-          if( zRankArgs ) memcpy(zRankArgs, pArgs, p-pArgs);
-        }
-      }
-    }
-  }
-
-  if( rc!=SQLITE_OK ){
-    sqlite3_free(zRank);
-    assert( zRankArgs==0 );
-  }else{
-    *pzRank = zRank;
-    *pzRankArgs = zRankArgs;
-  }
-  return rc;
-}
-
-static int sqlite3Fts5ConfigSetValue(
-  Fts5Config *pConfig,
-  const char *zKey,
-  sqlite3_value *pVal,
-  int *pbBadkey
-){
-  int rc = SQLITE_OK;
-
-  if( 0==sqlite3_stricmp(zKey, "pgsz") ){
-    int pgsz = 0;
-    if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
-      pgsz = sqlite3_value_int(pVal);
-    }
-    if( pgsz<32 || pgsz>FTS5_MAX_PAGE_SIZE ){
-      *pbBadkey = 1;
-    }else{
-      pConfig->pgsz = pgsz;
-    }
-  }
-
-  else if( 0==sqlite3_stricmp(zKey, "hashsize") ){
-    int nHashSize = -1;
-    if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
-      nHashSize = sqlite3_value_int(pVal);
-    }
-    if( nHashSize<=0 ){
-      *pbBadkey = 1;
-    }else{
-      pConfig->nHashSize = nHashSize;
-    }
-  }
-
-  else if( 0==sqlite3_stricmp(zKey, "automerge") ){
-    int nAutomerge = -1;
-    if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
-      nAutomerge = sqlite3_value_int(pVal);
-    }
-    if( nAutomerge<0 || nAutomerge>64 ){
-      *pbBadkey = 1;
-    }else{
-      if( nAutomerge==1 ) nAutomerge = FTS5_DEFAULT_AUTOMERGE;
-      pConfig->nAutomerge = nAutomerge;
-    }
-  }
-
-  else if( 0==sqlite3_stricmp(zKey, "usermerge") ){
-    int nUsermerge = -1;
-    if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
-      nUsermerge = sqlite3_value_int(pVal);
-    }
-    if( nUsermerge<2 || nUsermerge>16 ){
-      *pbBadkey = 1;
-    }else{
-      pConfig->nUsermerge = nUsermerge;
-    }
-  }
-
-  else if( 0==sqlite3_stricmp(zKey, "crisismerge") ){
-    int nCrisisMerge = -1;
-    if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
-      nCrisisMerge = sqlite3_value_int(pVal);
-    }
-    if( nCrisisMerge<0 ){
-      *pbBadkey = 1;
-    }else{
-      if( nCrisisMerge<=1 ) nCrisisMerge = FTS5_DEFAULT_CRISISMERGE;
-      if( nCrisisMerge>=FTS5_MAX_SEGMENT ) nCrisisMerge = FTS5_MAX_SEGMENT-1;
-      pConfig->nCrisisMerge = nCrisisMerge;
-    }
-  }
-
-  else if( 0==sqlite3_stricmp(zKey, "deletemerge") ){
-    int nVal = -1;
-    if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
-      nVal = sqlite3_value_int(pVal);
-    }else{
-      *pbBadkey = 1;
-    }
-    if( nVal<0 ) nVal = FTS5_DEFAULT_DELETE_AUTOMERGE;
-    if( nVal>100 ) nVal = 0;
-    pConfig->nDeleteMerge = nVal;
-  }
-
-  else if( 0==sqlite3_stricmp(zKey, "rank") ){
-    const char *zIn = (const char*)sqlite3_value_text(pVal);
-    char *zRank;
-    char *zRankArgs;
-    rc = sqlite3Fts5ConfigParseRank(zIn, &zRank, &zRankArgs);
-    if( rc==SQLITE_OK ){
-      sqlite3_free(pConfig->zRank);
-      sqlite3_free(pConfig->zRankArgs);
-      pConfig->zRank = zRank;
-      pConfig->zRankArgs = zRankArgs;
-    }else if( rc==SQLITE_ERROR ){
-      rc = SQLITE_OK;
-      *pbBadkey = 1;
-    }
-  }
-
-  else if( 0==sqlite3_stricmp(zKey, "secure-delete") ){
-    int bVal = -1;
-    if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
-      bVal = sqlite3_value_int(pVal);
-    }
-    if( bVal<0 ){
-      *pbBadkey = 1;
-    }else{
-      pConfig->bSecureDelete = (bVal ? 1 : 0);
-    }
-  }
-
-  else if( 0==sqlite3_stricmp(zKey, "insttoken") ){
-    int bVal = -1;
-    if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
-      bVal = sqlite3_value_int(pVal);
-    }
-    if( bVal<0 ){
-      *pbBadkey = 1;
-    }else{
-      pConfig->bPrefixInsttoken = (bVal ? 1 : 0);
-    }
-
-  }else{
-    *pbBadkey = 1;
-  }
-  return rc;
-}
-
-/*
-** Load the contents of the %_config table into memory.
-*/
-static int sqlite3Fts5ConfigLoad(Fts5Config *pConfig, int iCookie){
-  const char *zSelect = "SELECT k, v FROM %Q.'%q_config'";
-  char *zSql;
-  sqlite3_stmt *p = 0;
-  int rc = SQLITE_OK;
-  int iVersion = 0;
-
-  /* Set default values */
-  pConfig->pgsz = FTS5_DEFAULT_PAGE_SIZE;
-  pConfig->nAutomerge = FTS5_DEFAULT_AUTOMERGE;
-  pConfig->nUsermerge = FTS5_DEFAULT_USERMERGE;
-  pConfig->nCrisisMerge = FTS5_DEFAULT_CRISISMERGE;
-  pConfig->nHashSize = FTS5_DEFAULT_HASHSIZE;
-  pConfig->nDeleteMerge = FTS5_DEFAULT_DELETE_AUTOMERGE;
-
-  zSql = sqlite3Fts5Mprintf(&rc, zSelect, pConfig->zDb, pConfig->zName);
-  if( zSql ){
-    rc = sqlite3_prepare_v2(pConfig->db, zSql, -1, &p, 0);
-    sqlite3_free(zSql);
-  }
-
-  assert( rc==SQLITE_OK || p==0 );
-  if( rc==SQLITE_OK ){
-    while( SQLITE_ROW==sqlite3_step(p) ){
-      const char *zK = (const char*)sqlite3_column_text(p, 0);
-      sqlite3_value *pVal = sqlite3_column_value(p, 1);
-      if( 0==sqlite3_stricmp(zK, "version") ){
-        iVersion = sqlite3_value_int(pVal);
-      }else{
-        int bDummy = 0;
-        sqlite3Fts5ConfigSetValue(pConfig, zK, pVal, &bDummy);
-      }
-    }
-    rc = sqlite3_finalize(p);
-  }
-
-  if( rc==SQLITE_OK
-   && iVersion!=FTS5_CURRENT_VERSION
-   && iVersion!=FTS5_CURRENT_VERSION_SECUREDELETE
-  ){
-    rc = SQLITE_ERROR;
-    sqlite3Fts5ConfigErrmsg(pConfig, "invalid fts5 file format "
-        "(found %d, expected %d or %d) - run 'rebuild'",
-        iVersion, FTS5_CURRENT_VERSION, FTS5_CURRENT_VERSION_SECUREDELETE
-    );
-  }else{
-    pConfig->iVersion = iVersion;
-  }
-
-  if( rc==SQLITE_OK ){
-    pConfig->iCookie = iCookie;
-  }
-  return rc;
-}
-
-/*
-** Set (*pConfig->pzErrmsg) to point to an sqlite3_malloc()ed buffer
-** containing the error message created using printf() style formatting
-** string zFmt and its trailing arguments.
-*/
-static void sqlite3Fts5ConfigErrmsg(Fts5Config *pConfig, const char *zFmt, ...){
-  va_list ap;                     /* ... printf arguments */
-  char *zMsg = 0;
-
-  va_start(ap, zFmt);
-  zMsg = sqlite3_vmprintf(zFmt, ap);
-  if( pConfig->pzErrmsg ){
-    assert( *pConfig->pzErrmsg==0 );
-    *pConfig->pzErrmsg = zMsg;
-  }else{
-    sqlite3_free(zMsg);
-  }
-
-  va_end(ap);
-}
-
-/*
-** 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.
-**
-******************************************************************************
-**
-*/
-
-
-
-/* #include "fts5Int.h" */
-/* #include "fts5parse.h" */
-
-#ifndef SQLITE_FTS5_MAX_EXPR_DEPTH
-# define SQLITE_FTS5_MAX_EXPR_DEPTH 256
-#endif
-
-/*
-** All token types in the generated fts5parse.h file are greater than 0.
-*/
-#define FTS5_EOF 0
-
-#define FTS5_LARGEST_INT64  (0xffffffff|(((i64)0x7fffffff)<<32))
-
-typedef struct Fts5ExprTerm Fts5ExprTerm;
-
-/*
-** Functions generated by lemon from fts5parse.y.
-*/
-static void *sqlite3Fts5ParserAlloc(void *(*mallocProc)(u64));
-static void sqlite3Fts5ParserFree(void*, void (*freeProc)(void*));
-static void sqlite3Fts5Parser(void*, int, Fts5Token, Fts5Parse*);
-#ifndef NDEBUG
-/* #include <stdio.h> */
-static void sqlite3Fts5ParserTrace(FILE*, char*);
-#endif
-static int sqlite3Fts5ParserFallback(int);
-
-
-struct Fts5Expr {
-  Fts5Index *pIndex;
-  Fts5Config *pConfig;
-  Fts5ExprNode *pRoot;
-  int bDesc;                      /* Iterate in descending rowid order */
-  int nPhrase;                    /* Number of phrases in expression */
-  Fts5ExprPhrase **apExprPhrase;  /* Pointers to phrase objects */
-};
-
-/*
-** eType:
-**   Expression node type. Usually one of:
-**
-**       FTS5_AND                 (nChild, apChild valid)
-**       FTS5_OR                  (nChild, apChild valid)
-**       FTS5_NOT                 (nChild, apChild valid)
-**       FTS5_STRING              (pNear valid)
-**       FTS5_TERM                (pNear valid)
-**
-**   An expression node with eType==0 may also exist. It always matches zero
-**   rows. This is created when a phrase containing no tokens is parsed.
-**   e.g. "".
-**
-** iHeight:
-**   Distance from this node to furthest leaf. This is always 0 for nodes
-**   of type FTS5_STRING and FTS5_TERM. For all other nodes it is one
-**   greater than the largest child value.
-*/
-struct Fts5ExprNode {
-  int eType;                      /* Node type */
-  int bEof;                       /* True at EOF */
-  int bNomatch;                   /* True if entry is not a match */
-  int iHeight;                    /* Distance to tree leaf nodes */
-
-  /* Next method for this node. */
-  int (*xNext)(Fts5Expr*, Fts5ExprNode*, int, i64);
-
-  i64 iRowid;                     /* Current rowid */
-  Fts5ExprNearset *pNear;         /* For FTS5_STRING - cluster of phrases */
-
-  /* Child nodes. For a NOT node, this array always contains 2 entries. For
-  ** AND or OR nodes, it contains 2 or more entries.  */
-  int nChild;                     /* Number of child nodes */
-  Fts5ExprNode *apChild[FLEXARRAY]; /* Array of child nodes */
-};
-
-/* Size (in bytes) of an Fts5ExprNode object that holds up to N children */
-#define SZ_FTS5EXPRNODE(N) \
-  (offsetof(Fts5ExprNode,apChild) + (N)*sizeof(Fts5ExprNode*))
-
-#define Fts5NodeIsString(p) ((p)->eType==FTS5_TERM || (p)->eType==FTS5_STRING)
-
-/*
-** Invoke the xNext method of an Fts5ExprNode object. This macro should be
-** used as if it has the same signature as the xNext() methods themselves.
-*/
-#define fts5ExprNodeNext(a,b,c,d) (b)->xNext((a), (b), (c), (d))
-
-/*
-** An instance of the following structure represents a single search term
-** or term prefix.
-*/
-struct Fts5ExprTerm {
-  u8 bPrefix;                     /* True for a prefix term */
-  u8 bFirst;                      /* True if token must be first in column */
-  char *pTerm;                    /* Term data */
-  int nQueryTerm;                 /* Effective size of term in bytes */
-  int nFullTerm;                  /* Size of term in bytes incl. tokendata */
-  Fts5IndexIter *pIter;           /* Iterator for this term */
-  Fts5ExprTerm *pSynonym;         /* Pointer to first in list of synonyms */
-};
-
-/*
-** A phrase. One or more terms that must appear in a contiguous sequence
-** within a document for it to match.
-*/
-struct Fts5ExprPhrase {
-  Fts5ExprNode *pNode;            /* FTS5_STRING node this phrase is part of */
-  Fts5Buffer poslist;             /* Current position list */
-  int nTerm;                      /* Number of entries in aTerm[] */
-  Fts5ExprTerm aTerm[FLEXARRAY];  /* Terms that make up this phrase */
-};
-
-/* Size (in bytes) of an Fts5ExprPhrase object that holds up to N terms */
-#define SZ_FTS5EXPRPHRASE(N) \
-    (offsetof(Fts5ExprPhrase,aTerm) + (N)*sizeof(Fts5ExprTerm))
-
-/*
-** One or more phrases that must appear within a certain token distance of
-** each other within each matching document.
-*/
-struct Fts5ExprNearset {
-  int nNear;                      /* NEAR parameter */
-  Fts5Colset *pColset;            /* Columns to search (NULL -> all columns) */
-  int nPhrase;                    /* Number of entries in aPhrase[] array */
-  Fts5ExprPhrase *apPhrase[FLEXARRAY]; /* Array of phrase pointers */
-};
-
-/* Size (in bytes) of an Fts5ExprNearset object covering up to N phrases */
-#define SZ_FTS5EXPRNEARSET(N) \
-  (offsetof(Fts5ExprNearset,apPhrase)+(N)*sizeof(Fts5ExprPhrase*))
-
-/*
-** Parse context.
-*/
-struct Fts5Parse {
-  Fts5Config *pConfig;
-  char *zErr;
-  int rc;
-  int nPhrase;                    /* Size of apPhrase array */
-  Fts5ExprPhrase **apPhrase;      /* Array of all phrases */
-  Fts5ExprNode *pExpr;            /* Result of a successful parse */
-  int bPhraseToAnd;               /* Convert "a+b" to "a AND b" */
-};
-
-/*
-** Check that the Fts5ExprNode.iHeight variables are set correctly in
-** the expression tree passed as the only argument.
-*/
-#ifndef NDEBUG
-static void assert_expr_depth_ok(int rc, Fts5ExprNode *p){
-  if( rc==SQLITE_OK ){
-    if( p->eType==FTS5_TERM || p->eType==FTS5_STRING || p->eType==0 ){
-      assert( p->iHeight==0 );
-    }else{
-      int ii;
-      int iMaxChild = 0;
-      for(ii=0; ii<p->nChild; ii++){
-        Fts5ExprNode *pChild = p->apChild[ii];
-        iMaxChild = MAX(iMaxChild, pChild->iHeight);
-        assert_expr_depth_ok(SQLITE_OK, pChild);
-      }
-      assert( p->iHeight==iMaxChild+1 );
-    }
-  }
-}
-#else
-# define assert_expr_depth_ok(rc, p)
-#endif
-
-static void sqlite3Fts5ParseError(Fts5Parse *pParse, const char *zFmt, ...){
-  va_list ap;
-  va_start(ap, zFmt);
-  if( pParse->rc==SQLITE_OK ){
-    assert( pParse->zErr==0 );
-    pParse->zErr = sqlite3_vmprintf(zFmt, ap);
-    pParse->rc = SQLITE_ERROR;
-  }
-  va_end(ap);
-}
-
-static int fts5ExprIsspace(char t){
-  return t==' ' || t=='\t' || t=='\n' || t=='\r';
-}
-
-/*
-** Read the first token from the nul-terminated string at *pz.
-*/
-static int fts5ExprGetToken(
-  Fts5Parse *pParse,
-  const char **pz,                /* IN/OUT: Pointer into buffer */
-  Fts5Token *pToken
-){
-  const char *z = *pz;
-  int tok;
-
-  /* Skip past any whitespace */
-  while( fts5ExprIsspace(*z) ) z++;
-
-  pToken->p = z;
-  pToken->n = 1;
-  switch( *z ){
-    case '(':  tok = FTS5_LP;    break;
-    case ')':  tok = FTS5_RP;    break;
-    case '{':  tok = FTS5_LCP;   break;
-    case '}':  tok = FTS5_RCP;   break;
-    case ':':  tok = FTS5_COLON; break;
-    case ',':  tok = FTS5_COMMA; break;
-    case '+':  tok = FTS5_PLUS;  break;
-    case '*':  tok = FTS5_STAR;  break;
-    case '-':  tok = FTS5_MINUS; break;
-    case '^':  tok = FTS5_CARET; break;
-    case '\0': tok = FTS5_EOF;   break;
-
-    case '"': {
-      const char *z2;
-      tok = FTS5_STRING;
-
-      for(z2=&z[1]; 1; z2++){
-        if( z2[0]=='"' ){
-          z2++;
-          if( z2[0]!='"' ) break;
-        }
-        if( z2[0]=='\0' ){
-          sqlite3Fts5ParseError(pParse, "unterminated string");
-          return FTS5_EOF;
-        }
-      }
-      pToken->n = (z2 - z);
-      break;
-    }
-
-    default: {
-      const char *z2;
-      if( sqlite3Fts5IsBareword(z[0])==0 ){
-        sqlite3Fts5ParseError(pParse, "fts5: syntax error near \"%.1s\"", z);
-        return FTS5_EOF;
-      }
-      tok = FTS5_STRING;
-      for(z2=&z[1]; sqlite3Fts5IsBareword(*z2); z2++);
-      pToken->n = (z2 - z);
-      if( pToken->n==2 && memcmp(pToken->p, "OR", 2)==0 )  tok = FTS5_OR;
-      if( pToken->n==3 && memcmp(pToken->p, "NOT", 3)==0 ) tok = FTS5_NOT;
-      if( pToken->n==3 && memcmp(pToken->p, "AND", 3)==0 ) tok = FTS5_AND;
-      break;
-    }
-  }
-
-  *pz = &pToken->p[pToken->n];
-  return tok;
-}
-
-static void *fts5ParseAlloc(u64 t){ return sqlite3_malloc64((sqlite3_int64)t);}
-static void fts5ParseFree(void *p){ sqlite3_free(p); }
-
-static int sqlite3Fts5ExprNew(
-  Fts5Config *pConfig,            /* FTS5 Configuration */
-  int bPhraseToAnd,
-  int iCol,
-  const char *zExpr,              /* Expression text */
-  Fts5Expr **ppNew,
-  char **pzErr
-){
-  Fts5Parse sParse;
-  Fts5Token token;
-  const char *z = zExpr;
-  int t;                          /* Next token type */
-  void *pEngine;
-  Fts5Expr *pNew;
-
-  *ppNew = 0;
-  *pzErr = 0;
-  memset(&sParse, 0, sizeof(sParse));
-  sParse.bPhraseToAnd = bPhraseToAnd;
-  pEngine = sqlite3Fts5ParserAlloc(fts5ParseAlloc);
-  if( pEngine==0 ){ return SQLITE_NOMEM; }
-  sParse.pConfig = pConfig;
-
-  do {
-    t = fts5ExprGetToken(&sParse, &z, &token);
-    sqlite3Fts5Parser(pEngine, t, token, &sParse);
-  }while( sParse.rc==SQLITE_OK && t!=FTS5_EOF );
-  sqlite3Fts5ParserFree(pEngine, fts5ParseFree);
-
-  assert( sParse.pExpr || sParse.rc!=SQLITE_OK );
-  assert_expr_depth_ok(sParse.rc, sParse.pExpr);
-
-  /* If the LHS of the MATCH expression was a user column, apply the
-  ** implicit column-filter.  */
-  if( sParse.rc==SQLITE_OK && iCol<pConfig->nCol ){
-    int n = SZ_FTS5COLSET(1);
-    Fts5Colset *pColset = (Fts5Colset*)sqlite3Fts5MallocZero(&sParse.rc, n);
-    if( pColset ){
-      pColset->nCol = 1;
-      pColset->aiCol[0] = iCol;
-      sqlite3Fts5ParseSetColset(&sParse, sParse.pExpr, pColset);
-    }
-  }
-
-  assert( sParse.rc!=SQLITE_OK || sParse.zErr==0 );
-  if( sParse.rc==SQLITE_OK ){
-    *ppNew = pNew = sqlite3_malloc64(sizeof(Fts5Expr));
-    if( pNew==0 ){
-      sParse.rc = SQLITE_NOMEM;
-      sqlite3Fts5ParseNodeFree(sParse.pExpr);
-    }else{
-      pNew->pRoot = sParse.pExpr;
-      pNew->pIndex = 0;
-      pNew->pConfig = pConfig;
-      pNew->apExprPhrase = sParse.apPhrase;
-      pNew->nPhrase = sParse.nPhrase;
-      pNew->bDesc = 0;
-      sParse.apPhrase = 0;
-    }
-  }else{
-    sqlite3Fts5ParseNodeFree(sParse.pExpr);
-  }
-
-  sqlite3_free(sParse.apPhrase);
-  if( 0==*pzErr ){
-    *pzErr = sParse.zErr;
-  }else{
-    sqlite3_free(sParse.zErr);
-  }
-  return sParse.rc;
-}
-
-/*
-** Assuming that buffer z is at least nByte bytes in size and contains a
-** valid utf-8 string, return the number of characters in the string.
-*/
-static int fts5ExprCountChar(const char *z, int nByte){
-  int nRet = 0;
-  int ii;
-  for(ii=0; ii<nByte; ii++){
-    if( (z[ii] & 0xC0)!=0x80 ) nRet++;
-  }
-  return nRet;
-}
-
-/*
-** This function is only called when using the special 'trigram' tokenizer.
-** Argument zText contains the text of a LIKE or GLOB pattern matched
-** against column iCol. This function creates and compiles an FTS5 MATCH
-** expression that will match a superset of the rows matched by the LIKE or
-** GLOB. If successful, SQLITE_OK is returned. Otherwise, an SQLite error
-** code.
-*/
-static int sqlite3Fts5ExprPattern(
-  Fts5Config *pConfig, int bGlob, int iCol, const char *zText, Fts5Expr **pp
-){
-  i64 nText = strlen(zText);
-  char *zExpr = (char*)sqlite3_malloc64(nText*4 + 1);
-  int rc = SQLITE_OK;
-
-  if( zExpr==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    char aSpec[3];
-    int iOut = 0;
-    int i = 0;
-    int iFirst = 0;
-
-    if( bGlob==0 ){
-      aSpec[0] = '_';
-      aSpec[1] = '%';
-      aSpec[2] = 0;
-    }else{
-      aSpec[0] = '*';
-      aSpec[1] = '?';
-      aSpec[2] = '[';
-    }
-
-    while( i<=nText ){
-      if( i==nText
-       || zText[i]==aSpec[0] || zText[i]==aSpec[1] || zText[i]==aSpec[2]
-      ){
-
-        if( fts5ExprCountChar(&zText[iFirst], i-iFirst)>=3 ){
-          int jj;
-          zExpr[iOut++] = '"';
-          for(jj=iFirst; jj<i; jj++){
-            zExpr[iOut++] = zText[jj];
-            if( zText[jj]=='"' ) zExpr[iOut++] = '"';
-          }
-          zExpr[iOut++] = '"';
-          zExpr[iOut++] = ' ';
-        }
-        if( zText[i]==aSpec[2] ){
-          i += 2;
-          if( zText[i-1]=='^' ) i++;
-          while( i<nText && zText[i]!=']' ) i++;
-        }
-        iFirst = i+1;
-      }
-      i++;
-    }
-    if( iOut>0 ){
-      int bAnd = 0;
-      if( pConfig->eDetail!=FTS5_DETAIL_FULL ){
-        bAnd = 1;
-        if( pConfig->eDetail==FTS5_DETAIL_NONE ){
-          iCol = pConfig->nCol;
-        }
-      }
-      zExpr[iOut] = '\0';
-      rc = sqlite3Fts5ExprNew(pConfig, bAnd, iCol, zExpr, pp,pConfig->pzErrmsg);
-    }else{
-      *pp = 0;
-    }
-    sqlite3_free(zExpr);
-  }
-
-  return rc;
-}
-
-/*
-** Free the expression node object passed as the only argument.
-*/
-static void sqlite3Fts5ParseNodeFree(Fts5ExprNode *p){
-  if( p ){
-    int i;
-    for(i=0; i<p->nChild; i++){
-      sqlite3Fts5ParseNodeFree(p->apChild[i]);
-    }
-    sqlite3Fts5ParseNearsetFree(p->pNear);
-    sqlite3_free(p);
-  }
-}
-
-/*
-** Free the expression object passed as the only argument.
-*/
-static void sqlite3Fts5ExprFree(Fts5Expr *p){
-  if( p ){
-    sqlite3Fts5ParseNodeFree(p->pRoot);
-    sqlite3_free(p->apExprPhrase);
-    sqlite3_free(p);
-  }
-}
-
-static int sqlite3Fts5ExprAnd(Fts5Expr **pp1, Fts5Expr *p2){
-  Fts5Parse sParse;
-  memset(&sParse, 0, sizeof(sParse));
-
-  if( *pp1 && p2 ){
-    Fts5Expr *p1 = *pp1;
-    int nPhrase = p1->nPhrase + p2->nPhrase;
-
-    p1->pRoot = sqlite3Fts5ParseNode(&sParse, FTS5_AND, p1->pRoot, p2->pRoot,0);
-    p2->pRoot = 0;
-
-    if( sParse.rc==SQLITE_OK ){
-      Fts5ExprPhrase **ap = (Fts5ExprPhrase**)sqlite3_realloc64(
-          p1->apExprPhrase, nPhrase * sizeof(Fts5ExprPhrase*)
-      );
-      if( ap==0 ){
-        sParse.rc = SQLITE_NOMEM;
-      }else{
-        int i;
-        memmove(&ap[p2->nPhrase], ap, p1->nPhrase*sizeof(Fts5ExprPhrase*));
-        for(i=0; i<p2->nPhrase; i++){
-          ap[i] = p2->apExprPhrase[i];
-        }
-        p1->nPhrase = nPhrase;
-        p1->apExprPhrase = ap;
-      }
-    }
-    sqlite3_free(p2->apExprPhrase);
-    sqlite3_free(p2);
-  }else if( p2 ){
-    *pp1 = p2;
-  }
-
-  return sParse.rc;
-}
-
-/*
-** Argument pTerm must be a synonym iterator. Return the current rowid
-** that it points to.
-*/
-static i64 fts5ExprSynonymRowid(Fts5ExprTerm *pTerm, int bDesc, int *pbEof){
-  i64 iRet = 0;
-  int bRetValid = 0;
-  Fts5ExprTerm *p;
-
-  assert( pTerm );
-  assert( pTerm->pSynonym );
-  assert( bDesc==0 || bDesc==1 );
-  for(p=pTerm; p; p=p->pSynonym){
-    if( 0==sqlite3Fts5IterEof(p->pIter) ){
-      i64 iRowid = p->pIter->iRowid;
-      if( bRetValid==0 || (bDesc!=(iRowid<iRet)) ){
-        iRet = iRowid;
-        bRetValid = 1;
-      }
-    }
-  }
-
-  if( pbEof && bRetValid==0 ) *pbEof = 1;
-  return iRet;
-}
-
-/*
-** Argument pTerm must be a synonym iterator.
-*/
-static int fts5ExprSynonymList(
-  Fts5ExprTerm *pTerm,
-  i64 iRowid,
-  Fts5Buffer *pBuf,               /* Use this buffer for space if required */
-  u8 **pa, int *pn
-){
-  Fts5PoslistReader aStatic[4];
-  Fts5PoslistReader *aIter = aStatic;
-  int nIter = 0;
-  int nAlloc = 4;
-  int rc = SQLITE_OK;
-  Fts5ExprTerm *p;
-
-  assert( pTerm->pSynonym );
-  for(p=pTerm; p; p=p->pSynonym){
-    Fts5IndexIter *pIter = p->pIter;
-    if( sqlite3Fts5IterEof(pIter)==0 && pIter->iRowid==iRowid ){
-      if( pIter->nData==0 ) continue;
-      if( nIter==nAlloc ){
-        sqlite3_int64 nByte = sizeof(Fts5PoslistReader) * nAlloc * 2;
-        Fts5PoslistReader *aNew = (Fts5PoslistReader*)sqlite3_malloc64(nByte);
-        if( aNew==0 ){
-          rc = SQLITE_NOMEM;
-          goto synonym_poslist_out;
-        }
-        memcpy(aNew, aIter, sizeof(Fts5PoslistReader) * nIter);
-        nAlloc = nAlloc*2;
-        if( aIter!=aStatic ) sqlite3_free(aIter);
-        aIter = aNew;
-      }
-      sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
-      assert( aIter[nIter].bEof==0 );
-      nIter++;
-    }
-  }
-
-  if( nIter==1 ){
-    *pa = (u8*)aIter[0].a;
-    *pn = aIter[0].n;
-  }else{
-    Fts5PoslistWriter writer = {0};
-    i64 iPrev = -1;
-    fts5BufferZero(pBuf);
-    while( 1 ){
-      int i;
-      i64 iMin = FTS5_LARGEST_INT64;
-      for(i=0; i<nIter; i++){
-        if( aIter[i].bEof==0 ){
-          if( aIter[i].iPos==iPrev ){
-            if( sqlite3Fts5PoslistReaderNext(&aIter[i]) ) continue;
-          }
-          if( aIter[i].iPos<iMin ){
-            iMin = aIter[i].iPos;
-          }
-        }
-      }
-      if( iMin==FTS5_LARGEST_INT64 || rc!=SQLITE_OK ) break;
-      rc = sqlite3Fts5PoslistWriterAppend(pBuf, &writer, iMin);
-      iPrev = iMin;
-    }
-    if( rc==SQLITE_OK ){
-      *pa = pBuf->p;
-      *pn = pBuf->n;
-    }
-  }
-
- synonym_poslist_out:
-  if( aIter!=aStatic ) sqlite3_free(aIter);
-  return rc;
-}
-
-
-/*
-** All individual term iterators in pPhrase are guaranteed to be valid and
-** pointing to the same rowid when this function is called. This function
-** checks if the current rowid really is a match, and if so populates
-** the pPhrase->poslist buffer accordingly. Output parameter *pbMatch
-** is set to true if this is really a match, or false otherwise.
-**
-** SQLITE_OK is returned if an error occurs, or an SQLite error code
-** otherwise. It is not considered an error code if the current rowid is
-** not a match.
-*/
-static int fts5ExprPhraseIsMatch(
-  Fts5ExprNode *pNode,            /* Node pPhrase belongs to */
-  Fts5ExprPhrase *pPhrase,        /* Phrase object to initialize */
-  int *pbMatch                    /* OUT: Set to true if really a match */
-){
-  Fts5PoslistWriter writer = {0};
-  Fts5PoslistReader aStatic[4];
-  Fts5PoslistReader *aIter = aStatic;
-  int i;
-  int rc = SQLITE_OK;
-  int bFirst = pPhrase->aTerm[0].bFirst;
-
-  fts5BufferZero(&pPhrase->poslist);
-
-  /* If the aStatic[] array is not large enough, allocate a large array
-  ** using sqlite3_malloc(). This approach could be improved upon. */
-  if( pPhrase->nTerm>ArraySize(aStatic) ){
-    sqlite3_int64 nByte = sizeof(Fts5PoslistReader) * pPhrase->nTerm;
-    aIter = (Fts5PoslistReader*)sqlite3_malloc64(nByte);
-    if( !aIter ) return SQLITE_NOMEM;
-  }
-  memset(aIter, 0, sizeof(Fts5PoslistReader) * pPhrase->nTerm);
-
-  /* Initialize a term iterator for each term in the phrase */
-  for(i=0; i<pPhrase->nTerm; i++){
-    Fts5ExprTerm *pTerm = &pPhrase->aTerm[i];
-    int n = 0;
-    int bFlag = 0;
-    u8 *a = 0;
-    if( pTerm->pSynonym ){
-      Fts5Buffer buf = {0, 0, 0};
-      rc = fts5ExprSynonymList(pTerm, pNode->iRowid, &buf, &a, &n);
-      if( rc ){
-        sqlite3_free(a);
-        goto ismatch_out;
-      }
-      if( a==buf.p ) bFlag = 1;
-    }else{
-      a = (u8*)pTerm->pIter->pData;
-      n = pTerm->pIter->nData;
-    }
-    sqlite3Fts5PoslistReaderInit(a, n, &aIter[i]);
-    aIter[i].bFlag = (u8)bFlag;
-    if( aIter[i].bEof ) goto ismatch_out;
-  }
-
-  while( 1 ){
-    int bMatch;
-    i64 iPos = aIter[0].iPos;
-    do {
-      bMatch = 1;
-      for(i=0; i<pPhrase->nTerm; i++){
-        Fts5PoslistReader *pPos = &aIter[i];
-        i64 iAdj = iPos + i;
-        if( pPos->iPos!=iAdj ){
-          bMatch = 0;
-          while( pPos->iPos<iAdj ){
-            if( sqlite3Fts5PoslistReaderNext(pPos) ) goto ismatch_out;
-          }
-          if( pPos->iPos>iAdj ) iPos = pPos->iPos-i;
-        }
-      }
-    }while( bMatch==0 );
-
-    /* Append position iPos to the output */
-    if( bFirst==0 || FTS5_POS2OFFSET(iPos)==0 ){
-      rc = sqlite3Fts5PoslistWriterAppend(&pPhrase->poslist, &writer, iPos);
-      if( rc!=SQLITE_OK ) goto ismatch_out;
-    }
-
-    for(i=0; i<pPhrase->nTerm; i++){
-      if( sqlite3Fts5PoslistReaderNext(&aIter[i]) ) goto ismatch_out;
-    }
-  }
-
- ismatch_out:
-  *pbMatch = (pPhrase->poslist.n>0);
-  for(i=0; i<pPhrase->nTerm; i++){
-    if( aIter[i].bFlag ) sqlite3_free((u8*)aIter[i].a);
-  }
-  if( aIter!=aStatic ) sqlite3_free(aIter);
-  return rc;
-}
-
-typedef struct Fts5LookaheadReader Fts5LookaheadReader;
-struct Fts5LookaheadReader {
-  const u8 *a;                    /* Buffer containing position list */
-  int n;                          /* Size of buffer a[] in bytes */
-  int i;                          /* Current offset in position list */
-  i64 iPos;                       /* Current position */
-  i64 iLookahead;                 /* Next position */
-};
-
-#define FTS5_LOOKAHEAD_EOF (((i64)1) << 62)
-
-static int fts5LookaheadReaderNext(Fts5LookaheadReader *p){
-  p->iPos = p->iLookahead;
-  if( sqlite3Fts5PoslistNext64(p->a, p->n, &p->i, &p->iLookahead) ){
-    p->iLookahead = FTS5_LOOKAHEAD_EOF;
-  }
-  return (p->iPos==FTS5_LOOKAHEAD_EOF);
-}
-
-static int fts5LookaheadReaderInit(
-  const u8 *a, int n,             /* Buffer to read position list from */
-  Fts5LookaheadReader *p          /* Iterator object to initialize */
-){
-  memset(p, 0, sizeof(Fts5LookaheadReader));
-  p->a = a;
-  p->n = n;
-  fts5LookaheadReaderNext(p);
-  return fts5LookaheadReaderNext(p);
-}
-
-typedef struct Fts5NearTrimmer Fts5NearTrimmer;
-struct Fts5NearTrimmer {
-  Fts5LookaheadReader reader;     /* Input iterator */
-  Fts5PoslistWriter writer;       /* Writer context */
-  Fts5Buffer *pOut;               /* Output poslist */
-};
-
-/*
-** The near-set object passed as the first argument contains more than
-** one phrase. All phrases currently point to the same row. The
-** Fts5ExprPhrase.poslist buffers are populated accordingly. This function
-** tests if the current row contains instances of each phrase sufficiently
-** close together to meet the NEAR constraint. Non-zero is returned if it
-** does, or zero otherwise.
-**
-** If in/out parameter (*pRc) is set to other than SQLITE_OK when this
-** function is called, it is a no-op. Or, if an error (e.g. SQLITE_NOMEM)
-** occurs within this function (*pRc) is set accordingly before returning.
-** The return value is undefined in both these cases.
-**
-** If no error occurs and non-zero (a match) is returned, the position-list
-** of each phrase object is edited to contain only those entries that
-** meet the constraint before returning.
-*/
-static int fts5ExprNearIsMatch(int *pRc, Fts5ExprNearset *pNear){
-  Fts5NearTrimmer aStatic[4];
-  Fts5NearTrimmer *a = aStatic;
-  Fts5ExprPhrase **apPhrase = pNear->apPhrase;
-
-  int i;
-  int rc = *pRc;
-  int bMatch;
-
-  assert( pNear->nPhrase>1 );
-
-  /* If the aStatic[] array is not large enough, allocate a large array
-  ** using sqlite3_malloc(). This approach could be improved upon. */
-  if( pNear->nPhrase>ArraySize(aStatic) ){
-    sqlite3_int64 nByte = sizeof(Fts5NearTrimmer) * pNear->nPhrase;
-    a = (Fts5NearTrimmer*)sqlite3Fts5MallocZero(&rc, nByte);
-  }else{
-    memset(aStatic, 0, sizeof(aStatic));
-  }
-  if( rc!=SQLITE_OK ){
-    *pRc = rc;
-    return 0;
-  }
-
-  /* Initialize a lookahead iterator for each phrase. After passing the
-  ** buffer and buffer size to the lookaside-reader init function, zero
-  ** the phrase poslist buffer. The new poslist for the phrase (containing
-  ** the same entries as the original with some entries removed on account
-  ** of the NEAR constraint) is written over the original even as it is
-  ** being read. This is safe as the entries for the new poslist are a
-  ** subset of the old, so it is not possible for data yet to be read to
-  ** be overwritten.  */
-  for(i=0; i<pNear->nPhrase; i++){
-    Fts5Buffer *pPoslist = &apPhrase[i]->poslist;
-    fts5LookaheadReaderInit(pPoslist->p, pPoslist->n, &a[i].reader);
-    pPoslist->n = 0;
-    a[i].pOut = pPoslist;
-  }
-
-  while( 1 ){
-    int iAdv;
-    i64 iMin;
-    i64 iMax;
-
-    /* This block advances the phrase iterators until they point to a set of
-    ** entries that together comprise a match.  */
-    iMax = a[0].reader.iPos;
-    do {
-      bMatch = 1;
-      for(i=0; i<pNear->nPhrase; i++){
-        Fts5LookaheadReader *pPos = &a[i].reader;
-        iMin = iMax - pNear->apPhrase[i]->nTerm - pNear->nNear;
-        if( pPos->iPos<iMin || pPos->iPos>iMax ){
-          bMatch = 0;
-          while( pPos->iPos<iMin ){
-            if( fts5LookaheadReaderNext(pPos) ) goto ismatch_out;
-          }
-          if( pPos->iPos>iMax ) iMax = pPos->iPos;
-        }
-      }
-    }while( bMatch==0 );
-
-    /* Add an entry to each output position list */
-    for(i=0; i<pNear->nPhrase; i++){
-      i64 iPos = a[i].reader.iPos;
-      Fts5PoslistWriter *pWriter = &a[i].writer;
-      if( a[i].pOut->n==0 || iPos!=pWriter->iPrev ){
-        sqlite3Fts5PoslistWriterAppend(a[i].pOut, pWriter, iPos);
-      }
-    }
-
-    iAdv = 0;
-    iMin = a[0].reader.iLookahead;
-    for(i=0; i<pNear->nPhrase; i++){
-      if( a[i].reader.iLookahead < iMin ){
-        iMin = a[i].reader.iLookahead;
-        iAdv = i;
-      }
-    }
-    if( fts5LookaheadReaderNext(&a[iAdv].reader) ) goto ismatch_out;
-  }
-
-  ismatch_out: {
-    int bRet = a[0].pOut->n>0;
-    *pRc = rc;
-    if( a!=aStatic ) sqlite3_free(a);
-    return bRet;
-  }
-}
-
-/*
-** Advance iterator pIter until it points to a value equal to or laster
-** than the initial value of *piLast. If this means the iterator points
-** to a value laster than *piLast, update *piLast to the new lastest value.
-**
-** If the iterator reaches EOF, set *pbEof to true before returning. If
-** an error occurs, set *pRc to an error code. If either *pbEof or *pRc
-** are set, return a non-zero value. Otherwise, return zero.
-*/
-static int fts5ExprAdvanceto(
-  Fts5IndexIter *pIter,           /* Iterator to advance */
-  int bDesc,                      /* True if iterator is "rowid DESC" */
-  i64 *piLast,                    /* IN/OUT: Lastest rowid seen so far */
-  int *pRc,                       /* OUT: Error code */
-  int *pbEof                      /* OUT: Set to true if EOF */
-){
-  i64 iLast = *piLast;
-  i64 iRowid;
-
-  iRowid = pIter->iRowid;
-  if( (bDesc==0 && iLast>iRowid) || (bDesc && iLast<iRowid) ){
-    int rc = sqlite3Fts5IterNextFrom(pIter, iLast);
-    if( rc || sqlite3Fts5IterEof(pIter) ){
-      *pRc = rc;
-      *pbEof = 1;
-      return 1;
-    }
-    iRowid = pIter->iRowid;
-    assert( (bDesc==0 && iRowid>=iLast) || (bDesc==1 && iRowid<=iLast) );
-  }
-  *piLast = iRowid;
-
-  return 0;
-}
-
-static int fts5ExprSynonymAdvanceto(
-  Fts5ExprTerm *pTerm,            /* Term iterator to advance */
-  int bDesc,                      /* True if iterator is "rowid DESC" */
-  i64 *piLast,                    /* IN/OUT: Lastest rowid seen so far */
-  int *pRc                        /* OUT: Error code */
-){
-  int rc = SQLITE_OK;
-  i64 iLast = *piLast;
-  Fts5ExprTerm *p;
-  int bEof = 0;
-
-  for(p=pTerm; rc==SQLITE_OK && p; p=p->pSynonym){
-    if( sqlite3Fts5IterEof(p->pIter)==0 ){
-      i64 iRowid = p->pIter->iRowid;
-      if( (bDesc==0 && iLast>iRowid) || (bDesc && iLast<iRowid) ){
-        rc = sqlite3Fts5IterNextFrom(p->pIter, iLast);
-      }
-    }
-  }
-
-  if( rc!=SQLITE_OK ){
-    *pRc = rc;
-    bEof = 1;
-  }else{
-    *piLast = fts5ExprSynonymRowid(pTerm, bDesc, &bEof);
-  }
-  return bEof;
-}
-
-
-static int fts5ExprNearTest(
-  int *pRc,
-  Fts5Expr *pExpr,                /* Expression that pNear is a part of */
-  Fts5ExprNode *pNode             /* The "NEAR" node (FTS5_STRING) */
-){
-  Fts5ExprNearset *pNear = pNode->pNear;
-  int rc = *pRc;
-
-  if( pExpr->pConfig->eDetail!=FTS5_DETAIL_FULL ){
-    Fts5ExprTerm *pTerm;
-    Fts5ExprPhrase *pPhrase = pNear->apPhrase[0];
-    pPhrase->poslist.n = 0;
-    for(pTerm=&pPhrase->aTerm[0]; pTerm; pTerm=pTerm->pSynonym){
-      Fts5IndexIter *pIter = pTerm->pIter;
-      if( sqlite3Fts5IterEof(pIter)==0 ){
-        if( pIter->iRowid==pNode->iRowid && pIter->nData>0 ){
-          pPhrase->poslist.n = 1;
-        }
-      }
-    }
-    return pPhrase->poslist.n;
-  }else{
-    int i;
-
-    /* Check that each phrase in the nearset matches the current row.
-    ** Populate the pPhrase->poslist buffers at the same time. If any
-    ** phrase is not a match, break out of the loop early.  */
-    for(i=0; rc==SQLITE_OK && i<pNear->nPhrase; i++){
-      Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
-      if( pPhrase->nTerm>1 || pPhrase->aTerm[0].pSynonym
-       || pNear->pColset || pPhrase->aTerm[0].bFirst
-      ){
-        int bMatch = 0;
-        rc = fts5ExprPhraseIsMatch(pNode, pPhrase, &bMatch);
-        if( bMatch==0 ) break;
-      }else{
-        Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
-        fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
-      }
-    }
-
-    *pRc = rc;
-    if( i==pNear->nPhrase && (i==1 || fts5ExprNearIsMatch(pRc, pNear)) ){
-      return 1;
-    }
-    return 0;
-  }
-}
-
-
-/*
-** Initialize all term iterators in the pNear object. If any term is found
-** to match no documents at all, return immediately without initializing any
-** further iterators.
-**
-** If an error occurs, return an SQLite error code. Otherwise, return
-** SQLITE_OK. It is not considered an error if some term matches zero
-** documents.
-*/
-static int fts5ExprNearInitAll(
-  Fts5Expr *pExpr,
-  Fts5ExprNode *pNode
-){
-  Fts5ExprNearset *pNear = pNode->pNear;
-  int i;
-
-  assert( pNode->bNomatch==0 );
-  for(i=0; i<pNear->nPhrase; i++){
-    Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
-    if( pPhrase->nTerm==0 ){
-      pNode->bEof = 1;
-      return SQLITE_OK;
-    }else{
-      int j;
-      for(j=0; j<pPhrase->nTerm; j++){
-        Fts5ExprTerm *pTerm = &pPhrase->aTerm[j];
-        Fts5ExprTerm *p;
-        int bHit = 0;
-
-        for(p=pTerm; p; p=p->pSynonym){
-          int rc;
-          if( p->pIter ){
-            sqlite3Fts5IterClose(p->pIter);
-            p->pIter = 0;
-          }
-          rc = sqlite3Fts5IndexQuery(
-              pExpr->pIndex, p->pTerm, p->nQueryTerm,
-              (pTerm->bPrefix ? FTS5INDEX_QUERY_PREFIX : 0) |
-              (pExpr->bDesc ? FTS5INDEX_QUERY_DESC : 0),
-              pNear->pColset,
-              &p->pIter
-          );
-          assert( (rc==SQLITE_OK)==(p->pIter!=0) );
-          if( rc!=SQLITE_OK ) return rc;
-          if( 0==sqlite3Fts5IterEof(p->pIter) ){
-            bHit = 1;
-          }
-        }
-
-        if( bHit==0 ){
-          pNode->bEof = 1;
-          return SQLITE_OK;
-        }
-      }
-    }
-  }
-
-  pNode->bEof = 0;
-  return SQLITE_OK;
-}
-
-/*
-** If pExpr is an ASC iterator, this function returns a value with the
-** same sign as:
-**
-**   (iLhs - iRhs)
-**
-** Otherwise, if this is a DESC iterator, the opposite is returned:
-**
-**   (iRhs - iLhs)
-*/
-static int fts5RowidCmp(
-  Fts5Expr *pExpr,
-  i64 iLhs,
-  i64 iRhs
-){
-  assert( pExpr->bDesc==0 || pExpr->bDesc==1 );
-  if( pExpr->bDesc==0 ){
-    if( iLhs<iRhs ) return -1;
-    return (iLhs > iRhs);
-  }else{
-    if( iLhs>iRhs ) return -1;
-    return (iLhs < iRhs);
-  }
-}
-
-static void fts5ExprSetEof(Fts5ExprNode *pNode){
-  int i;
-  pNode->bEof = 1;
-  pNode->bNomatch = 0;
-  for(i=0; i<pNode->nChild; i++){
-    fts5ExprSetEof(pNode->apChild[i]);
-  }
-}
-
-static void fts5ExprNodeZeroPoslist(Fts5ExprNode *pNode){
-  if( pNode->eType==FTS5_STRING || pNode->eType==FTS5_TERM ){
-    Fts5ExprNearset *pNear = pNode->pNear;
-    int i;
-    for(i=0; i<pNear->nPhrase; i++){
-      Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
-      pPhrase->poslist.n = 0;
-    }
-  }else{
-    int i;
-    for(i=0; i<pNode->nChild; i++){
-      fts5ExprNodeZeroPoslist(pNode->apChild[i]);
-    }
-  }
-}
-
-
-
-/*
-** Compare the values currently indicated by the two nodes as follows:
-**
-**    res = (*p1) - (*p2)
-**
-** Nodes that point to values that come later in the iteration order are
-** considered to be larger. Nodes at EOF are the largest of all.
-**
-** This means that if the iteration order is ASC, then numerically larger
-** rowids are considered larger. Or if it is the default DESC, numerically
-** smaller rowids are larger.
-*/
-static int fts5NodeCompare(
-  Fts5Expr *pExpr,
-  Fts5ExprNode *p1,
-  Fts5ExprNode *p2
-){
-  if( p2->bEof ) return -1;
-  if( p1->bEof ) return +1;
-  return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
-}
-
-/*
-** All individual term iterators in pNear are guaranteed to be valid when
-** this function is called. This function checks if all term iterators
-** point to the same rowid, and if not, advances them until they do.
-** If an EOF is reached before this happens, *pbEof is set to true before
-** returning.
-**
-** SQLITE_OK is returned if an error occurs, or an SQLite error code
-** otherwise. It is not considered an error code if an iterator reaches
-** EOF.
-*/
-static int fts5ExprNodeTest_STRING(
-  Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
-  Fts5ExprNode *pNode
-){
-  Fts5ExprNearset *pNear = pNode->pNear;
-  Fts5ExprPhrase *pLeft = pNear->apPhrase[0];
-  int rc = SQLITE_OK;
-  i64 iLast;                      /* Lastest rowid any iterator points to */
-  int i, j;                       /* Phrase and token index, respectively */
-  int bMatch;                     /* True if all terms are at the same rowid */
-  const int bDesc = pExpr->bDesc;
-
-  /* Check that this node should not be FTS5_TERM */
-  assert( pNear->nPhrase>1
-       || pNear->apPhrase[0]->nTerm>1
-       || pNear->apPhrase[0]->aTerm[0].pSynonym
-       || pNear->apPhrase[0]->aTerm[0].bFirst
-  );
-
-  /* Initialize iLast, the "lastest" rowid any iterator points to. If the
-  ** iterator skips through rowids in the default ascending order, this means
-  ** the maximum rowid. Or, if the iterator is "ORDER BY rowid DESC", then it
-  ** means the minimum rowid.  */
-  if( pLeft->aTerm[0].pSynonym ){
-    iLast = fts5ExprSynonymRowid(&pLeft->aTerm[0], bDesc, 0);
-  }else{
-    iLast = pLeft->aTerm[0].pIter->iRowid;
-  }
-
-  do {
-    bMatch = 1;
-    for(i=0; i<pNear->nPhrase; i++){
-      Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
-      for(j=0; j<pPhrase->nTerm; j++){
-        Fts5ExprTerm *pTerm = &pPhrase->aTerm[j];
-        if( pTerm->pSynonym ){
-          i64 iRowid = fts5ExprSynonymRowid(pTerm, bDesc, 0);
-          if( iRowid==iLast ) continue;
-          bMatch = 0;
-          if( fts5ExprSynonymAdvanceto(pTerm, bDesc, &iLast, &rc) ){
-            pNode->bNomatch = 0;
-            pNode->bEof = 1;
-            return rc;
-          }
-        }else{
-          Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
-          if( pIter->iRowid==iLast ) continue;
-          bMatch = 0;
-          if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
-            return rc;
-          }
-        }
-      }
-    }
-  }while( bMatch==0 );
-
-  pNode->iRowid = iLast;
-  pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
-  assert( pNode->bEof==0 || pNode->bNomatch==0 );
-
-  return rc;
-}
-
-/*
-** Advance the first term iterator in the first phrase of pNear. Set output
-** variable *pbEof to true if it reaches EOF or if an error occurs.
-**
-** Return SQLITE_OK if successful, or an SQLite error code if an error
-** occurs.
-*/
-static int fts5ExprNodeNext_STRING(
-  Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
-  Fts5ExprNode *pNode,            /* FTS5_STRING or FTS5_TERM node */
-  int bFromValid,
-  i64 iFrom
-){
-  Fts5ExprTerm *pTerm = &pNode->pNear->apPhrase[0]->aTerm[0];
-  int rc = SQLITE_OK;
-
-  pNode->bNomatch = 0;
-  if( pTerm->pSynonym ){
-    int bEof = 1;
-    Fts5ExprTerm *p;
-
-    /* Find the firstest rowid any synonym points to. */
-    i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
-
-    /* Advance each iterator that currently points to iRowid. Or, if iFrom
-    ** is valid - each iterator that points to a rowid before iFrom.  */
-    for(p=pTerm; p; p=p->pSynonym){
-      if( sqlite3Fts5IterEof(p->pIter)==0 ){
-        i64 ii = p->pIter->iRowid;
-        if( ii==iRowid
-         || (bFromValid && ii!=iFrom && (ii>iFrom)==pExpr->bDesc)
-        ){
-          if( bFromValid ){
-            rc = sqlite3Fts5IterNextFrom(p->pIter, iFrom);
-          }else{
-            rc = sqlite3Fts5IterNext(p->pIter);
-          }
-          if( rc!=SQLITE_OK ) break;
-          if( sqlite3Fts5IterEof(p->pIter)==0 ){
-            bEof = 0;
-          }
-        }else{
-          bEof = 0;
-        }
-      }
-    }
-
-    /* Set the EOF flag if either all synonym iterators are at EOF or an
-    ** error has occurred.  */
-    pNode->bEof = (rc || bEof);
-  }else{
-    Fts5IndexIter *pIter = pTerm->pIter;
-
-    assert( Fts5NodeIsString(pNode) );
-    if( bFromValid ){
-      rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
-    }else{
-      rc = sqlite3Fts5IterNext(pIter);
-    }
-
-    pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
-  }
-
-  if( pNode->bEof==0 ){
-    assert( rc==SQLITE_OK );
-    rc = fts5ExprNodeTest_STRING(pExpr, pNode);
-  }
-
-  return rc;
-}
-
-
-static int fts5ExprNodeTest_TERM(
-  Fts5Expr *pExpr,                /* Expression that pNear is a part of */
-  Fts5ExprNode *pNode             /* The "NEAR" node (FTS5_TERM) */
-){
-  /* As this "NEAR" object is actually a single phrase that consists
-  ** of a single term only, grab pointers into the poslist managed by the
-  ** fts5_index.c iterator object. This is much faster than synthesizing
-  ** a new poslist the way we have to for more complicated phrase or NEAR
-  ** expressions.  */
-  Fts5ExprPhrase *pPhrase = pNode->pNear->apPhrase[0];
-  Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
-
-  assert( pNode->eType==FTS5_TERM );
-  assert( pNode->pNear->nPhrase==1 && pPhrase->nTerm==1 );
-  assert( pPhrase->aTerm[0].pSynonym==0 );
-
-  pPhrase->poslist.n = pIter->nData;
-  if( pExpr->pConfig->eDetail==FTS5_DETAIL_FULL ){
-    pPhrase->poslist.p = (u8*)pIter->pData;
-  }
-  pNode->iRowid = pIter->iRowid;
-  pNode->bNomatch = (pPhrase->poslist.n==0);
-  return SQLITE_OK;
-}
-
-/*
-** xNext() method for a node of type FTS5_TERM.
-*/
-static int fts5ExprNodeNext_TERM(
-  Fts5Expr *pExpr,
-  Fts5ExprNode *pNode,
-  int bFromValid,
-  i64 iFrom
-){
-  int rc;
-  Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
-
-  assert( pNode->bEof==0 );
-  if( bFromValid ){
-    rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
-  }else{
-    rc = sqlite3Fts5IterNext(pIter);
-  }
-  if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
-    rc = fts5ExprNodeTest_TERM(pExpr, pNode);
-  }else{
-    pNode->bEof = 1;
-    pNode->bNomatch = 0;
-  }
-  return rc;
-}
-
-static void fts5ExprNodeTest_OR(
-  Fts5Expr *pExpr,                /* Expression of which pNode is a part */
-  Fts5ExprNode *pNode             /* Expression node to test */
-){
-  Fts5ExprNode *pNext = pNode->apChild[0];
-  int i;
-
-  for(i=1; i<pNode->nChild; i++){
-    Fts5ExprNode *pChild = pNode->apChild[i];
-    int cmp = fts5NodeCompare(pExpr, pNext, pChild);
-    if( cmp>0 || (cmp==0 && pChild->bNomatch==0) ){
-      pNext = pChild;
-    }
-  }
-  pNode->iRowid = pNext->iRowid;
-  pNode->bEof = pNext->bEof;
-  pNode->bNomatch = pNext->bNomatch;
-}
-
-static int fts5ExprNodeNext_OR(
-  Fts5Expr *pExpr,
-  Fts5ExprNode *pNode,
-  int bFromValid,
-  i64 iFrom
-){
-  int i;
-  i64 iLast = pNode->iRowid;
-
-  for(i=0; i<pNode->nChild; i++){
-    Fts5ExprNode *p1 = pNode->apChild[i];
-    assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
-    if( p1->bEof==0 ){
-      if( (p1->iRowid==iLast)
-       || (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
-      ){
-        int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
-        if( rc!=SQLITE_OK ){
-          pNode->bNomatch = 0;
-          return rc;
-        }
-      }
-    }
-  }
-
-  fts5ExprNodeTest_OR(pExpr, pNode);
-  return SQLITE_OK;
-}
-
-/*
-** Argument pNode is an FTS5_AND node.
-*/
-static int fts5ExprNodeTest_AND(
-  Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
-  Fts5ExprNode *pAnd              /* FTS5_AND node to advance */
-){
-  int iChild;
-  i64 iLast = pAnd->iRowid;
-  int rc = SQLITE_OK;
-  int bMatch;
-
-  assert( pAnd->bEof==0 );
-  do {
-    pAnd->bNomatch = 0;
-    bMatch = 1;
-    for(iChild=0; iChild<pAnd->nChild; iChild++){
-      Fts5ExprNode *pChild = pAnd->apChild[iChild];
-      int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
-      if( cmp>0 ){
-        /* Advance pChild until it points to iLast or laster */
-        rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
-        if( rc!=SQLITE_OK ){
-          pAnd->bNomatch = 0;
-          return rc;
-        }
-      }
-
-      /* If the child node is now at EOF, so is the parent AND node. Otherwise,
-      ** the child node is guaranteed to have advanced at least as far as
-      ** rowid iLast. So if it is not at exactly iLast, pChild->iRowid is the
-      ** new lastest rowid seen so far.  */
-      assert( pChild->bEof || fts5RowidCmp(pExpr, iLast, pChild->iRowid)<=0 );
-      if( pChild->bEof ){
-        fts5ExprSetEof(pAnd);
-        bMatch = 1;
-        break;
-      }else if( iLast!=pChild->iRowid ){
-        bMatch = 0;
-        iLast = pChild->iRowid;
-      }
-
-      if( pChild->bNomatch ){
-        pAnd->bNomatch = 1;
-      }
-    }
-  }while( bMatch==0 );
-
-  if( pAnd->bNomatch && pAnd!=pExpr->pRoot ){
-    fts5ExprNodeZeroPoslist(pAnd);
-  }
-  pAnd->iRowid = iLast;
-  return SQLITE_OK;
-}
-
-static int fts5ExprNodeNext_AND(
-  Fts5Expr *pExpr,
-  Fts5ExprNode *pNode,
-  int bFromValid,
-  i64 iFrom
-){
-  int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
-  if( rc==SQLITE_OK ){
-    rc = fts5ExprNodeTest_AND(pExpr, pNode);
-  }else{
-    pNode->bNomatch = 0;
-  }
-  return rc;
-}
-
-static int fts5ExprNodeTest_NOT(
-  Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
-  Fts5ExprNode *pNode             /* FTS5_NOT node to advance */
-){
-  int rc = SQLITE_OK;
-  Fts5ExprNode *p1 = pNode->apChild[0];
-  Fts5ExprNode *p2 = pNode->apChild[1];
-  assert( pNode->nChild==2 );
-
-  while( rc==SQLITE_OK && p1->bEof==0 ){
-    int cmp = fts5NodeCompare(pExpr, p1, p2);
-    if( cmp>0 ){
-      rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
-      cmp = fts5NodeCompare(pExpr, p1, p2);
-    }
-    assert( rc!=SQLITE_OK || cmp<=0 );
-    if( cmp || p2->bNomatch ) break;
-    rc = fts5ExprNodeNext(pExpr, p1, 0, 0);
-  }
-  pNode->bEof = p1->bEof;
-  pNode->bNomatch = p1->bNomatch;
-  pNode->iRowid = p1->iRowid;
-  if( p1->bEof ){
-    fts5ExprNodeZeroPoslist(p2);
-  }
-  return rc;
-}
-
-static int fts5ExprNodeNext_NOT(
-  Fts5Expr *pExpr,
-  Fts5ExprNode *pNode,
-  int bFromValid,
-  i64 iFrom
-){
-  int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
-  if( rc==SQLITE_OK ){
-    rc = fts5ExprNodeTest_NOT(pExpr, pNode);
-  }
-  if( rc!=SQLITE_OK ){
-    pNode->bNomatch = 0;
-  }
-  return rc;
-}
-
-/*
-** If pNode currently points to a match, this function returns SQLITE_OK
-** without modifying it. Otherwise, pNode is advanced until it does point
-** to a match or EOF is reached.
-*/
-static int fts5ExprNodeTest(
-  Fts5Expr *pExpr,                /* Expression of which pNode is a part */
-  Fts5ExprNode *pNode             /* Expression node to test */
-){
-  int rc = SQLITE_OK;
-  if( pNode->bEof==0 ){
-    switch( pNode->eType ){
-
-      case FTS5_STRING: {
-        rc = fts5ExprNodeTest_STRING(pExpr, pNode);
-        break;
-      }
-
-      case FTS5_TERM: {
-        rc = fts5ExprNodeTest_TERM(pExpr, pNode);
-        break;
-      }
-
-      case FTS5_AND: {
-        rc = fts5ExprNodeTest_AND(pExpr, pNode);
-        break;
-      }
-
-      case FTS5_OR: {
-        fts5ExprNodeTest_OR(pExpr, pNode);
-        break;
-      }
-
-      default: assert( pNode->eType==FTS5_NOT ); {
-        rc = fts5ExprNodeTest_NOT(pExpr, pNode);
-        break;
-      }
-    }
-  }
-  return rc;
-}
-
-
-/*
-** Set node pNode, which is part of expression pExpr, to point to the first
-** match. If there are no matches, set the Node.bEof flag to indicate EOF.
-**
-** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
-** It is not an error if there are no matches.
-*/
-static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){
-  int rc = SQLITE_OK;
-  pNode->bEof = 0;
-  pNode->bNomatch = 0;
-
-  if( Fts5NodeIsString(pNode) ){
-    /* Initialize all term iterators in the NEAR object. */
-    rc = fts5ExprNearInitAll(pExpr, pNode);
-  }else if( pNode->xNext==0 ){
-    pNode->bEof = 1;
-  }else{
-    int i;
-    int nEof = 0;
-    for(i=0; i<pNode->nChild && rc==SQLITE_OK; i++){
-      Fts5ExprNode *pChild = pNode->apChild[i];
-      rc = fts5ExprNodeFirst(pExpr, pNode->apChild[i]);
-      assert( pChild->bEof==0 || pChild->bEof==1 );
-      nEof += pChild->bEof;
-    }
-    pNode->iRowid = pNode->apChild[0]->iRowid;
-
-    switch( pNode->eType ){
-      case FTS5_AND:
-        if( nEof>0 ) fts5ExprSetEof(pNode);
-        break;
-
-      case FTS5_OR:
-        if( pNode->nChild==nEof ) fts5ExprSetEof(pNode);
-        break;
-
-      default:
-        assert( pNode->eType==FTS5_NOT );
-        pNode->bEof = pNode->apChild[0]->bEof;
-        break;
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = fts5ExprNodeTest(pExpr, pNode);
-  }
-  return rc;
-}
-
-
-/*
-** Begin iterating through the set of documents in index pIdx matched by
-** the MATCH expression passed as the first argument. If the "bDesc"
-** parameter is passed a non-zero value, iteration is in descending rowid
-** order. Or, if it is zero, in ascending order.
-**
-** If iterating in ascending rowid order (bDesc==0), the first document
-** visited is that with the smallest rowid that is larger than or equal
-** to parameter iFirst. Or, if iterating in ascending order (bDesc==1),
-** then the first document visited must have a rowid smaller than or
-** equal to iFirst.
-**
-** Return SQLITE_OK if successful, or an SQLite error code otherwise. It
-** is not considered an error if the query does not match any documents.
-*/
-static int sqlite3Fts5ExprFirst(
-  Fts5Expr *p,
-  Fts5Index *pIdx,
-  i64 iFirst,
-  i64 iLast,
-  int bDesc
-){
-  Fts5ExprNode *pRoot = p->pRoot;
-  int rc;                         /* Return code */
-
-  p->pIndex = pIdx;
-  p->bDesc = bDesc;
-  rc = fts5ExprNodeFirst(p, pRoot);
-
-  /* If not at EOF but the current rowid occurs earlier than iFirst in
-  ** the iteration order, move to document iFirst or later. */
-  if( rc==SQLITE_OK
-   && 0==pRoot->bEof
-   && fts5RowidCmp(p, pRoot->iRowid, iFirst)<0
-  ){
-    rc = fts5ExprNodeNext(p, pRoot, 1, iFirst);
-  }
-
-  /* If the iterator is not at a real match, skip forward until it is. */
-  while( pRoot->bNomatch && rc==SQLITE_OK ){
-    assert( pRoot->bEof==0 );
-    rc = fts5ExprNodeNext(p, pRoot, 0, 0);
-  }
-  if( fts5RowidCmp(p, pRoot->iRowid, iLast)>0 ){
-    pRoot->bEof = 1;
-  }
-  return rc;
-}
-
-/*
-** Move to the next document
-**
-** Return SQLITE_OK if successful, or an SQLite error code otherwise. It
-** is not considered an error if the query does not match any documents.
-*/
-static int sqlite3Fts5ExprNext(Fts5Expr *p, i64 iLast){
-  int rc;
-  Fts5ExprNode *pRoot = p->pRoot;
-  assert( pRoot->bEof==0 && pRoot->bNomatch==0 );
-  do {
-    rc = fts5ExprNodeNext(p, pRoot, 0, 0);
-    assert( pRoot->bNomatch==0 || (rc==SQLITE_OK && pRoot->bEof==0) );
-  }while( pRoot->bNomatch );
-  if( fts5RowidCmp(p, pRoot->iRowid, iLast)>0 ){
-    pRoot->bEof = 1;
-  }
-  return rc;
-}
-
-static int sqlite3Fts5ExprEof(Fts5Expr *p){
-  return p->pRoot->bEof;
-}
-
-static i64 sqlite3Fts5ExprRowid(Fts5Expr *p){
-  return p->pRoot->iRowid;
-}
-
-static int fts5ParseStringFromToken(Fts5Token *pToken, char **pz){
-  int rc = SQLITE_OK;
-  *pz = sqlite3Fts5Strndup(&rc, pToken->p, pToken->n);
-  return rc;
-}
-
-/*
-** Free the phrase object passed as the only argument.
-*/
-static void fts5ExprPhraseFree(Fts5ExprPhrase *pPhrase){
-  if( pPhrase ){
-    int i;
-    for(i=0; i<pPhrase->nTerm; i++){
-      Fts5ExprTerm *pSyn;
-      Fts5ExprTerm *pNext;
-      Fts5ExprTerm *pTerm = &pPhrase->aTerm[i];
-      sqlite3_free(pTerm->pTerm);
-      sqlite3Fts5IterClose(pTerm->pIter);
-      for(pSyn=pTerm->pSynonym; pSyn; pSyn=pNext){
-        pNext = pSyn->pSynonym;
-        sqlite3Fts5IterClose(pSyn->pIter);
-        fts5BufferFree((Fts5Buffer*)&pSyn[1]);
-        sqlite3_free(pSyn);
-      }
-    }
-    if( pPhrase->poslist.nSpace>0 ) fts5BufferFree(&pPhrase->poslist);
-    sqlite3_free(pPhrase);
-  }
-}
-
-/*
-** Set the "bFirst" flag on the first token of the phrase passed as the
-** only argument.
-*/
-static void sqlite3Fts5ParseSetCaret(Fts5ExprPhrase *pPhrase){
-  if( pPhrase && pPhrase->nTerm ){
-    pPhrase->aTerm[0].bFirst = 1;
-  }
-}
-
-/*
-** If argument pNear is NULL, then a new Fts5ExprNearset object is allocated
-** and populated with pPhrase. Or, if pNear is not NULL, phrase pPhrase is
-** appended to it and the results returned.
-**
-** If an OOM error occurs, both the pNear and pPhrase objects are freed and
-** NULL returned.
-*/
-static Fts5ExprNearset *sqlite3Fts5ParseNearset(
-  Fts5Parse *pParse,              /* Parse context */
-  Fts5ExprNearset *pNear,         /* Existing nearset, or NULL */
-  Fts5ExprPhrase *pPhrase         /* Recently parsed phrase */
-){
-  const int SZALLOC = 8;
-  Fts5ExprNearset *pRet = 0;
-
-  if( pParse->rc==SQLITE_OK ){
-    if( pNear==0 ){
-      sqlite3_int64 nByte;
-      nByte = SZ_FTS5EXPRNEARSET(SZALLOC+1);
-      pRet = sqlite3_malloc64(nByte);
-      if( pRet==0 ){
-        pParse->rc = SQLITE_NOMEM;
-      }else{
-        memset(pRet, 0, (size_t)nByte);
-      }
-    }else if( (pNear->nPhrase % SZALLOC)==0 ){
-      int nNew = pNear->nPhrase + SZALLOC;
-      sqlite3_int64 nByte;
-
-      nByte = SZ_FTS5EXPRNEARSET(nNew+1);
-      pRet = (Fts5ExprNearset*)sqlite3_realloc64(pNear, nByte);
-      if( pRet==0 ){
-        pParse->rc = SQLITE_NOMEM;
-      }
-    }else{
-      pRet = pNear;
-    }
-  }
-
-  if( pRet==0 ){
-    assert( pParse->rc!=SQLITE_OK );
-    sqlite3Fts5ParseNearsetFree(pNear);
-    sqlite3Fts5ParsePhraseFree(pPhrase);
-  }else{
-    if( pRet->nPhrase>0 ){
-      Fts5ExprPhrase *pLast = pRet->apPhrase[pRet->nPhrase-1];
-      assert( pParse!=0 );
-      assert( pParse->apPhrase!=0 );
-      assert( pParse->nPhrase>=2 );
-      assert( pLast==pParse->apPhrase[pParse->nPhrase-2] );
-      if( pPhrase->nTerm==0 ){
-        fts5ExprPhraseFree(pPhrase);
-        pRet->nPhrase--;
-        pParse->nPhrase--;
-        pPhrase = pLast;
-      }else if( pLast->nTerm==0 ){
-        fts5ExprPhraseFree(pLast);
-        pParse->apPhrase[pParse->nPhrase-2] = pPhrase;
-        pParse->nPhrase--;
-        pRet->nPhrase--;
-      }
-    }
-    pRet->apPhrase[pRet->nPhrase++] = pPhrase;
-  }
-  return pRet;
-}
-
-typedef struct TokenCtx TokenCtx;
-struct TokenCtx {
-  Fts5ExprPhrase *pPhrase;
-  Fts5Config *pConfig;
-  int rc;
-};
-
-/*
-** Callback for tokenizing terms used by ParseTerm().
-*/
-static int fts5ParseTokenize(
-  void *pContext,                 /* Pointer to Fts5InsertCtx object */
-  int tflags,                     /* Mask of FTS5_TOKEN_* flags */
-  const char *pToken,             /* Buffer containing token */
-  int nToken,                     /* Size of token in bytes */
-  int iUnused1,                   /* Start offset of token */
-  int iUnused2                    /* End offset of token */
-){
-  int rc = SQLITE_OK;
-  const int SZALLOC = 8;
-  TokenCtx *pCtx = (TokenCtx*)pContext;
-  Fts5ExprPhrase *pPhrase = pCtx->pPhrase;
-
-  UNUSED_PARAM2(iUnused1, iUnused2);
-
-  /* If an error has already occurred, this is a no-op */
-  if( pCtx->rc!=SQLITE_OK ) return pCtx->rc;
-  if( nToken>FTS5_MAX_TOKEN_SIZE ) nToken = FTS5_MAX_TOKEN_SIZE;
-
-  if( pPhrase && pPhrase->nTerm>0 && (tflags & FTS5_TOKEN_COLOCATED) ){
-    Fts5ExprTerm *pSyn;
-    sqlite3_int64 nByte = sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer) + nToken+1;
-    pSyn = (Fts5ExprTerm*)sqlite3_malloc64(nByte);
-    if( pSyn==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      memset(pSyn, 0, (size_t)nByte);
-      pSyn->pTerm = ((char*)pSyn) + sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer);
-      pSyn->nFullTerm = pSyn->nQueryTerm = nToken;
-      if( pCtx->pConfig->bTokendata ){
-        pSyn->nQueryTerm = (int)strlen(pSyn->pTerm);
-      }
-      memcpy(pSyn->pTerm, pToken, nToken);
-      pSyn->pSynonym = pPhrase->aTerm[pPhrase->nTerm-1].pSynonym;
-      pPhrase->aTerm[pPhrase->nTerm-1].pSynonym = pSyn;
-    }
-  }else{
-    Fts5ExprTerm *pTerm;
-    if( pPhrase==0 || (pPhrase->nTerm % SZALLOC)==0 ){
-      Fts5ExprPhrase *pNew;
-      int nNew = SZALLOC + (pPhrase ? pPhrase->nTerm : 0);
-
-      pNew = (Fts5ExprPhrase*)sqlite3_realloc64(pPhrase,
-          SZ_FTS5EXPRPHRASE(nNew+1)
-      );
-      if( pNew==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        if( pPhrase==0 ) memset(pNew, 0, SZ_FTS5EXPRPHRASE(1));
-        pCtx->pPhrase = pPhrase = pNew;
-        pNew->nTerm = nNew - SZALLOC;
-      }
-    }
-
-    if( rc==SQLITE_OK ){
-      pTerm = &pPhrase->aTerm[pPhrase->nTerm++];
-      memset(pTerm, 0, sizeof(Fts5ExprTerm));
-      pTerm->pTerm = sqlite3Fts5Strndup(&rc, pToken, nToken);
-      pTerm->nFullTerm = pTerm->nQueryTerm = nToken;
-      if( pCtx->pConfig->bTokendata && rc==SQLITE_OK ){
-        pTerm->nQueryTerm = (int)strlen(pTerm->pTerm);
-      }
-    }
-  }
-
-  pCtx->rc = rc;
-  return rc;
-}
-
-
-/*
-** Free the phrase object passed as the only argument.
-*/
-static void sqlite3Fts5ParsePhraseFree(Fts5ExprPhrase *pPhrase){
-  fts5ExprPhraseFree(pPhrase);
-}
-
-/*
-** Free the phrase object passed as the second argument.
-*/
-static void sqlite3Fts5ParseNearsetFree(Fts5ExprNearset *pNear){
-  if( pNear ){
-    int i;
-    for(i=0; i<pNear->nPhrase; i++){
-      fts5ExprPhraseFree(pNear->apPhrase[i]);
-    }
-    sqlite3_free(pNear->pColset);
-    sqlite3_free(pNear);
-  }
-}
-
-static void sqlite3Fts5ParseFinished(Fts5Parse *pParse, Fts5ExprNode *p){
-  assert( pParse->pExpr==0 );
-  pParse->pExpr = p;
-}
-
-static int parseGrowPhraseArray(Fts5Parse *pParse){
-  if( (pParse->nPhrase % 8)==0 ){
-    sqlite3_int64 nByte = sizeof(Fts5ExprPhrase*) * (pParse->nPhrase + 8);
-    Fts5ExprPhrase **apNew;
-    apNew = (Fts5ExprPhrase**)sqlite3_realloc64(pParse->apPhrase, nByte);
-    if( apNew==0 ){
-      pParse->rc = SQLITE_NOMEM;
-      return SQLITE_NOMEM;
-    }
-    pParse->apPhrase = apNew;
-  }
-  return SQLITE_OK;
-}
-
-/*
-** This function is called by the parser to process a string token. The
-** string may or may not be quoted. In any case it is tokenized and a
-** phrase object consisting of all tokens returned.
-*/
-static Fts5ExprPhrase *sqlite3Fts5ParseTerm(
-  Fts5Parse *pParse,              /* Parse context */
-  Fts5ExprPhrase *pAppend,        /* Phrase to append to */
-  Fts5Token *pToken,              /* String to tokenize */
-  int bPrefix                     /* True if there is a trailing "*" */
-){
-  Fts5Config *pConfig = pParse->pConfig;
-  TokenCtx sCtx;                  /* Context object passed to callback */
-  int rc;                         /* Tokenize return code */
-  char *z = 0;
-
-  memset(&sCtx, 0, sizeof(TokenCtx));
-  sCtx.pPhrase = pAppend;
-  sCtx.pConfig = pConfig;
-
-  rc = fts5ParseStringFromToken(pToken, &z);
-  if( rc==SQLITE_OK ){
-    int flags = FTS5_TOKENIZE_QUERY | (bPrefix ? FTS5_TOKENIZE_PREFIX : 0);
-    int n;
-    sqlite3Fts5Dequote(z);
-    n = (int)strlen(z);
-    rc = sqlite3Fts5Tokenize(pConfig, flags, z, n, &sCtx, fts5ParseTokenize);
-  }
-  sqlite3_free(z);
-  if( rc || (rc = sCtx.rc) ){
-    pParse->rc = rc;
-    fts5ExprPhraseFree(sCtx.pPhrase);
-    sCtx.pPhrase = 0;
-  }else{
-
-    if( pAppend==0 ){
-      if( parseGrowPhraseArray(pParse) ){
-        fts5ExprPhraseFree(sCtx.pPhrase);
-        return 0;
-      }
-      pParse->nPhrase++;
-    }
-
-    if( sCtx.pPhrase==0 ){
-      /* This happens when parsing a token or quoted phrase that contains
-      ** no token characters at all. (e.g ... MATCH '""'). */
-      sCtx.pPhrase = sqlite3Fts5MallocZero(&pParse->rc, SZ_FTS5EXPRPHRASE(1));
-    }else if( sCtx.pPhrase->nTerm ){
-      sCtx.pPhrase->aTerm[sCtx.pPhrase->nTerm-1].bPrefix = (u8)bPrefix;
-    }
-    assert( pParse->apPhrase!=0 );
-    pParse->apPhrase[pParse->nPhrase-1] = sCtx.pPhrase;
-  }
-
-  return sCtx.pPhrase;
-}
-
-/*
-** Create a new FTS5 expression by cloning phrase iPhrase of the
-** expression passed as the second argument.
-*/
-static int sqlite3Fts5ExprClonePhrase(
-  Fts5Expr *pExpr,
-  int iPhrase,
-  Fts5Expr **ppNew
-){
-  int rc = SQLITE_OK;             /* Return code */
-  Fts5ExprPhrase *pOrig = 0;      /* The phrase extracted from pExpr */
-  Fts5Expr *pNew = 0;             /* Expression to return via *ppNew */
-  TokenCtx sCtx = {0,0,0};        /* Context object for fts5ParseTokenize */
-  if( !pExpr || iPhrase<0 || iPhrase>=pExpr->nPhrase ){
-    rc = SQLITE_RANGE;
-  }else{
-    pOrig = pExpr->apExprPhrase[iPhrase];
-    pNew = (Fts5Expr*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5Expr));
-  }
-  if( rc==SQLITE_OK ){
-    pNew->apExprPhrase = (Fts5ExprPhrase**)sqlite3Fts5MallocZero(&rc,
-        sizeof(Fts5ExprPhrase*));
-  }
-  if( rc==SQLITE_OK ){
-    pNew->pRoot = (Fts5ExprNode*)sqlite3Fts5MallocZero(&rc, SZ_FTS5EXPRNODE(1));
-  }
-  if( rc==SQLITE_OK ){
-    pNew->pRoot->pNear = (Fts5ExprNearset*)sqlite3Fts5MallocZero(&rc,
-                                                    SZ_FTS5EXPRNEARSET(2));
-  }
-  if( rc==SQLITE_OK && ALWAYS(pOrig!=0) ){
-    Fts5Colset *pColsetOrig = pOrig->pNode->pNear->pColset;
-    if( pColsetOrig ){
-      sqlite3_int64 nByte;
-      Fts5Colset *pColset;
-      nByte = SZ_FTS5COLSET(pColsetOrig->nCol);
-      pColset = (Fts5Colset*)sqlite3Fts5MallocZero(&rc, nByte);
-      if( pColset ){
-        memcpy(pColset, pColsetOrig, (size_t)nByte);
-      }
-      pNew->pRoot->pNear->pColset = pColset;
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    if( pOrig->nTerm ){
-      int i;                          /* Used to iterate through phrase terms */
-      sCtx.pConfig = pExpr->pConfig;
-      for(i=0; rc==SQLITE_OK && i<pOrig->nTerm; i++){
-        int tflags = 0;
-        Fts5ExprTerm *p;
-        for(p=&pOrig->aTerm[i]; p && rc==SQLITE_OK; p=p->pSynonym){
-          rc = fts5ParseTokenize((void*)&sCtx,tflags,p->pTerm,p->nFullTerm,0,0);
-          tflags = FTS5_TOKEN_COLOCATED;
-        }
-        if( rc==SQLITE_OK ){
-          sCtx.pPhrase->aTerm[i].bPrefix = pOrig->aTerm[i].bPrefix;
-          sCtx.pPhrase->aTerm[i].bFirst = pOrig->aTerm[i].bFirst;
-        }
-      }
-    }else{
-      /* This happens when parsing a token or quoted phrase that contains
-      ** no token characters at all. (e.g ... MATCH '""'). */
-      sCtx.pPhrase = sqlite3Fts5MallocZero(&rc, SZ_FTS5EXPRPHRASE(1));
-    }
-  }
-
-  if( rc==SQLITE_OK && ALWAYS(sCtx.pPhrase) ){
-    /* All the allocations succeeded. Put the expression object together. */
-    pNew->pIndex = pExpr->pIndex;
-    pNew->pConfig = pExpr->pConfig;
-    pNew->nPhrase = 1;
-    pNew->apExprPhrase[0] = sCtx.pPhrase;
-    pNew->pRoot->pNear->apPhrase[0] = sCtx.pPhrase;
-    pNew->pRoot->pNear->nPhrase = 1;
-    sCtx.pPhrase->pNode = pNew->pRoot;
-
-    if( pOrig->nTerm==1
-     && pOrig->aTerm[0].pSynonym==0
-     && pOrig->aTerm[0].bFirst==0
-    ){
-      pNew->pRoot->eType = FTS5_TERM;
-      pNew->pRoot->xNext = fts5ExprNodeNext_TERM;
-    }else{
-      pNew->pRoot->eType = FTS5_STRING;
-      pNew->pRoot->xNext = fts5ExprNodeNext_STRING;
-    }
-  }else{
-    sqlite3Fts5ExprFree(pNew);
-    fts5ExprPhraseFree(sCtx.pPhrase);
-    pNew = 0;
-  }
-
-  *ppNew = pNew;
-  return rc;
-}
-
-
-/*
-** Token pTok has appeared in a MATCH expression where the NEAR operator
-** is expected. If token pTok does not contain "NEAR", store an error
-** in the pParse object.
-*/
-static void sqlite3Fts5ParseNear(Fts5Parse *pParse, Fts5Token *pTok){
-  if( pTok->n!=4 || memcmp("NEAR", pTok->p, 4) ){
-    sqlite3Fts5ParseError(
-        pParse, "fts5: syntax error near \"%.*s\"", pTok->n, pTok->p
-    );
-  }
-}
-
-static void sqlite3Fts5ParseSetDistance(
-  Fts5Parse *pParse,
-  Fts5ExprNearset *pNear,
-  Fts5Token *p
-){
-  if( pNear ){
-    int nNear = 0;
-    int i;
-    if( p->n ){
-      for(i=0; i<p->n; i++){
-        char c = (char)p->p[i];
-        if( c<'0' || c>'9' ){
-          sqlite3Fts5ParseError(
-              pParse, "expected integer, got \"%.*s\"", p->n, p->p
-              );
-          return;
-        }
-        if( nNear<214748363 ) nNear = nNear * 10 + (p->p[i] - '0');
-        /*  ^^^^^^^^^^^^^^^---  Prevent integer overflow */
-      }
-    }else{
-      nNear = FTS5_DEFAULT_NEARDIST;
-    }
-    pNear->nNear = nNear;
-  }
-}
-
-/*
-** The second argument passed to this function may be NULL, or it may be
-** an existing Fts5Colset object. This function returns a pointer to
-** a new colset object containing the contents of (p) with new value column
-** number iCol appended.
-**
-** If an OOM error occurs, store an error code in pParse and return NULL.
-** The old colset object (if any) is not freed in this case.
-*/
-static Fts5Colset *fts5ParseColset(
-  Fts5Parse *pParse,              /* Store SQLITE_NOMEM here if required */
-  Fts5Colset *p,                  /* Existing colset object */
-  int iCol                        /* New column to add to colset object */
-){
-  int nCol = p ? p->nCol : 0;     /* Num. columns already in colset object */
-  Fts5Colset *pNew;               /* New colset object to return */
-
-  assert( pParse->rc==SQLITE_OK );
-  assert( iCol>=0 && iCol<pParse->pConfig->nCol );
-
-  pNew = sqlite3_realloc64(p, SZ_FTS5COLSET(nCol+1));
-  if( pNew==0 ){
-    pParse->rc = SQLITE_NOMEM;
-  }else{
-    int *aiCol = pNew->aiCol;
-    int i, j;
-    for(i=0; i<nCol; i++){
-      if( aiCol[i]==iCol ) return pNew;
-      if( aiCol[i]>iCol ) break;
-    }
-    for(j=nCol; j>i; j--){
-      aiCol[j] = aiCol[j-1];
-    }
-    aiCol[i] = iCol;
-    pNew->nCol = nCol+1;
-
-#ifndef NDEBUG
-    /* Check that the array is in order and contains no duplicate entries. */
-    for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
-#endif
-  }
-
-  return pNew;
-}
-
-/*
-** Allocate and return an Fts5Colset object specifying the inverse of
-** the colset passed as the second argument. Free the colset passed
-** as the second argument before returning.
-*/
-static Fts5Colset *sqlite3Fts5ParseColsetInvert(Fts5Parse *pParse, Fts5Colset *p){
-  Fts5Colset *pRet;
-  int nCol = pParse->pConfig->nCol;
-
-  pRet = (Fts5Colset*)sqlite3Fts5MallocZero(&pParse->rc,
-      SZ_FTS5COLSET(nCol+1)
-  );
-  if( pRet ){
-    int i;
-    int iOld = 0;
-    for(i=0; i<nCol; i++){
-      if( iOld>=p->nCol || p->aiCol[iOld]!=i ){
-        pRet->aiCol[pRet->nCol++] = i;
-      }else{
-        iOld++;
-      }
-    }
-  }
-
-  sqlite3_free(p);
-  return pRet;
-}
-
-static Fts5Colset *sqlite3Fts5ParseColset(
-  Fts5Parse *pParse,              /* Store SQLITE_NOMEM here if required */
-  Fts5Colset *pColset,            /* Existing colset object */
-  Fts5Token *p
-){
-  Fts5Colset *pRet = 0;
-  int iCol;
-  char *z;                        /* Dequoted copy of token p */
-
-  z = sqlite3Fts5Strndup(&pParse->rc, p->p, p->n);
-  if( pParse->rc==SQLITE_OK ){
-    Fts5Config *pConfig = pParse->pConfig;
-    sqlite3Fts5Dequote(z);
-    for(iCol=0; iCol<pConfig->nCol; iCol++){
-      if( 0==sqlite3_stricmp(pConfig->azCol[iCol], z) ) break;
-    }
-    if( iCol==pConfig->nCol ){
-      sqlite3Fts5ParseError(pParse, "no such column: %s", z);
-    }else{
-      pRet = fts5ParseColset(pParse, pColset, iCol);
-    }
-    sqlite3_free(z);
-  }
-
-  if( pRet==0 ){
-    assert( pParse->rc!=SQLITE_OK );
-    sqlite3_free(pColset);
-  }
-
-  return pRet;
-}
-
-/*
-** If argument pOrig is NULL, or if (*pRc) is set to anything other than
-** SQLITE_OK when this function is called, NULL is returned.
-**
-** Otherwise, a copy of (*pOrig) is made into memory obtained from
-** sqlite3Fts5MallocZero() and a pointer to it returned. If the allocation
-** fails, (*pRc) is set to SQLITE_NOMEM and NULL is returned.
-*/
-static Fts5Colset *fts5CloneColset(int *pRc, Fts5Colset *pOrig){
-  Fts5Colset *pRet;
-  if( pOrig ){
-    sqlite3_int64 nByte = SZ_FTS5COLSET(pOrig->nCol);
-    pRet = (Fts5Colset*)sqlite3Fts5MallocZero(pRc, nByte);
-    if( pRet ){
-      memcpy(pRet, pOrig, (size_t)nByte);
-    }
-  }else{
-    pRet = 0;
-  }
-  return pRet;
-}
-
-/*
-** Remove from colset pColset any columns that are not also in colset pMerge.
-*/
-static void fts5MergeColset(Fts5Colset *pColset, Fts5Colset *pMerge){
-  int iIn = 0;          /* Next input in pColset */
-  int iMerge = 0;       /* Next input in pMerge */
-  int iOut = 0;         /* Next output slot in pColset */
-
-  while( iIn<pColset->nCol && iMerge<pMerge->nCol ){
-    int iDiff = pColset->aiCol[iIn] - pMerge->aiCol[iMerge];
-    if( iDiff==0 ){
-      pColset->aiCol[iOut++] = pMerge->aiCol[iMerge];
-      iMerge++;
-      iIn++;
-    }else if( iDiff>0 ){
-      iMerge++;
-    }else{
-      iIn++;
-    }
-  }
-  pColset->nCol = iOut;
-}
-
-/*
-** Recursively apply colset pColset to expression node pNode and all of
-** its decendents. If (*ppFree) is not NULL, it contains a spare copy
-** of pColset. This function may use the spare copy and set (*ppFree) to
-** zero, or it may create copies of pColset using fts5CloneColset().
-*/
-static void fts5ParseSetColset(
-  Fts5Parse *pParse,
-  Fts5ExprNode *pNode,
-  Fts5Colset *pColset,
-  Fts5Colset **ppFree
-){
-  if( pParse->rc==SQLITE_OK ){
-    assert( pNode->eType==FTS5_TERM || pNode->eType==FTS5_STRING
-         || pNode->eType==FTS5_AND  || pNode->eType==FTS5_OR
-         || pNode->eType==FTS5_NOT  || pNode->eType==FTS5_EOF
-    );
-    if( pNode->eType==FTS5_STRING || pNode->eType==FTS5_TERM ){
-      Fts5ExprNearset *pNear = pNode->pNear;
-      if( pNear->pColset ){
-        fts5MergeColset(pNear->pColset, pColset);
-        if( pNear->pColset->nCol==0 ){
-          pNode->eType = FTS5_EOF;
-          pNode->xNext = 0;
-        }
-      }else if( *ppFree ){
-        pNear->pColset = pColset;
-        *ppFree = 0;
-      }else{
-        pNear->pColset = fts5CloneColset(&pParse->rc, pColset);
-      }
-    }else{
-      int i;
-      assert( pNode->eType!=FTS5_EOF || pNode->nChild==0 );
-      for(i=0; i<pNode->nChild; i++){
-        fts5ParseSetColset(pParse, pNode->apChild[i], pColset, ppFree);
-      }
-    }
-  }
-}
-
-/*
-** Apply colset pColset to expression node pExpr and all of its descendents.
-*/
-static void sqlite3Fts5ParseSetColset(
-  Fts5Parse *pParse,
-  Fts5ExprNode *pExpr,
-  Fts5Colset *pColset
-){
-  Fts5Colset *pFree = pColset;
-  if( pParse->pConfig->eDetail==FTS5_DETAIL_NONE ){
-    sqlite3Fts5ParseError(pParse,
-        "fts5: column queries are not supported (detail=none)"
-    );
-  }else{
-    fts5ParseSetColset(pParse, pExpr, pColset, &pFree);
-  }
-  sqlite3_free(pFree);
-}
-
-static void fts5ExprAssignXNext(Fts5ExprNode *pNode){
-  switch( pNode->eType ){
-    case FTS5_STRING: {
-      Fts5ExprNearset *pNear = pNode->pNear;
-      if( pNear->nPhrase==1 && pNear->apPhrase[0]->nTerm==1
-       && pNear->apPhrase[0]->aTerm[0].pSynonym==0
-       && pNear->apPhrase[0]->aTerm[0].bFirst==0
-      ){
-        pNode->eType = FTS5_TERM;
-        pNode->xNext = fts5ExprNodeNext_TERM;
-      }else{
-        pNode->xNext = fts5ExprNodeNext_STRING;
-      }
-      break;
-    };
-
-    case FTS5_OR: {
-      pNode->xNext = fts5ExprNodeNext_OR;
-      break;
-    };
-
-    case FTS5_AND: {
-      pNode->xNext = fts5ExprNodeNext_AND;
-      break;
-    };
-
-    default: assert( pNode->eType==FTS5_NOT ); {
-      pNode->xNext = fts5ExprNodeNext_NOT;
-      break;
-    };
-  }
-}
-
-/*
-** Add pSub as a child of p.
-*/
-static void fts5ExprAddChildren(Fts5ExprNode *p, Fts5ExprNode *pSub){
-  int ii = p->nChild;
-  if( p->eType!=FTS5_NOT && pSub->eType==p->eType ){
-    int nByte = sizeof(Fts5ExprNode*) * pSub->nChild;
-    memcpy(&p->apChild[p->nChild], pSub->apChild, nByte);
-    p->nChild += pSub->nChild;
-    sqlite3_free(pSub);
-  }else{
-    p->apChild[p->nChild++] = pSub;
-  }
-  for( ; ii<p->nChild; ii++){
-    p->iHeight = MAX(p->iHeight, p->apChild[ii]->iHeight + 1);
-  }
-}
-
-/*
-** This function is used when parsing LIKE or GLOB patterns against
-** trigram indexes that specify either detail=column or detail=none.
-** It converts a phrase:
-**
-**     abc + def + ghi
-**
-** into an AND tree:
-**
-**     abc AND def AND ghi
-*/
-static Fts5ExprNode *fts5ParsePhraseToAnd(
-  Fts5Parse *pParse,
-  Fts5ExprNearset *pNear
-){
-  int nTerm = pNear->apPhrase[0]->nTerm;
-  int ii;
-  int nByte;
-  Fts5ExprNode *pRet;
-
-  assert( pNear->nPhrase==1 );
-  assert( pParse->bPhraseToAnd );
-
-  nByte = SZ_FTS5EXPRNODE(nTerm+1);
-  pRet = (Fts5ExprNode*)sqlite3Fts5MallocZero(&pParse->rc, nByte);
-  if( pRet ){
-    pRet->eType = FTS5_AND;
-    pRet->nChild = nTerm;
-    pRet->iHeight = 1;
-    fts5ExprAssignXNext(pRet);
-    pParse->nPhrase--;
-    for(ii=0; ii<nTerm; ii++){
-      Fts5ExprPhrase *pPhrase = (Fts5ExprPhrase*)sqlite3Fts5MallocZero(
-          &pParse->rc, SZ_FTS5EXPRPHRASE(1)
-      );
-      if( pPhrase ){
-        if( parseGrowPhraseArray(pParse) ){
-          fts5ExprPhraseFree(pPhrase);
-        }else{
-          Fts5ExprTerm *p = &pNear->apPhrase[0]->aTerm[ii];
-          Fts5ExprTerm *pTo = &pPhrase->aTerm[0];
-          pParse->apPhrase[pParse->nPhrase++] = pPhrase;
-          pPhrase->nTerm = 1;
-          pTo->pTerm = sqlite3Fts5Strndup(&pParse->rc, p->pTerm, p->nFullTerm);
-          pTo->nQueryTerm = p->nQueryTerm;
-          pTo->nFullTerm = p->nFullTerm;
-          pRet->apChild[ii] = sqlite3Fts5ParseNode(pParse, FTS5_STRING,
-              0, 0, sqlite3Fts5ParseNearset(pParse, 0, pPhrase)
-          );
-        }
-      }
-    }
-
-    if( pParse->rc ){
-      sqlite3Fts5ParseNodeFree(pRet);
-      pRet = 0;
-    }else{
-      sqlite3Fts5ParseNearsetFree(pNear);
-    }
-  }
-
-  return pRet;
-}
-
-/*
-** Allocate and return a new expression object. If anything goes wrong (i.e.
-** OOM error), leave an error code in pParse and return NULL.
-*/
-static Fts5ExprNode *sqlite3Fts5ParseNode(
-  Fts5Parse *pParse,              /* Parse context */
-  int eType,                      /* FTS5_STRING, AND, OR or NOT */
-  Fts5ExprNode *pLeft,            /* Left hand child expression */
-  Fts5ExprNode *pRight,           /* Right hand child expression */
-  Fts5ExprNearset *pNear          /* For STRING expressions, the near cluster */
-){
-  Fts5ExprNode *pRet = 0;
-
-  if( pParse->rc==SQLITE_OK ){
-    int nChild = 0;               /* Number of children of returned node */
-    sqlite3_int64 nByte;          /* Bytes of space to allocate for this node */
-
-    assert( (eType!=FTS5_STRING && !pNear)
-         || (eType==FTS5_STRING && !pLeft && !pRight)
-    );
-    if( eType==FTS5_STRING && pNear==0 ) return 0;
-    if( eType!=FTS5_STRING && pLeft==0 ) return pRight;
-    if( eType!=FTS5_STRING && pRight==0 ) return pLeft;
-
-    if( eType==FTS5_STRING
-     && pParse->bPhraseToAnd
-     && pNear->apPhrase[0]->nTerm>1
-    ){
-      pRet = fts5ParsePhraseToAnd(pParse, pNear);
-    }else{
-      if( eType==FTS5_NOT ){
-        nChild = 2;
-      }else if( eType==FTS5_AND || eType==FTS5_OR ){
-        nChild = 2;
-        if( pLeft->eType==eType ) nChild += pLeft->nChild-1;
-        if( pRight->eType==eType ) nChild += pRight->nChild-1;
-      }
-
-      nByte = SZ_FTS5EXPRNODE(nChild);
-      pRet = (Fts5ExprNode*)sqlite3Fts5MallocZero(&pParse->rc, nByte);
-
-      if( pRet ){
-        pRet->eType = eType;
-        pRet->pNear = pNear;
-        fts5ExprAssignXNext(pRet);
-        if( eType==FTS5_STRING ){
-          int iPhrase;
-          for(iPhrase=0; iPhrase<pNear->nPhrase; iPhrase++){
-            pNear->apPhrase[iPhrase]->pNode = pRet;
-            if( pNear->apPhrase[iPhrase]->nTerm==0 ){
-              pRet->xNext = 0;
-              pRet->eType = FTS5_EOF;
-            }
-          }
-
-          if( pParse->pConfig->eDetail!=FTS5_DETAIL_FULL ){
-            Fts5ExprPhrase *pPhrase = pNear->apPhrase[0];
-            if( pNear->nPhrase!=1
-                || pPhrase->nTerm>1
-                || (pPhrase->nTerm>0 && pPhrase->aTerm[0].bFirst)
-              ){
-              sqlite3Fts5ParseError(pParse,
-                  "fts5: %s queries are not supported (detail!=full)",
-                  pNear->nPhrase==1 ? "phrase": "NEAR"
-              );
-              sqlite3Fts5ParseNodeFree(pRet);
-              pRet = 0;
-              pNear = 0;
-              assert( pLeft==0 && pRight==0 );
-            }
-          }
-        }else{
-          assert( pNear==0 );
-          fts5ExprAddChildren(pRet, pLeft);
-          fts5ExprAddChildren(pRet, pRight);
-          pLeft = pRight = 0;
-          if( pRet->iHeight>SQLITE_FTS5_MAX_EXPR_DEPTH ){
-            sqlite3Fts5ParseError(pParse,
-                "fts5 expression tree is too large (maximum depth %d)",
-                SQLITE_FTS5_MAX_EXPR_DEPTH
-            );
-            sqlite3Fts5ParseNodeFree(pRet);
-            pRet = 0;
-          }
-        }
-      }
-    }
-  }
-
-  if( pRet==0 ){
-    assert( pParse->rc!=SQLITE_OK );
-    sqlite3Fts5ParseNodeFree(pLeft);
-    sqlite3Fts5ParseNodeFree(pRight);
-    sqlite3Fts5ParseNearsetFree(pNear);
-  }
-  return pRet;
-}
-
-static Fts5ExprNode *sqlite3Fts5ParseImplicitAnd(
-  Fts5Parse *pParse,              /* Parse context */
-  Fts5ExprNode *pLeft,            /* Left hand child expression */
-  Fts5ExprNode *pRight            /* Right hand child expression */
-){
-  Fts5ExprNode *pRet = 0;
-  Fts5ExprNode *pPrev;
-
-  if( pParse->rc ){
-    sqlite3Fts5ParseNodeFree(pLeft);
-    sqlite3Fts5ParseNodeFree(pRight);
-  }else{
-
-    assert( pLeft->eType==FTS5_STRING
-        || pLeft->eType==FTS5_TERM
-        || pLeft->eType==FTS5_EOF
-        || pLeft->eType==FTS5_AND
-    );
-    assert( pRight->eType==FTS5_STRING
-        || pRight->eType==FTS5_TERM
-        || pRight->eType==FTS5_EOF
-        || (pRight->eType==FTS5_AND && pParse->bPhraseToAnd)
-    );
-
-    if( pLeft->eType==FTS5_AND ){
-      pPrev = pLeft->apChild[pLeft->nChild-1];
-    }else{
-      pPrev = pLeft;
-    }
-    assert( pPrev->eType==FTS5_STRING
-        || pPrev->eType==FTS5_TERM
-        || pPrev->eType==FTS5_EOF
-        );
-
-    if( pRight->eType==FTS5_EOF ){
-      assert( pParse->apPhrase!=0 );
-      assert( pParse->nPhrase>0 );
-      assert( pParse->apPhrase[pParse->nPhrase-1]==pRight->pNear->apPhrase[0] );
-      sqlite3Fts5ParseNodeFree(pRight);
-      pRet = pLeft;
-      pParse->nPhrase--;
-    }
-    else if( pPrev->eType==FTS5_EOF ){
-      Fts5ExprPhrase **ap;
-
-      if( pPrev==pLeft ){
-        pRet = pRight;
-      }else{
-        pLeft->apChild[pLeft->nChild-1] = pRight;
-        pRet = pLeft;
-      }
-
-      ap = &pParse->apPhrase[pParse->nPhrase-1-pRight->pNear->nPhrase];
-      assert( ap[0]==pPrev->pNear->apPhrase[0] );
-      memmove(ap, &ap[1], sizeof(Fts5ExprPhrase*)*pRight->pNear->nPhrase);
-      pParse->nPhrase--;
-
-      sqlite3Fts5ParseNodeFree(pPrev);
-    }
-    else{
-      pRet = sqlite3Fts5ParseNode(pParse, FTS5_AND, pLeft, pRight, 0);
-    }
-  }
-
-  return pRet;
-}
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-static char *fts5ExprTermPrint(Fts5ExprTerm *pTerm){
-  sqlite3_int64 nByte = 0;
-  Fts5ExprTerm *p;
-  char *zQuoted;
-
-  /* Determine the maximum amount of space required. */
-  for(p=pTerm; p; p=p->pSynonym){
-    nByte += pTerm->nQueryTerm * 2 + 3 + 2;
-  }
-  zQuoted = sqlite3_malloc64(nByte);
-
-  if( zQuoted ){
-    int i = 0;
-    for(p=pTerm; p; p=p->pSynonym){
-      char *zIn = p->pTerm;
-      char *zEnd = &zIn[p->nQueryTerm];
-      zQuoted[i++] = '"';
-      while( zIn<zEnd ){
-        if( *zIn=='"' ) zQuoted[i++] = '"';
-        zQuoted[i++] = *zIn++;
-      }
-      zQuoted[i++] = '"';
-      if( p->pSynonym ) zQuoted[i++] = '|';
-    }
-    if( pTerm->bPrefix ){
-      zQuoted[i++] = ' ';
-      zQuoted[i++] = '*';
-    }
-    zQuoted[i++] = '\0';
-  }
-  return zQuoted;
-}
-
-static char *fts5PrintfAppend(char *zApp, const char *zFmt, ...){
-  char *zNew;
-  va_list ap;
-  va_start(ap, zFmt);
-  zNew = sqlite3_vmprintf(zFmt, ap);
-  va_end(ap);
-  if( zApp && zNew ){
-    char *zNew2 = sqlite3_mprintf("%s%s", zApp, zNew);
-    sqlite3_free(zNew);
-    zNew = zNew2;
-  }
-  sqlite3_free(zApp);
-  return zNew;
-}
-
-/*
-** Compose a tcl-readable representation of expression pExpr. Return a
-** pointer to a buffer containing that representation. It is the
-** responsibility of the caller to at some point free the buffer using
-** sqlite3_free().
-*/
-static char *fts5ExprPrintTcl(
-  Fts5Config *pConfig,
-  const char *zNearsetCmd,
-  Fts5ExprNode *pExpr
-){
-  char *zRet = 0;
-  if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
-    Fts5ExprNearset *pNear = pExpr->pNear;
-    int i;
-    int iTerm;
-
-    zRet = fts5PrintfAppend(zRet, "%s ", zNearsetCmd);
-    if( zRet==0 ) return 0;
-    if( pNear->pColset ){
-      int *aiCol = pNear->pColset->aiCol;
-      int nCol = pNear->pColset->nCol;
-      if( nCol==1 ){
-        zRet = fts5PrintfAppend(zRet, "-col %d ", aiCol[0]);
-      }else{
-        zRet = fts5PrintfAppend(zRet, "-col {%d", aiCol[0]);
-        for(i=1; i<pNear->pColset->nCol; i++){
-          zRet = fts5PrintfAppend(zRet, " %d", aiCol[i]);
-        }
-        zRet = fts5PrintfAppend(zRet, "} ");
-      }
-      if( zRet==0 ) return 0;
-    }
-
-    if( pNear->nPhrase>1 ){
-      zRet = fts5PrintfAppend(zRet, "-near %d ", pNear->nNear);
-      if( zRet==0 ) return 0;
-    }
-
-    zRet = fts5PrintfAppend(zRet, "--");
-    if( zRet==0 ) return 0;
-
-    for(i=0; i<pNear->nPhrase; i++){
-      Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
-
-      zRet = fts5PrintfAppend(zRet, " {");
-      for(iTerm=0; zRet && iTerm<pPhrase->nTerm; iTerm++){
-        Fts5ExprTerm *p = &pPhrase->aTerm[iTerm];
-        zRet = fts5PrintfAppend(zRet, "%s%.*s", iTerm==0?"":" ",
-            p->nQueryTerm, p->pTerm
-        );
-        if( pPhrase->aTerm[iTerm].bPrefix ){
-          zRet = fts5PrintfAppend(zRet, "*");
-        }
-      }
-
-      if( zRet ) zRet = fts5PrintfAppend(zRet, "}");
-      if( zRet==0 ) return 0;
-    }
-
-  }else if( pExpr->eType==0 ){
-    zRet = sqlite3_mprintf("{}");
-  }else{
-    char const *zOp = 0;
-    int i;
-    switch( pExpr->eType ){
-      case FTS5_AND: zOp = "AND"; break;
-      case FTS5_NOT: zOp = "NOT"; break;
-      default:
-        assert( pExpr->eType==FTS5_OR );
-        zOp = "OR";
-        break;
-    }
-
-    zRet = sqlite3_mprintf("%s", zOp);
-    for(i=0; zRet && i<pExpr->nChild; i++){
-      char *z = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->apChild[i]);
-      if( !z ){
-        sqlite3_free(zRet);
-        zRet = 0;
-      }else{
-        zRet = fts5PrintfAppend(zRet, " [%z]", z);
-      }
-    }
-  }
-
-  return zRet;
-}
-
-static char *fts5ExprPrint(Fts5Config *pConfig, Fts5ExprNode *pExpr){
-  char *zRet = 0;
-  if( pExpr->eType==0 ){
-    return sqlite3_mprintf("\"\"");
-  }else
-  if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
-    Fts5ExprNearset *pNear = pExpr->pNear;
-    int i;
-    int iTerm;
-
-    if( pNear->pColset ){
-      int ii;
-      Fts5Colset *pColset = pNear->pColset;
-      if( pColset->nCol>1 ) zRet = fts5PrintfAppend(zRet, "{");
-      for(ii=0; ii<pColset->nCol; ii++){
-        zRet = fts5PrintfAppend(zRet, "%s%s",
-            pConfig->azCol[pColset->aiCol[ii]], ii==pColset->nCol-1 ? "" : " "
-        );
-      }
-      if( zRet ){
-        zRet = fts5PrintfAppend(zRet, "%s : ", pColset->nCol>1 ? "}" : "");
-      }
-      if( zRet==0 ) return 0;
-    }
-
-    if( pNear->nPhrase>1 ){
-      zRet = fts5PrintfAppend(zRet, "NEAR(");
-      if( zRet==0 ) return 0;
-    }
-
-    for(i=0; i<pNear->nPhrase; i++){
-      Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
-      if( i!=0 ){
-        zRet = fts5PrintfAppend(zRet, " ");
-        if( zRet==0 ) return 0;
-      }
-      for(iTerm=0; iTerm<pPhrase->nTerm; iTerm++){
-        char *zTerm = fts5ExprTermPrint(&pPhrase->aTerm[iTerm]);
-        if( zTerm ){
-          zRet = fts5PrintfAppend(zRet, "%s%s", iTerm==0?"":" + ", zTerm);
-          sqlite3_free(zTerm);
-        }
-        if( zTerm==0 || zRet==0 ){
-          sqlite3_free(zRet);
-          return 0;
-        }
-      }
-    }
-
-    if( pNear->nPhrase>1 ){
-      zRet = fts5PrintfAppend(zRet, ", %d)", pNear->nNear);
-      if( zRet==0 ) return 0;
-    }
-
-  }else{
-    char const *zOp = 0;
-    int i;
-
-    switch( pExpr->eType ){
-      case FTS5_AND: zOp = " AND "; break;
-      case FTS5_NOT: zOp = " NOT "; break;
-      default:
-        assert( pExpr->eType==FTS5_OR );
-        zOp = " OR ";
-        break;
-    }
-
-    for(i=0; i<pExpr->nChild; i++){
-      char *z = fts5ExprPrint(pConfig, pExpr->apChild[i]);
-      if( z==0 ){
-        sqlite3_free(zRet);
-        zRet = 0;
-      }else{
-        int e = pExpr->apChild[i]->eType;
-        int b = (e!=FTS5_STRING && e!=FTS5_TERM && e!=FTS5_EOF);
-        zRet = fts5PrintfAppend(zRet, "%s%s%z%s",
-            (i==0 ? "" : zOp),
-            (b?"(":""), z, (b?")":"")
-        );
-      }
-      if( zRet==0 ) break;
-    }
-  }
-
-  return zRet;
-}
-
-/*
-** The implementation of user-defined scalar functions fts5_expr() (bTcl==0)
-** and fts5_expr_tcl() (bTcl!=0).
-*/
-static void fts5ExprFunction(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args */
-  sqlite3_value **apVal,          /* Function arguments */
-  int bTcl
-){
-  Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
-  sqlite3 *db = sqlite3_context_db_handle(pCtx);
-  const char *zExpr = 0;
-  char *zErr = 0;
-  Fts5Expr *pExpr = 0;
-  int rc;
-  int i;
-
-  const char **azConfig;          /* Array of arguments for Fts5Config */
-  const char *zNearsetCmd = "nearset";
-  int nConfig;                    /* Size of azConfig[] */
-  Fts5Config *pConfig = 0;
-  int iArg = 1;
-
-  if( nArg<1 ){
-    zErr = sqlite3_mprintf("wrong number of arguments to function %s",
-        bTcl ? "fts5_expr_tcl" : "fts5_expr"
-    );
-    sqlite3_result_error(pCtx, zErr, -1);
-    sqlite3_free(zErr);
-    return;
-  }
-
-  if( bTcl && nArg>1 ){
-    zNearsetCmd = (const char*)sqlite3_value_text(apVal[1]);
-    iArg = 2;
-  }
-
-  nConfig = 3 + (nArg-iArg);
-  azConfig = (const char**)sqlite3_malloc64(sizeof(char*) * nConfig);
-  if( azConfig==0 ){
-    sqlite3_result_error_nomem(pCtx);
-    return;
-  }
-  azConfig[0] = 0;
-  azConfig[1] = "main";
-  azConfig[2] = "tbl";
-  for(i=3; iArg<nArg; iArg++){
-    const char *z = (const char*)sqlite3_value_text(apVal[iArg]);
-    azConfig[i++] = (z ? z : "");
-  }
-
-  zExpr = (const char*)sqlite3_value_text(apVal[0]);
-  if( zExpr==0 ) zExpr = "";
-
-  rc = sqlite3Fts5ConfigParse(pGlobal, db, nConfig, azConfig, &pConfig, &zErr);
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
-  }
-  if( rc==SQLITE_OK ){
-    char *zText;
-    if( pExpr->pRoot->xNext==0 ){
-      zText = sqlite3_mprintf("");
-    }else if( bTcl ){
-      zText = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->pRoot);
-    }else{
-      zText = fts5ExprPrint(pConfig, pExpr->pRoot);
-    }
-    if( zText==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      sqlite3_result_text(pCtx, zText, -1, SQLITE_TRANSIENT);
-      sqlite3_free(zText);
-    }
-  }
-
-  if( rc!=SQLITE_OK ){
-    if( zErr ){
-      sqlite3_result_error(pCtx, zErr, -1);
-      sqlite3_free(zErr);
-    }else{
-      sqlite3_result_error_code(pCtx, rc);
-    }
-  }
-  sqlite3_free((void *)azConfig);
-  sqlite3Fts5ConfigFree(pConfig);
-  sqlite3Fts5ExprFree(pExpr);
-}
-
-static void fts5ExprFunctionHr(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args */
-  sqlite3_value **apVal           /* Function arguments */
-){
-  fts5ExprFunction(pCtx, nArg, apVal, 0);
-}
-static void fts5ExprFunctionTcl(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args */
-  sqlite3_value **apVal           /* Function arguments */
-){
-  fts5ExprFunction(pCtx, nArg, apVal, 1);
-}
-
-/*
-** The implementation of an SQLite user-defined-function that accepts a
-** single integer as an argument. If the integer is an alpha-numeric
-** unicode code point, 1 is returned. Otherwise 0.
-*/
-static void fts5ExprIsAlnum(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args */
-  sqlite3_value **apVal           /* Function arguments */
-){
-  int iCode;
-  u8 aArr[32];
-  if( nArg!=1 ){
-    sqlite3_result_error(pCtx,
-        "wrong number of arguments to function fts5_isalnum", -1
-    );
-    return;
-  }
-  memset(aArr, 0, sizeof(aArr));
-  sqlite3Fts5UnicodeCatParse("L*", aArr);
-  sqlite3Fts5UnicodeCatParse("N*", aArr);
-  sqlite3Fts5UnicodeCatParse("Co", aArr);
-  iCode = sqlite3_value_int(apVal[0]);
-  sqlite3_result_int(pCtx, aArr[sqlite3Fts5UnicodeCategory((u32)iCode)]);
-}
-
-static void fts5ExprFold(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args */
-  sqlite3_value **apVal           /* Function arguments */
-){
-  if( nArg!=1 && nArg!=2 ){
-    sqlite3_result_error(pCtx,
-        "wrong number of arguments to function fts5_fold", -1
-    );
-  }else{
-    int iCode;
-    int bRemoveDiacritics = 0;
-    iCode = sqlite3_value_int(apVal[0]);
-    if( nArg==2 ) bRemoveDiacritics = sqlite3_value_int(apVal[1]);
-    sqlite3_result_int(pCtx, sqlite3Fts5UnicodeFold(iCode, bRemoveDiacritics));
-  }
-}
-#endif /* if SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-/*
-** This is called during initialization to register the fts5_expr() scalar
-** UDF with the SQLite handle passed as the only argument.
-*/
-static int sqlite3Fts5ExprInit(Fts5Global *pGlobal, sqlite3 *db){
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-  struct Fts5ExprFunc {
-    const char *z;
-    void (*x)(sqlite3_context*,int,sqlite3_value**);
-  } aFunc[] = {
-    { "fts5_expr",     fts5ExprFunctionHr },
-    { "fts5_expr_tcl", fts5ExprFunctionTcl },
-    { "fts5_isalnum",  fts5ExprIsAlnum },
-    { "fts5_fold",     fts5ExprFold },
-  };
-  int i;
-  int rc = SQLITE_OK;
-  void *pCtx = (void*)pGlobal;
-
-  for(i=0; rc==SQLITE_OK && i<ArraySize(aFunc); i++){
-    struct Fts5ExprFunc *p = &aFunc[i];
-    rc = sqlite3_create_function(db, p->z, -1, SQLITE_UTF8, pCtx, p->x, 0, 0);
-  }
-#else
-  int rc = SQLITE_OK;
-  UNUSED_PARAM2(pGlobal,db);
-#endif
-
-  /* Avoid warnings indicating that sqlite3Fts5ParserTrace() and
-  ** sqlite3Fts5ParserFallback() are unused */
-#ifndef NDEBUG
-  (void)sqlite3Fts5ParserTrace;
-#endif
-  (void)sqlite3Fts5ParserFallback;
-
-  return rc;
-}
-
-/*
-** Return the number of phrases in expression pExpr.
-*/
-static int sqlite3Fts5ExprPhraseCount(Fts5Expr *pExpr){
-  return (pExpr ? pExpr->nPhrase : 0);
-}
-
-/*
-** Return the number of terms in the iPhrase'th phrase in pExpr.
-*/
-static int sqlite3Fts5ExprPhraseSize(Fts5Expr *pExpr, int iPhrase){
-  if( iPhrase<0 || iPhrase>=pExpr->nPhrase ) return 0;
-  return pExpr->apExprPhrase[iPhrase]->nTerm;
-}
-
-/*
-** This function is used to access the current position list for phrase
-** iPhrase.
-*/
-static int sqlite3Fts5ExprPoslist(Fts5Expr *pExpr, int iPhrase, const u8 **pa){
-  int nRet;
-  Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
-  Fts5ExprNode *pNode = pPhrase->pNode;
-  if( pNode->bEof==0 && pNode->iRowid==pExpr->pRoot->iRowid ){
-    *pa = pPhrase->poslist.p;
-    nRet = pPhrase->poslist.n;
-  }else{
-    *pa = 0;
-    nRet = 0;
-  }
-  return nRet;
-}
-
-struct Fts5PoslistPopulator {
-  Fts5PoslistWriter writer;
-  int bOk;                        /* True if ok to populate */
-  int bMiss;
-};
-
-/*
-** Clear the position lists associated with all phrases in the expression
-** passed as the first argument. Argument bLive is true if the expression
-** might be pointing to a real entry, otherwise it has just been reset.
-**
-** At present this function is only used for detail=col and detail=none
-** fts5 tables. This implies that all phrases must be at most 1 token
-** in size, as phrase matches are not supported without detail=full.
-*/
-static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){
-  Fts5PoslistPopulator *pRet;
-  pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
-  if( pRet ){
-    int i;
-    memset(pRet, 0, sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
-    for(i=0; i<pExpr->nPhrase; i++){
-      Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
-      Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
-      assert( pExpr->apExprPhrase[i]->nTerm<=1 );
-      if( bLive &&
-          (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
-      ){
-        pRet[i].bMiss = 1;
-      }else{
-        pBuf->n = 0;
-      }
-    }
-  }
-  return pRet;
-}
-
-struct Fts5ExprCtx {
-  Fts5Expr *pExpr;
-  Fts5PoslistPopulator *aPopulator;
-  i64 iOff;
-};
-typedef struct Fts5ExprCtx Fts5ExprCtx;
-
-/*
-** TODO: Make this more efficient!
-*/
-static int fts5ExprColsetTest(Fts5Colset *pColset, int iCol){
-  int i;
-  for(i=0; i<pColset->nCol; i++){
-    if( pColset->aiCol[i]==iCol ) return 1;
-  }
-  return 0;
-}
-
-/*
-** pToken is a buffer nToken bytes in size that may or may not contain
-** an embedded 0x00 byte. If it does, return the number of bytes in
-** the buffer before the 0x00. If it does not, return nToken.
-*/
-static int fts5QueryTerm(const char *pToken, int nToken){
-  int ii;
-  for(ii=0; ii<nToken && pToken[ii]; ii++){}
-  return ii;
-}
-
-static int fts5ExprPopulatePoslistsCb(
-  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 iUnused1,              /* Byte offset of token within input text */
-  int iUnused2               /* Byte offset of end of token within input text */
-){
-  Fts5ExprCtx *p = (Fts5ExprCtx*)pCtx;
-  Fts5Expr *pExpr = p->pExpr;
-  int i;
-  int nQuery = nToken;
-  i64 iRowid = pExpr->pRoot->iRowid;
-
-  UNUSED_PARAM2(iUnused1, iUnused2);
-
-  if( nQuery>FTS5_MAX_TOKEN_SIZE ) nQuery = FTS5_MAX_TOKEN_SIZE;
-  if( pExpr->pConfig->bTokendata ){
-    nQuery = fts5QueryTerm(pToken, nQuery);
-  }
-  if( (tflags & FTS5_TOKEN_COLOCATED)==0 ) p->iOff++;
-  for(i=0; i<pExpr->nPhrase; i++){
-    Fts5ExprTerm *pT;
-    if( p->aPopulator[i].bOk==0 ) continue;
-    for(pT=&pExpr->apExprPhrase[i]->aTerm[0]; pT; pT=pT->pSynonym){
-      if( (pT->nQueryTerm==nQuery || (pT->nQueryTerm<nQuery && pT->bPrefix))
-       && memcmp(pT->pTerm, pToken, pT->nQueryTerm)==0
-      ){
-        int rc = sqlite3Fts5PoslistWriterAppend(
-            &pExpr->apExprPhrase[i]->poslist, &p->aPopulator[i].writer, p->iOff
-        );
-        if( rc==SQLITE_OK && (pExpr->pConfig->bTokendata || pT->bPrefix) ){
-          int iCol = p->iOff>>32;
-          int iTokOff = p->iOff & 0x7FFFFFFF;
-          rc = sqlite3Fts5IndexIterWriteTokendata(
-              pT->pIter, pToken, nToken, iRowid, iCol, iTokOff
-          );
-        }
-        if( rc ) return rc;
-        break;
-      }
-    }
-  }
-  return SQLITE_OK;
-}
-
-static int sqlite3Fts5ExprPopulatePoslists(
-  Fts5Config *pConfig,
-  Fts5Expr *pExpr,
-  Fts5PoslistPopulator *aPopulator,
-  int iCol,
-  const char *z, int n
-){
-  int i;
-  Fts5ExprCtx sCtx;
-  sCtx.pExpr = pExpr;
-  sCtx.aPopulator = aPopulator;
-  sCtx.iOff = (((i64)iCol) << 32) - 1;
-
-  for(i=0; i<pExpr->nPhrase; i++){
-    Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
-    Fts5Colset *pColset = pNode->pNear->pColset;
-    if( (pColset && 0==fts5ExprColsetTest(pColset, iCol))
-     || aPopulator[i].bMiss
-    ){
-      aPopulator[i].bOk = 0;
-    }else{
-      aPopulator[i].bOk = 1;
-    }
-  }
-
-  return sqlite3Fts5Tokenize(pConfig,
-      FTS5_TOKENIZE_DOCUMENT, z, n, (void*)&sCtx, fts5ExprPopulatePoslistsCb
-  );
-}
-
-static void fts5ExprClearPoslists(Fts5ExprNode *pNode){
-  if( pNode->eType==FTS5_TERM || pNode->eType==FTS5_STRING ){
-    pNode->pNear->apPhrase[0]->poslist.n = 0;
-  }else{
-    int i;
-    for(i=0; i<pNode->nChild; i++){
-      fts5ExprClearPoslists(pNode->apChild[i]);
-    }
-  }
-}
-
-static int fts5ExprCheckPoslists(Fts5ExprNode *pNode, i64 iRowid){
-  pNode->iRowid = iRowid;
-  pNode->bEof = 0;
-  switch( pNode->eType ){
-    case 0:
-    case FTS5_TERM:
-    case FTS5_STRING:
-      return (pNode->pNear->apPhrase[0]->poslist.n>0);
-
-    case FTS5_AND: {
-      int i;
-      for(i=0; i<pNode->nChild; i++){
-        if( fts5ExprCheckPoslists(pNode->apChild[i], iRowid)==0 ){
-          fts5ExprClearPoslists(pNode);
-          return 0;
-        }
-      }
-      break;
-    }
-
-    case FTS5_OR: {
-      int i;
-      int bRet = 0;
-      for(i=0; i<pNode->nChild; i++){
-        if( fts5ExprCheckPoslists(pNode->apChild[i], iRowid) ){
-          bRet = 1;
-        }
-      }
-      return bRet;
-    }
-
-    default: {
-      assert( pNode->eType==FTS5_NOT );
-      if( 0==fts5ExprCheckPoslists(pNode->apChild[0], iRowid)
-          || 0!=fts5ExprCheckPoslists(pNode->apChild[1], iRowid)
-        ){
-        fts5ExprClearPoslists(pNode);
-        return 0;
-      }
-      break;
-    }
-  }
-  return 1;
-}
-
-static void sqlite3Fts5ExprCheckPoslists(Fts5Expr *pExpr, i64 iRowid){
-  fts5ExprCheckPoslists(pExpr->pRoot, iRowid);
-}
-
-/*
-** This function is only called for detail=columns tables.
-*/
-static int sqlite3Fts5ExprPhraseCollist(
-  Fts5Expr *pExpr,
-  int iPhrase,
-  const u8 **ppCollist,
-  int *pnCollist
-){
-  Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
-  Fts5ExprNode *pNode = pPhrase->pNode;
-  int rc = SQLITE_OK;
-
-  assert( iPhrase>=0 && iPhrase<pExpr->nPhrase );
-  assert( pExpr->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
-
-  if( pNode->bEof==0
-   && pNode->iRowid==pExpr->pRoot->iRowid
-   && pPhrase->poslist.n>0
-  ){
-    Fts5ExprTerm *pTerm = &pPhrase->aTerm[0];
-    if( pTerm->pSynonym ){
-      Fts5Buffer *pBuf = (Fts5Buffer*)&pTerm->pSynonym[1];
-      rc = fts5ExprSynonymList(
-          pTerm, pNode->iRowid, pBuf, (u8**)ppCollist, pnCollist
-      );
-    }else{
-      *ppCollist = pPhrase->aTerm[0].pIter->pData;
-      *pnCollist = pPhrase->aTerm[0].pIter->nData;
-    }
-  }else{
-    *ppCollist = 0;
-    *pnCollist = 0;
-  }
-
-  return rc;
-}
-
-/*
-** Does the work of the fts5_api.xQueryToken() API method.
-*/
-static int sqlite3Fts5ExprQueryToken(
-  Fts5Expr *pExpr,
-  int iPhrase,
-  int iToken,
-  const char **ppOut,
-  int *pnOut
-){
-  Fts5ExprPhrase *pPhrase = 0;
-
-  if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
-    return SQLITE_RANGE;
-  }
-  pPhrase = pExpr->apExprPhrase[iPhrase];
-  if( iToken<0 || iToken>=pPhrase->nTerm ){
-    return SQLITE_RANGE;
-  }
-
-  *ppOut = pPhrase->aTerm[iToken].pTerm;
-  *pnOut = pPhrase->aTerm[iToken].nFullTerm;
-  return SQLITE_OK;
-}
-
-/*
-** Does the work of the fts5_api.xInstToken() API method.
-*/
-static int sqlite3Fts5ExprInstToken(
-  Fts5Expr *pExpr,
-  i64 iRowid,
-  int iPhrase,
-  int iCol,
-  int iOff,
-  int iToken,
-  const char **ppOut,
-  int *pnOut
-){
-  Fts5ExprPhrase *pPhrase = 0;
-  Fts5ExprTerm *pTerm = 0;
-  int rc = SQLITE_OK;
-
-  if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
-    return SQLITE_RANGE;
-  }
-  pPhrase = pExpr->apExprPhrase[iPhrase];
-  if( iToken<0 || iToken>=pPhrase->nTerm ){
-    return SQLITE_RANGE;
-  }
-  pTerm = &pPhrase->aTerm[iToken];
-  if( pExpr->pConfig->bTokendata || pTerm->bPrefix ){
-    rc = sqlite3Fts5IterToken(
-        pTerm->pIter, pTerm->pTerm, pTerm->nQueryTerm,
-        iRowid, iCol, iOff+iToken, ppOut, pnOut
-    );
-  }else{
-    *ppOut = pTerm->pTerm;
-    *pnOut = pTerm->nFullTerm;
-  }
-  return rc;
-}
-
-/*
-** Clear the token mappings for all Fts5IndexIter objects managed by
-** the expression passed as the only argument.
-*/
-static void sqlite3Fts5ExprClearTokens(Fts5Expr *pExpr){
-  int ii;
-  for(ii=0; ii<pExpr->nPhrase; ii++){
-    Fts5ExprTerm *pT;
-    for(pT=&pExpr->apExprPhrase[ii]->aTerm[0]; pT; pT=pT->pSynonym){
-      sqlite3Fts5IndexIterClearTokendata(pT->pIter);
-    }
-  }
-}
-
-/*
-** 2014 August 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.
-**
-******************************************************************************
-**
-*/
-
-
-
-/* #include "fts5Int.h" */
-
-typedef struct Fts5HashEntry Fts5HashEntry;
-
-/*
-** This file contains the implementation of an in-memory hash table used
-** to accumulate "term -> doclist" content before it is flushed to a level-0
-** segment.
-*/
-
-
-struct Fts5Hash {
-  int eDetail;                    /* Copy of Fts5Config.eDetail */
-  int *pnByte;                    /* Pointer to bytes counter */
-  int nEntry;                     /* Number of entries currently in hash */
-  int nSlot;                      /* Size of aSlot[] array */
-  Fts5HashEntry *pScan;           /* Current ordered scan item */
-  Fts5HashEntry **aSlot;          /* Array of hash slots */
-};
-
-/*
-** Each entry in the hash table is represented by an object of the
-** following type. Each object, its key, and its current data are stored
-** in a single memory allocation. The key immediately follows the object
-** in memory. The position list data immediately follows the key data
-** in memory.
-**
-** The key is Fts5HashEntry.nKey bytes in size. It consists of a single
-** byte identifying the index (either the main term index or a prefix-index),
-** followed by the term data. For example: "0token". There is no
-** nul-terminator - in this case nKey=6.
-**
-** The data that follows the key is in a similar, but not identical format
-** to the doclist data stored in the database. It is:
-**
-**   * Rowid, as a varint
-**   * Position list, without 0x00 terminator.
-**   * Size of previous position list and rowid, as a 4 byte
-**     big-endian integer.
-**
-** iRowidOff:
-**   Offset of last rowid written to data area. Relative to first byte of
-**   structure.
-**
-** nData:
-**   Bytes of data written since iRowidOff.
-*/
-struct Fts5HashEntry {
-  Fts5HashEntry *pHashNext;       /* Next hash entry with same hash-key */
-  Fts5HashEntry *pScanNext;       /* Next entry in sorted order */
-
-  int nAlloc;                     /* Total size of allocation */
-  int iSzPoslist;                 /* Offset of space for 4-byte poslist size */
-  int nData;                      /* Total bytes of data (incl. structure) */
-  int nKey;                       /* Length of key in bytes */
-  u8 bDel;                        /* Set delete-flag @ iSzPoslist */
-  u8 bContent;                    /* Set content-flag (detail=none mode) */
-  i16 iCol;                       /* Column of last value written */
-  int iPos;                       /* Position of last value written */
-  i64 iRowid;                     /* Rowid of last value written */
-};
-
-/*
-** Equivalent to:
-**
-**   char *fts5EntryKey(Fts5HashEntry *pEntry){ return zKey; }
-*/
-#define fts5EntryKey(p) ( ((char *)(&(p)[1])) )
-
-
-/*
-** Allocate a new hash table.
-*/
-static int sqlite3Fts5HashNew(Fts5Config *pConfig, Fts5Hash **ppNew, int *pnByte){
-  int rc = SQLITE_OK;
-  Fts5Hash *pNew;
-
-  *ppNew = pNew = (Fts5Hash*)sqlite3_malloc64(sizeof(Fts5Hash));
-  if( pNew==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    sqlite3_int64 nByte;
-    memset(pNew, 0, sizeof(Fts5Hash));
-    pNew->pnByte = pnByte;
-    pNew->eDetail = pConfig->eDetail;
-
-    pNew->nSlot = 1024;
-    nByte = sizeof(Fts5HashEntry*) * pNew->nSlot;
-    pNew->aSlot = (Fts5HashEntry**)sqlite3_malloc64(nByte);
-    if( pNew->aSlot==0 ){
-      sqlite3_free(pNew);
-      *ppNew = 0;
-      rc = SQLITE_NOMEM;
-    }else{
-      memset(pNew->aSlot, 0, (size_t)nByte);
-    }
-  }
-  return rc;
-}
-
-/*
-** Free a hash table object.
-*/
-static void sqlite3Fts5HashFree(Fts5Hash *pHash){
-  if( pHash ){
-    sqlite3Fts5HashClear(pHash);
-    sqlite3_free(pHash->aSlot);
-    sqlite3_free(pHash);
-  }
-}
-
-/*
-** Empty (but do not delete) a hash table.
-*/
-static void sqlite3Fts5HashClear(Fts5Hash *pHash){
-  int i;
-  for(i=0; i<pHash->nSlot; i++){
-    Fts5HashEntry *pNext;
-    Fts5HashEntry *pSlot;
-    for(pSlot=pHash->aSlot[i]; pSlot; pSlot=pNext){
-      pNext = pSlot->pHashNext;
-      sqlite3_free(pSlot);
-    }
-  }
-  memset(pHash->aSlot, 0, pHash->nSlot * sizeof(Fts5HashEntry*));
-  pHash->nEntry = 0;
-}
-
-static unsigned int fts5HashKey(int nSlot, const u8 *p, int n){
-  int i;
-  unsigned int h = 13;
-  for(i=n-1; i>=0; i--){
-    h = (h << 3) ^ h ^ p[i];
-  }
-  return (h % nSlot);
-}
-
-static unsigned int fts5HashKey2(int nSlot, u8 b, const u8 *p, int n){
-  int i;
-  unsigned int h = 13;
-  for(i=n-1; i>=0; i--){
-    h = (h << 3) ^ h ^ p[i];
-  }
-  h = (h << 3) ^ h ^ b;
-  return (h % nSlot);
-}
-
-/*
-** Resize the hash table by doubling the number of slots.
-*/
-static int fts5HashResize(Fts5Hash *pHash){
-  int nNew = pHash->nSlot*2;
-  int i;
-  Fts5HashEntry **apNew;
-  Fts5HashEntry **apOld = pHash->aSlot;
-
-  apNew = (Fts5HashEntry**)sqlite3_malloc64(nNew*sizeof(Fts5HashEntry*));
-  if( !apNew ) return SQLITE_NOMEM;
-  memset(apNew, 0, nNew*sizeof(Fts5HashEntry*));
-
-  for(i=0; i<pHash->nSlot; i++){
-    while( apOld[i] ){
-      unsigned int iHash;
-      Fts5HashEntry *p = apOld[i];
-      apOld[i] = p->pHashNext;
-      iHash = fts5HashKey(nNew, (u8*)fts5EntryKey(p), p->nKey);
-      p->pHashNext = apNew[iHash];
-      apNew[iHash] = p;
-    }
-  }
-
-  sqlite3_free(apOld);
-  pHash->nSlot = nNew;
-  pHash->aSlot = apNew;
-  return SQLITE_OK;
-}
-
-static int fts5HashAddPoslistSize(
-  Fts5Hash *pHash,
-  Fts5HashEntry *p,
-  Fts5HashEntry *p2
-){
-  int nRet = 0;
-  if( p->iSzPoslist ){
-    u8 *pPtr = p2 ? (u8*)p2 : (u8*)p;
-    int nData = p->nData;
-    if( pHash->eDetail==FTS5_DETAIL_NONE ){
-      assert( nData==p->iSzPoslist );
-      if( p->bDel ){
-        pPtr[nData++] = 0x00;
-        if( p->bContent ){
-          pPtr[nData++] = 0x00;
-        }
-      }
-    }else{
-      int nSz = (nData - p->iSzPoslist - 1);       /* Size in bytes */
-      int nPos = nSz*2 + p->bDel;                     /* Value of nPos field */
-
-      assert( p->bDel==0 || p->bDel==1 );
-      if( nPos<=127 ){
-        pPtr[p->iSzPoslist] = (u8)nPos;
-      }else{
-        int nByte = sqlite3Fts5GetVarintLen((u32)nPos);
-        memmove(&pPtr[p->iSzPoslist + nByte], &pPtr[p->iSzPoslist + 1], nSz);
-        sqlite3Fts5PutVarint(&pPtr[p->iSzPoslist], nPos);
-        nData += (nByte-1);
-      }
-    }
-
-    nRet = nData - p->nData;
-    if( p2==0 ){
-      p->iSzPoslist = 0;
-      p->bDel = 0;
-      p->bContent = 0;
-      p->nData = nData;
-    }
-  }
-  return nRet;
-}
-
-/*
-** Add an entry to the in-memory hash table. The key is the concatenation
-** of bByte and (pToken/nToken). The value is (iRowid/iCol/iPos).
-**
-**     (bByte || pToken) -> (iRowid,iCol,iPos)
-**
-** Or, if iCol is negative, then the value is a delete marker.
-*/
-static int sqlite3Fts5HashWrite(
-  Fts5Hash *pHash,
-  i64 iRowid,                     /* Rowid for this entry */
-  int iCol,                       /* Column token appears in (-ve -> delete) */
-  int iPos,                       /* Position of token within column */
-  char bByte,                     /* First byte of token */
-  const char *pToken, int nToken  /* Token to add or remove to or from index */
-){
-  unsigned int iHash;
-  Fts5HashEntry *p;
-  u8 *pPtr;
-  int nIncr = 0;                  /* Amount to increment (*pHash->pnByte) by */
-  int bNew;                       /* If non-delete entry should be written */
-
-  bNew = (pHash->eDetail==FTS5_DETAIL_FULL);
-
-  /* Attempt to locate an existing hash entry */
-  iHash = fts5HashKey2(pHash->nSlot, (u8)bByte, (const u8*)pToken, nToken);
-  for(p=pHash->aSlot[iHash]; p; p=p->pHashNext){
-    char *zKey = fts5EntryKey(p);
-    if( zKey[0]==bByte
-     && p->nKey==nToken+1
-     && memcmp(&zKey[1], pToken, nToken)==0
-    ){
-      break;
-    }
-  }
-
-  /* If an existing hash entry cannot be found, create a new one. */
-  if( p==0 ){
-    /* Figure out how much space to allocate */
-    char *zKey;
-    sqlite3_int64 nByte = sizeof(Fts5HashEntry) + (nToken+1) + 1 + 64;
-    if( nByte<128 ) nByte = 128;
-
-    /* Grow the Fts5Hash.aSlot[] array if necessary. */
-    if( (pHash->nEntry*2)>=pHash->nSlot ){
-      int rc = fts5HashResize(pHash);
-      if( rc!=SQLITE_OK ) return rc;
-      iHash = fts5HashKey2(pHash->nSlot, (u8)bByte, (const u8*)pToken, nToken);
-    }
-
-    /* Allocate new Fts5HashEntry and add it to the hash table. */
-    p = (Fts5HashEntry*)sqlite3_malloc64(nByte);
-    if( !p ) return SQLITE_NOMEM;
-    memset(p, 0, sizeof(Fts5HashEntry));
-    p->nAlloc = (int)nByte;
-    zKey = fts5EntryKey(p);
-    zKey[0] = bByte;
-    memcpy(&zKey[1], pToken, nToken);
-    assert( iHash==fts5HashKey(pHash->nSlot, (u8*)zKey, nToken+1) );
-    p->nKey = nToken+1;
-    zKey[nToken+1] = '\0';
-    p->nData = nToken+1 + sizeof(Fts5HashEntry);
-    p->pHashNext = pHash->aSlot[iHash];
-    pHash->aSlot[iHash] = p;
-    pHash->nEntry++;
-
-    /* Add the first rowid field to the hash-entry */
-    p->nData += sqlite3Fts5PutVarint(&((u8*)p)[p->nData], iRowid);
-    p->iRowid = iRowid;
-
-    p->iSzPoslist = p->nData;
-    if( pHash->eDetail!=FTS5_DETAIL_NONE ){
-      p->nData += 1;
-      p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
-    }
-
-  }else{
-
-    /* Appending to an existing hash-entry. Check that there is enough
-    ** space to append the largest possible new entry. Worst case scenario
-    ** is:
-    **
-    **     + 9 bytes for a new rowid,
-    **     + 4 byte reserved for the "poslist size" varint.
-    **     + 1 byte for a "new column" byte,
-    **     + 3 bytes for a new column number (16-bit max) as a varint,
-    **     + 5 bytes for the new position offset (32-bit max).
-    */
-    if( (p->nAlloc - p->nData) < (9 + 4 + 1 + 3 + 5) ){
-      sqlite3_int64 nNew = p->nAlloc * 2;
-      Fts5HashEntry *pNew;
-      Fts5HashEntry **pp;
-      pNew = (Fts5HashEntry*)sqlite3_realloc64(p, nNew);
-      if( pNew==0 ) return SQLITE_NOMEM;
-      pNew->nAlloc = (int)nNew;
-      for(pp=&pHash->aSlot[iHash]; *pp!=p; pp=&(*pp)->pHashNext);
-      *pp = pNew;
-      p = pNew;
-    }
-    nIncr -= p->nData;
-  }
-  assert( (p->nAlloc - p->nData) >= (9 + 4 + 1 + 3 + 5) );
-
-  pPtr = (u8*)p;
-
-  /* If this is a new rowid, append the 4-byte size field for the previous
-  ** entry, and the new rowid for this entry.  */
-  if( iRowid!=p->iRowid ){
-    u64 iDiff = (u64)iRowid - (u64)p->iRowid;
-    fts5HashAddPoslistSize(pHash, p, 0);
-    p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iDiff);
-    p->iRowid = iRowid;
-    bNew = 1;
-    p->iSzPoslist = p->nData;
-    if( pHash->eDetail!=FTS5_DETAIL_NONE ){
-      p->nData += 1;
-      p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
-      p->iPos = 0;
-    }
-  }
-
-  if( iCol>=0 ){
-    if( pHash->eDetail==FTS5_DETAIL_NONE ){
-      p->bContent = 1;
-    }else{
-      /* Append a new column value, if necessary */
-      assert_nc( iCol>=p->iCol );
-      if( iCol!=p->iCol ){
-        if( pHash->eDetail==FTS5_DETAIL_FULL ){
-          pPtr[p->nData++] = 0x01;
-          p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
-          p->iCol = (i16)iCol;
-          p->iPos = 0;
-        }else{
-          bNew = 1;
-          p->iCol = (i16)(iPos = iCol);
-        }
-      }
-
-      /* Append the new position offset, if necessary */
-      if( bNew ){
-        p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iPos - p->iPos + 2);
-        p->iPos = iPos;
-      }
-    }
-  }else{
-    /* This is a delete. Set the delete flag. */
-    p->bDel = 1;
-  }
-
-  nIncr += p->nData;
-  *pHash->pnByte += nIncr;
-  return SQLITE_OK;
-}
-
-
-/*
-** Arguments pLeft and pRight point to linked-lists of hash-entry objects,
-** each sorted in key order. This function merges the two lists into a
-** single list and returns a pointer to its first element.
-*/
-static Fts5HashEntry *fts5HashEntryMerge(
-  Fts5HashEntry *pLeft,
-  Fts5HashEntry *pRight
-){
-  Fts5HashEntry *p1 = pLeft;
-  Fts5HashEntry *p2 = pRight;
-  Fts5HashEntry *pRet = 0;
-  Fts5HashEntry **ppOut = &pRet;
-
-  while( p1 || p2 ){
-    if( p1==0 ){
-      *ppOut = p2;
-      p2 = 0;
-    }else if( p2==0 ){
-      *ppOut = p1;
-      p1 = 0;
-    }else{
-      char *zKey1 = fts5EntryKey(p1);
-      char *zKey2 = fts5EntryKey(p2);
-      int nMin = MIN(p1->nKey, p2->nKey);
-
-      int cmp = memcmp(zKey1, zKey2, nMin);
-      if( cmp==0 ){
-        cmp = p1->nKey - p2->nKey;
-      }
-      assert( cmp!=0 );
-
-      if( cmp>0 ){
-        /* p2 is smaller */
-        *ppOut = p2;
-        ppOut = &p2->pScanNext;
-        p2 = p2->pScanNext;
-      }else{
-        /* p1 is smaller */
-        *ppOut = p1;
-        ppOut = &p1->pScanNext;
-        p1 = p1->pScanNext;
-      }
-      *ppOut = 0;
-    }
-  }
-
-  return pRet;
-}
-
-/*
-** Link all tokens from hash table iHash into a list in sorted order. The
-** tokens are not removed from the hash table.
-*/
-static int fts5HashEntrySort(
-  Fts5Hash *pHash,
-  const char *pTerm, int nTerm,   /* Query prefix, if any */
-  Fts5HashEntry **ppSorted
-){
-  const int nMergeSlot = 32;
-  Fts5HashEntry **ap;
-  Fts5HashEntry *pList;
-  int iSlot;
-  int i;
-
-  *ppSorted = 0;
-  ap = sqlite3_malloc64(sizeof(Fts5HashEntry*) * nMergeSlot);
-  if( !ap ) return SQLITE_NOMEM;
-  memset(ap, 0, sizeof(Fts5HashEntry*) * nMergeSlot);
-
-  for(iSlot=0; iSlot<pHash->nSlot; iSlot++){
-    Fts5HashEntry *pIter;
-    for(pIter=pHash->aSlot[iSlot]; pIter; pIter=pIter->pHashNext){
-      if( pTerm==0
-       || (pIter->nKey>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
-      ){
-        Fts5HashEntry *pEntry = pIter;
-        pEntry->pScanNext = 0;
-        for(i=0; ap[i]; i++){
-          pEntry = fts5HashEntryMerge(pEntry, ap[i]);
-          ap[i] = 0;
-        }
-        ap[i] = pEntry;
-      }
-    }
-  }
-
-  pList = 0;
-  for(i=0; i<nMergeSlot; i++){
-    pList = fts5HashEntryMerge(pList, ap[i]);
-  }
-
-  sqlite3_free(ap);
-  *ppSorted = pList;
-  return SQLITE_OK;
-}
-
-/*
-** Query the hash table for a doclist associated with term pTerm/nTerm.
-*/
-static int sqlite3Fts5HashQuery(
-  Fts5Hash *pHash,                /* Hash table to query */
-  int nPre,
-  const char *pTerm, int nTerm,   /* Query term */
-  void **ppOut,                   /* OUT: Pointer to new object */
-  int *pnDoclist                  /* OUT: Size of doclist in bytes */
-){
-  unsigned int iHash = fts5HashKey(pHash->nSlot, (const u8*)pTerm, nTerm);
-  char *zKey = 0;
-  Fts5HashEntry *p;
-
-  for(p=pHash->aSlot[iHash]; p; p=p->pHashNext){
-    zKey = fts5EntryKey(p);
-    if( nTerm==p->nKey && memcmp(zKey, pTerm, nTerm)==0 ) break;
-  }
-
-  if( p ){
-    int nHashPre = sizeof(Fts5HashEntry) + nTerm;
-    int nList = p->nData - nHashPre;
-    u8 *pRet = (u8*)(*ppOut = sqlite3_malloc64(nPre + nList + 10));
-    if( pRet ){
-      Fts5HashEntry *pFaux = (Fts5HashEntry*)&pRet[nPre-nHashPre];
-      memcpy(&pRet[nPre], &((u8*)p)[nHashPre], nList);
-      nList += fts5HashAddPoslistSize(pHash, p, pFaux);
-      *pnDoclist = nList;
-    }else{
-      *pnDoclist = 0;
-      return SQLITE_NOMEM;
-    }
-  }else{
-    *ppOut = 0;
-    *pnDoclist = 0;
-  }
-
-  return SQLITE_OK;
-}
-
-static int sqlite3Fts5HashScanInit(
-  Fts5Hash *p,                    /* Hash table to query */
-  const char *pTerm, int nTerm    /* Query prefix */
-){
-  return fts5HashEntrySort(p, pTerm, nTerm, &p->pScan);
-}
-
-#ifdef SQLITE_DEBUG
-static int fts5HashCount(Fts5Hash *pHash){
-  int nEntry = 0;
-  int ii;
-  for(ii=0; ii<pHash->nSlot; ii++){
-    Fts5HashEntry *p = 0;
-    for(p=pHash->aSlot[ii]; p; p=p->pHashNext){
-      nEntry++;
-    }
-  }
-  return nEntry;
-}
-#endif
-
-/*
-** Return true if the hash table is empty, false otherwise.
-*/
-static int sqlite3Fts5HashIsEmpty(Fts5Hash *pHash){
-  assert( pHash->nEntry==fts5HashCount(pHash) );
-  return pHash->nEntry==0;
-}
-
-static void sqlite3Fts5HashScanNext(Fts5Hash *p){
-  assert( !sqlite3Fts5HashScanEof(p) );
-  p->pScan = p->pScan->pScanNext;
-}
-
-static int sqlite3Fts5HashScanEof(Fts5Hash *p){
-  return (p->pScan==0);
-}
-
-static void sqlite3Fts5HashScanEntry(
-  Fts5Hash *pHash,
-  const char **pzTerm,            /* OUT: term (nul-terminated) */
-  int *pnTerm,                    /* OUT: Size of term in bytes */
-  const u8 **ppDoclist,           /* OUT: pointer to doclist */
-  int *pnDoclist                  /* OUT: size of doclist in bytes */
-){
-  Fts5HashEntry *p;
-  if( (p = pHash->pScan) ){
-    char *zKey = fts5EntryKey(p);
-    int nTerm = p->nKey;
-    fts5HashAddPoslistSize(pHash, p, 0);
-    *pzTerm = zKey;
-    *pnTerm = nTerm;
-    *ppDoclist = (const u8*)&zKey[nTerm];
-    *pnDoclist = p->nData - (sizeof(Fts5HashEntry) + nTerm);
-  }else{
-    *pzTerm = 0;
-    *pnTerm = 0;
-    *ppDoclist = 0;
-    *pnDoclist = 0;
-  }
-}
-
-/*
-** 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.
-**
-******************************************************************************
-**
-** Low level access to the FTS index stored in the database file. The
-** routines in this file file implement all read and write access to the
-** %_data table. Other parts of the system access this functionality via
-** the interface defined in fts5Int.h.
-*/
-
-
-/* #include "fts5Int.h" */
-
-/*
-** Overview:
-**
-** The %_data table contains all the FTS indexes for an FTS5 virtual table.
-** As well as the main term index, there may be up to 31 prefix indexes.
-** The format is similar to FTS3/4, except that:
-**
-**   * all segment b-tree leaf data is stored in fixed size page records
-**     (e.g. 1000 bytes). A single doclist may span multiple pages. Care is
-**     taken to ensure it is possible to iterate in either direction through
-**     the entries in a doclist, or to seek to a specific entry within a
-**     doclist, without loading it into memory.
-**
-**   * large doclists that span many pages have associated "doclist index"
-**     records that contain a copy of the first rowid on each page spanned by
-**     the doclist. This is used to speed up seek operations, and merges of
-**     large doclists with very small doclists.
-**
-**   * extra fields in the "structure record" record the state of ongoing
-**     incremental merge operations.
-**
-*/
-
-
-#define FTS5_OPT_WORK_UNIT  1000  /* Number of leaf pages per optimize step */
-#define FTS5_WORK_UNIT      64    /* Number of leaf pages in unit of work */
-
-#define FTS5_MIN_DLIDX_SIZE 4     /* Add dlidx if this many empty pages */
-
-#define FTS5_MAIN_PREFIX '0'
-
-#if FTS5_MAX_PREFIX_INDEXES > 31
-# error "FTS5_MAX_PREFIX_INDEXES is too large"
-#endif
-
-#define FTS5_MAX_LEVEL 64
-
-/*
-** There are two versions of the format used for the structure record:
-**
-**   1. the legacy format, that may be read by all fts5 versions, and
-**
-**   2. the V2 format, which is used by contentless_delete=1 databases.
-**
-** Both begin with a 4-byte "configuration cookie" value. Then, a legacy
-** format structure record contains a varint - the number of levels in
-** the structure. Whereas a V2 structure record contains the constant
-** 4 bytes [0xff 0x00 0x00 0x01]. This is unambiguous as the value of a
-** varint has to be at least 16256 to begin with "0xFF". And the default
-** maximum number of levels is 64.
-**
-** See below for more on structure record formats.
-*/
-#define FTS5_STRUCTURE_V2 "\xFF\x00\x00\x01"
-
-/*
-** Details:
-**
-** The %_data table managed by this module,
-**
-**     CREATE TABLE %_data(id INTEGER PRIMARY KEY, block BLOB);
-**
-** , contains the following 6 types of records. See the comments surrounding
-** the FTS5_*_ROWID macros below for a description of how %_data rowids are
-** assigned to each fo them.
-**
-** 1. Structure Records:
-**
-**   The set of segments that make up an index - the index structure - are
-**   recorded in a single record within the %_data table. The record consists
-**   of a single 32-bit configuration cookie value followed by a list of
-**   SQLite varints.
-**
-**   If the structure record is a V2 record, the configuration cookie is
-**   followed by the following 4 bytes: [0xFF 0x00 0x00 0x01].
-**
-**   Next, the record continues with three varints:
-**
-**     + number of levels,
-**     + total number of segments on all levels,
-**     + value of write counter.
-**
-**   Then, for each level from 0 to nMax:
-**
-**     + number of input segments in ongoing merge.
-**     + total number of segments in level.
-**     + for each segment from oldest to newest:
-**         + segment id (always > 0)
-**         + first leaf page number (often 1, always greater than 0)
-**         + final leaf page number
-**
-**      Then, for V2 structures only:
-**
-**         + lower origin counter value,
-**         + upper origin counter value,
-**         + the number of tombstone hash pages.
-**
-** 2. The Averages Record:
-**
-**   A single record within the %_data table. The data is a list of varints.
-**   The first value is the number of rows in the index. Then, for each column
-**   from left to right, the total number of tokens in the column for all
-**   rows of the table.
-**
-** 3. Segment leaves:
-**
-**   TERM/DOCLIST FORMAT:
-**
-**     Most of each segment leaf is taken up by term/doclist data. The
-**     general format of term/doclist, starting with the first term
-**     on the leaf page, is:
-**
-**         varint : size of first term
-**         blob:    first term data
-**         doclist: first doclist
-**         zero-or-more {
-**           varint:  number of bytes in common with previous term
-**           varint:  number of bytes of new term data (nNew)
-**           blob:    nNew bytes of new term data
-**           doclist: next doclist
-**         }
-**
-**     doclist format:
-**
-**         varint:  first rowid
-**         poslist: first poslist
-**         zero-or-more {
-**           varint:  rowid delta (always > 0)
-**           poslist: next poslist
-**         }
-**
-**     poslist format:
-**
-**         varint: size of poslist in bytes multiplied by 2, not including
-**                 this field. Plus 1 if this entry carries the "delete" flag.
-**         collist: collist for column 0
-**         zero-or-more {
-**           0x01 byte
-**           varint: column number (I)
-**           collist: collist for column I
-**         }
-**
-**     collist format:
-**
-**         varint: first offset + 2
-**         zero-or-more {
-**           varint: offset delta + 2
-**         }
-**
-**   PAGE FORMAT
-**
-**     Each leaf page begins with a 4-byte header containing 2 16-bit
-**     unsigned integer fields in big-endian format. They are:
-**
-**       * The byte offset of the first rowid on the page, if it exists
-**         and occurs before the first term (otherwise 0).
-**
-**       * The byte offset of the start of the page footer. If the page
-**         footer is 0 bytes in size, then this field is the same as the
-**         size of the leaf page in bytes.
-**
-**     The page footer consists of a single varint for each term located
-**     on the page. Each varint is the byte offset of the current term
-**     within the page, delta-compressed against the previous value. In
-**     other words, the first varint in the footer is the byte offset of
-**     the first term, the second is the byte offset of the second less that
-**     of the first, and so on.
-**
-**     The term/doclist format described above is accurate if the entire
-**     term/doclist data fits on a single leaf page. If this is not the case,
-**     the format is changed in two ways:
-**
-**       + if the first rowid on a page occurs before the first term, it
-**         is stored as a literal value:
-**
-**             varint:  first rowid
-**
-**       + the first term on each page is stored in the same way as the
-**         very first term of the segment:
-**
-**             varint : size of first term
-**             blob:    first term data
-**
-** 5. Segment doclist indexes:
-**
-**   Doclist indexes are themselves b-trees, however they usually consist of
-**   a single leaf record only. The format of each doclist index leaf page
-**   is:
-**
-**     * Flags byte. Bits are:
-**         0x01: Clear if leaf is also the root page, otherwise set.
-**
-**     * Page number of fts index leaf page. As a varint.
-**
-**     * First rowid on page indicated by previous field. As a varint.
-**
-**     * A list of varints, one for each subsequent termless page. A
-**       positive delta if the termless page contains at least one rowid,
-**       or an 0x00 byte otherwise.
-**
-**   Internal doclist index nodes are:
-**
-**     * Flags byte. Bits are:
-**         0x01: Clear for root page, otherwise set.
-**
-**     * Page number of first child page. As a varint.
-**
-**     * Copy of first rowid on page indicated by previous field. As a varint.
-**
-**     * A list of delta-encoded varints - the first rowid on each subsequent
-**       child page.
-**
-** 6. Tombstone Hash Page
-**
-**   These records are only ever present in contentless_delete=1 tables.
-**   There are zero or more of these associated with each segment. They
-**   are used to store the tombstone rowids for rows contained in the
-**   associated segments.
-**
-**   The set of nHashPg tombstone hash pages associated with a single
-**   segment together form a single hash table containing tombstone rowids.
-**   To find the page of the hash on which a key might be stored:
-**
-**       iPg = (rowid % nHashPg)
-**
-**   Then, within page iPg, which has nSlot slots:
-**
-**       iSlot = (rowid / nHashPg) % nSlot
-**
-**   Each tombstone hash page begins with an 8 byte header:
-**
-**     1-byte:  Key-size (the size in bytes of each slot). Either 4 or 8.
-**     1-byte:  rowid-0-tombstone flag. This flag is only valid on the
-**              first tombstone hash page for each segment (iPg=0). If set,
-**              the hash table contains rowid 0. If clear, it does not.
-**              Rowid 0 is handled specially.
-**     2-bytes: unused.
-**     4-bytes: Big-endian integer containing number of entries on page.
-**
-**   Following this are nSlot 4 or 8 byte slots (depending on the key-size
-**   in the first byte of the page header). The number of slots may be
-**   determined based on the size of the page record and the key-size:
-**
-**     nSlot = (nByte - 8) / key-size
-*/
-
-/*
-** Rowids for the averages and structure records in the %_data table.
-*/
-#define FTS5_AVERAGES_ROWID     1    /* Rowid used for the averages record */
-#define FTS5_STRUCTURE_ROWID   10    /* The structure record */
-
-/*
-** Macros determining the rowids used by segment leaves and dlidx leaves
-** and nodes. All nodes and leaves are stored in the %_data table with large
-** positive rowids.
-**
-** Each segment has a unique non-zero 16-bit id.
-**
-** The rowid for each segment leaf is found by passing the segment id and
-** the leaf page number to the FTS5_SEGMENT_ROWID macro. Leaves are numbered
-** sequentially starting from 1.
-*/
-#define FTS5_DATA_ID_B     16     /* Max seg id number 65535 */
-#define FTS5_DATA_DLI_B     1     /* Doclist-index flag (1 bit) */
-#define FTS5_DATA_HEIGHT_B  5     /* Max dlidx tree height of 32 */
-#define FTS5_DATA_PAGE_B   31     /* Max page number of 2147483648 */
-
-#define fts5_dri(segid, dlidx, height, pgno) (                                 \
- ((i64)(segid)  << (FTS5_DATA_PAGE_B+FTS5_DATA_HEIGHT_B+FTS5_DATA_DLI_B)) +    \
- ((i64)(dlidx)  << (FTS5_DATA_PAGE_B + FTS5_DATA_HEIGHT_B)) +                  \
- ((i64)(height) << (FTS5_DATA_PAGE_B)) +                                       \
- ((i64)(pgno))                                                                 \
-)
-
-#define FTS5_SEGMENT_ROWID(segid, pgno)       fts5_dri(segid, 0, 0, pgno)
-#define FTS5_DLIDX_ROWID(segid, height, pgno) fts5_dri(segid, 1, height, pgno)
-#define FTS5_TOMBSTONE_ROWID(segid,ipg)       fts5_dri(segid+(1<<16), 0, 0, ipg)
-
-#ifdef SQLITE_DEBUG
-static int sqlite3Fts5Corrupt() { return SQLITE_CORRUPT_VTAB; }
-#endif
-
-
-/*
-** Each time a blob is read from the %_data table, it is padded with this
-** many zero bytes. This makes it easier to decode the various record formats
-** without overreading if the records are corrupt.
-*/
-#define FTS5_DATA_ZERO_PADDING 8
-#define FTS5_DATA_PADDING 20
-
-typedef struct Fts5Data Fts5Data;
-typedef struct Fts5DlidxIter Fts5DlidxIter;
-typedef struct Fts5DlidxLvl Fts5DlidxLvl;
-typedef struct Fts5DlidxWriter Fts5DlidxWriter;
-typedef struct Fts5Iter Fts5Iter;
-typedef struct Fts5PageWriter Fts5PageWriter;
-typedef struct Fts5SegIter Fts5SegIter;
-typedef struct Fts5DoclistIter Fts5DoclistIter;
-typedef struct Fts5SegWriter Fts5SegWriter;
-typedef struct Fts5Structure Fts5Structure;
-typedef struct Fts5StructureLevel Fts5StructureLevel;
-typedef struct Fts5StructureSegment Fts5StructureSegment;
-typedef struct Fts5TokenDataIter Fts5TokenDataIter;
-typedef struct Fts5TokenDataMap Fts5TokenDataMap;
-typedef struct Fts5TombstoneArray Fts5TombstoneArray;
-
-struct Fts5Data {
-  u8 *p;                          /* Pointer to buffer containing record */
-  int nn;                         /* Size of record in bytes */
-  int szLeaf;                     /* Size of leaf without page-index */
-};
-
-/*
-** One object per %_data table.
-**
-** nContentlessDelete:
-**   The number of contentless delete operations since the most recent
-**   call to fts5IndexFlush() or fts5IndexDiscardData(). This is tracked
-**   so that extra auto-merge work can be done by fts5IndexFlush() to
-**   account for the delete operations.
-*/
-struct Fts5Index {
-  Fts5Config *pConfig;            /* Virtual table configuration */
-  char *zDataTbl;                 /* Name of %_data table */
-  int nWorkUnit;                  /* Leaf pages in a "unit" of work */
-
-  /*
-  ** Variables related to the accumulation of tokens and doclists within the
-  ** in-memory hash tables before they are flushed to disk.
-  */
-  Fts5Hash *pHash;                /* Hash table for in-memory data */
-  int nPendingData;               /* Current bytes of pending data */
-  i64 iWriteRowid;                /* Rowid for current doc being written */
-  int bDelete;                    /* Current write is a delete */
-  int nContentlessDelete;         /* Number of contentless delete ops */
-  int nPendingRow;                /* Number of INSERT in hash table */
-
-  /* Error state. */
-  int rc;                         /* Current error code */
-  int flushRc;
-
-  /* State used by the fts5DataXXX() functions. */
-  sqlite3_blob *pReader;          /* RO incr-blob open on %_data table */
-  sqlite3_stmt *pWriter;          /* "INSERT ... %_data VALUES(?,?)" */
-  sqlite3_stmt *pDeleter;         /* "DELETE FROM %_data ... id>=? AND id<=?" */
-  sqlite3_stmt *pIdxWriter;       /* "INSERT ... %_idx VALUES(?,?,?,?)" */
-  sqlite3_stmt *pIdxDeleter;      /* "DELETE FROM %_idx WHERE segid=?" */
-  sqlite3_stmt *pIdxSelect;
-  sqlite3_stmt *pIdxNextSelect;
-  int nRead;                      /* Total number of blocks read */
-
-  sqlite3_stmt *pDeleteFromIdx;
-
-  sqlite3_stmt *pDataVersion;
-  i64 iStructVersion;             /* data_version when pStruct read */
-  Fts5Structure *pStruct;         /* Current db structure (or NULL) */
-};
-
-struct Fts5DoclistIter {
-  u8 *aEof;                       /* Pointer to 1 byte past end of doclist */
-
-  /* Output variables. aPoslist==0 at EOF */
-  i64 iRowid;
-  u8 *aPoslist;
-  int nPoslist;
-  int nSize;
-};
-
-/*
-** The contents of the "structure" record for each index are represented
-** using an Fts5Structure record in memory. Which uses instances of the
-** other Fts5StructureXXX types as components.
-**
-** nOriginCntr:
-**   This value is set to non-zero for structure records created for
-**   contentlessdelete=1 tables only. In that case it represents the
-**   origin value to apply to the next top-level segment created.
-*/
-struct Fts5StructureSegment {
-  int iSegid;                     /* Segment id */
-  int pgnoFirst;                  /* First leaf page number in segment */
-  int pgnoLast;                   /* Last leaf page number in segment */
-
-  /* contentlessdelete=1 tables only: */
-  u64 iOrigin1;
-  u64 iOrigin2;
-  int nPgTombstone;               /* Number of tombstone hash table pages */
-  u64 nEntryTombstone;            /* Number of tombstone entries that "count" */
-  u64 nEntry;                     /* Number of rows in this segment */
-};
-struct Fts5StructureLevel {
-  int nMerge;                     /* Number of segments in incr-merge */
-  int nSeg;                       /* Total number of segments on level */
-  Fts5StructureSegment *aSeg;     /* Array of segments. aSeg[0] is oldest. */
-};
-struct Fts5Structure {
-  int nRef;                       /* Object reference count */
-  u64 nWriteCounter;              /* Total leaves written to level 0 */
-  u64 nOriginCntr;                /* Origin value for next top-level segment */
-  int nSegment;                   /* Total segments in this structure */
-  int nLevel;                     /* Number of levels in this index */
-  Fts5StructureLevel aLevel[FLEXARRAY]; /* Array of nLevel level objects */
-};
-
-/* Size (in bytes) of an Fts5Structure object holding up to N levels */
-#define SZ_FTS5STRUCTURE(N) \
-         (offsetof(Fts5Structure,aLevel) + (N)*sizeof(Fts5StructureLevel))
-
-/*
-** An object of type Fts5SegWriter is used to write to segments.
-*/
-struct Fts5PageWriter {
-  int pgno;                       /* Page number for this page */
-  int iPrevPgidx;                 /* Previous value written into pgidx */
-  Fts5Buffer buf;                 /* Buffer containing leaf data */
-  Fts5Buffer pgidx;               /* Buffer containing page-index */
-  Fts5Buffer term;                /* Buffer containing previous term on page */
-};
-struct Fts5DlidxWriter {
-  int pgno;                       /* Page number for this page */
-  int bPrevValid;                 /* True if iPrev is valid */
-  i64 iPrev;                      /* Previous rowid value written to page */
-  Fts5Buffer buf;                 /* Buffer containing page data */
-};
-struct Fts5SegWriter {
-  int iSegid;                     /* Segid to write to */
-  Fts5PageWriter writer;          /* PageWriter object */
-  i64 iPrevRowid;                 /* Previous rowid written to current leaf */
-  u8 bFirstRowidInDoclist;        /* True if next rowid is first in doclist */
-  u8 bFirstRowidInPage;           /* True if next rowid is first in page */
-  /* TODO1: Can use (writer.pgidx.n==0) instead of bFirstTermInPage */
-  u8 bFirstTermInPage;            /* True if next term will be first in leaf */
-  int nLeafWritten;               /* Number of leaf pages written */
-  int nEmpty;                     /* Number of contiguous term-less nodes */
-
-  int nDlidx;                     /* Allocated size of aDlidx[] array */
-  Fts5DlidxWriter *aDlidx;        /* Array of Fts5DlidxWriter objects */
-
-  /* Values to insert into the %_idx table */
-  Fts5Buffer btterm;              /* Next term to insert into %_idx table */
-  int iBtPage;                    /* Page number corresponding to btterm */
-};
-
-typedef struct Fts5CResult Fts5CResult;
-struct Fts5CResult {
-  u16 iFirst;                     /* aSeg[] index of firstest iterator */
-  u8 bTermEq;                     /* True if the terms are equal */
-};
-
-/*
-** Object for iterating through a single segment, visiting each term/rowid
-** pair in the segment.
-**
-** pSeg:
-**   The segment to iterate through.
-**
-** iLeafPgno:
-**   Current leaf page number within segment.
-**
-** iLeafOffset:
-**   Byte offset within the current leaf that is the first byte of the
-**   position list data (one byte passed the position-list size field).
-**
-** pLeaf:
-**   Buffer containing current leaf page data. Set to NULL at EOF.
-**
-** iTermLeafPgno, iTermLeafOffset:
-**   Leaf page number containing the last term read from the segment. And
-**   the offset immediately following the term data.
-**
-** flags:
-**   Mask of FTS5_SEGITER_XXX values. Interpreted as follows:
-**
-**   FTS5_SEGITER_ONETERM:
-**     If set, set the iterator to point to EOF after the current doclist
-**     has been exhausted. Do not proceed to the next term in the segment.
-**
-**   FTS5_SEGITER_REVERSE:
-**     This flag is only ever set if FTS5_SEGITER_ONETERM is also set. If
-**     it is set, iterate through rowid in descending order instead of the
-**     default ascending order.
-**
-** iRowidOffset/nRowidOffset/aRowidOffset:
-**     These are used if the FTS5_SEGITER_REVERSE flag is set.
-**
-**     For each rowid on the page corresponding to the current term, the
-**     corresponding aRowidOffset[] entry is set to the byte offset of the
-**     start of the "position-list-size" field within the page.
-**
-** iTermIdx:
-**     Index of current term on iTermLeafPgno.
-**
-** apTombstone/nTombstone:
-**     These are used for contentless_delete=1 tables only. When the cursor
-**     is first allocated, the apTombstone[] array is allocated so that it
-**     is large enough for all tombstones hash pages associated with the
-**     segment. The pages themselves are loaded lazily from the database as
-**     they are required.
-*/
-struct Fts5SegIter {
-  Fts5StructureSegment *pSeg;     /* Segment to iterate through */
-  int flags;                      /* Mask of configuration flags */
-  int iLeafPgno;                  /* Current leaf page number */
-  Fts5Data *pLeaf;                /* Current leaf data */
-  Fts5Data *pNextLeaf;            /* Leaf page (iLeafPgno+1) */
-  i64 iLeafOffset;                /* Byte offset within current leaf */
-  Fts5TombstoneArray *pTombArray; /* Array of tombstone pages */
-
-  /* Next method */
-  void (*xNext)(Fts5Index*, Fts5SegIter*, int*);
-
-  /* The page and offset from which the current term was read. The offset
-  ** is the offset of the first rowid in the current doclist.  */
-  int iTermLeafPgno;
-  int iTermLeafOffset;
-
-  int iPgidxOff;                  /* Next offset in pgidx */
-  int iEndofDoclist;
-
-  /* The following are only used if the FTS5_SEGITER_REVERSE flag is set. */
-  int iRowidOffset;               /* Current entry in aRowidOffset[] */
-  int nRowidOffset;               /* Allocated size of aRowidOffset[] array */
-  int *aRowidOffset;              /* Array of offset to rowid fields */
-
-  Fts5DlidxIter *pDlidx;          /* If there is a doclist-index */
-
-  /* Variables populated based on current entry. */
-  Fts5Buffer term;                /* Current term */
-  i64 iRowid;                     /* Current rowid */
-  int nPos;                       /* Number of bytes in current position list */
-  u8 bDel;                        /* True if the delete flag is set */
-};
-
-static int fts5IndexCorruptRowid(Fts5Index *pIdx, i64 iRowid){
-  pIdx->rc = FTS5_CORRUPT;
-  sqlite3Fts5ConfigErrmsg(pIdx->pConfig,
-      "fts5: corruption found reading blob %lld from table \"%s\"",
-      iRowid, pIdx->pConfig->zName
-  );
-  return SQLITE_CORRUPT_VTAB;
-}
-#define FTS5_CORRUPT_ROWID(pIdx, iRowid) fts5IndexCorruptRowid(pIdx, iRowid)
-
-static int fts5IndexCorruptIter(Fts5Index *pIdx, Fts5SegIter *pIter){
-  pIdx->rc = FTS5_CORRUPT;
-  sqlite3Fts5ConfigErrmsg(pIdx->pConfig,
-      "fts5: corruption on page %d, segment %d, table \"%s\"",
-      pIter->iLeafPgno, pIter->pSeg->iSegid, pIdx->pConfig->zName
-  );
-  return SQLITE_CORRUPT_VTAB;
-}
-#define FTS5_CORRUPT_ITER(pIdx, pIter) fts5IndexCorruptIter(pIdx, pIter)
-
-static int fts5IndexCorruptIdx(Fts5Index *pIdx){
-  pIdx->rc = FTS5_CORRUPT;
-  sqlite3Fts5ConfigErrmsg(pIdx->pConfig,
-      "fts5: corruption in table \"%s\"", pIdx->pConfig->zName
-  );
-  return SQLITE_CORRUPT_VTAB;
-}
-#define FTS5_CORRUPT_IDX(pIdx) fts5IndexCorruptIdx(pIdx)
-
-
-/*
-** Array of tombstone pages. Reference counted.
-*/
-struct Fts5TombstoneArray {
-  int nRef;                         /* Number of pointers to this object */
-  int nTombstone;
-  Fts5Data *apTombstone[FLEXARRAY]; /* Array of tombstone pages */
-};
-
-/* Size (in bytes) of an Fts5TombstoneArray holding up to N tombstones */
-#define SZ_FTS5TOMBSTONEARRAY(N) \
-  (offsetof(Fts5TombstoneArray,apTombstone)+(N)*sizeof(Fts5Data*))
-
-/*
-** Argument is a pointer to an Fts5Data structure that contains a
-** leaf page.
-*/
-#define ASSERT_SZLEAF_OK(x) assert( \
-    (x)->szLeaf==(x)->nn || (x)->szLeaf==fts5GetU16(&(x)->p[2]) \
-)
-
-#define FTS5_SEGITER_ONETERM 0x01
-#define FTS5_SEGITER_REVERSE 0x02
-
-/*
-** Argument is a pointer to an Fts5Data structure that contains a leaf
-** page. This macro evaluates to true if the leaf contains no terms, or
-** false if it contains at least one term.
-*/
-#define fts5LeafIsTermless(x) ((x)->szLeaf >= (x)->nn)
-
-#define fts5LeafTermOff(x, i) (fts5GetU16(&(x)->p[(x)->szLeaf + (i)*2]))
-
-#define fts5LeafFirstRowidOff(x) (fts5GetU16((x)->p))
-
-/*
-** Object for iterating through the merged results of one or more segments,
-** visiting each term/rowid pair in the merged data.
-**
-** nSeg is always a power of two greater than or equal to the number of
-** segments that this object is merging data from. Both the aSeg[] and
-** aFirst[] arrays are sized at nSeg entries. The aSeg[] array is padded
-** with zeroed objects - these are handled as if they were iterators opened
-** on empty segments.
-**
-** The results of comparing segments aSeg[N] and aSeg[N+1], where N is an
-** even number, is stored in aFirst[(nSeg+N)/2]. The "result" of the
-** comparison in this context is the index of the iterator that currently
-** points to the smaller term/rowid combination. Iterators at EOF are
-** considered to be greater than all other iterators.
-**
-** aFirst[1] contains the index in aSeg[] of the iterator that points to
-** the smallest key overall. aFirst[0] is unused.
-**
-** poslist:
-**   Used by sqlite3Fts5IterPoslist() when the poslist needs to be buffered.
-**   There is no way to tell if this is populated or not.
-**
-** pColset:
-**   If not NULL, points to an object containing a set of column indices.
-**   Only matches that occur in one of these columns will be returned.
-**   The Fts5Iter does not own the Fts5Colset object, and so it is not
-**   freed when the iterator is closed - it is owned by the upper layer.
-*/
-struct Fts5Iter {
-  Fts5IndexIter base;             /* Base class containing output vars */
-  Fts5TokenDataIter *pTokenDataIter;
-
-  Fts5Index *pIndex;              /* Index that owns this iterator */
-  Fts5Buffer poslist;             /* Buffer containing current poslist */
-  Fts5Colset *pColset;            /* Restrict matches to these columns */
-
-  /* Invoked to set output variables. */
-  void (*xSetOutputs)(Fts5Iter*, Fts5SegIter*);
-
-  int nSeg;                       /* Size of aSeg[] array */
-  int bRev;                       /* True to iterate in reverse order */
-  u8 bSkipEmpty;                  /* True to skip deleted entries */
-
-  i64 iSwitchRowid;               /* Firstest rowid of other than aFirst[1] */
-  Fts5CResult *aFirst;            /* Current merge state (see above) */
-  Fts5SegIter aSeg[FLEXARRAY];    /* Array of segment iterators */
-};
-
-/* Size (in bytes) of an Fts5Iter object holding up to N segment iterators */
-#define SZ_FTS5ITER(N)  (offsetof(Fts5Iter,aSeg)+(N)*sizeof(Fts5SegIter))
-
-/*
-** An instance of the following type is used to iterate through the contents
-** of a doclist-index record.
-**
-** pData:
-**   Record containing the doclist-index data.
-**
-** bEof:
-**   Set to true once iterator has reached EOF.
-**
-** iOff:
-**   Set to the current offset within record pData.
-*/
-struct Fts5DlidxLvl {
-  Fts5Data *pData;              /* Data for current page of this level */
-  int iOff;                     /* Current offset into pData */
-  int bEof;                     /* At EOF already */
-  int iFirstOff;                /* Used by reverse iterators */
-
-  /* Output variables */
-  int iLeafPgno;                /* Page number of current leaf page */
-  i64 iRowid;                   /* First rowid on leaf iLeafPgno */
-};
-struct Fts5DlidxIter {
-  int nLvl;
-  int iSegid;
-  Fts5DlidxLvl aLvl[FLEXARRAY];
-};
-
-/* Size (in bytes) of an Fts5DlidxIter object with up to N levels */
-#define SZ_FTS5DLIDXITER(N) \
-          (offsetof(Fts5DlidxIter,aLvl)+(N)*sizeof(Fts5DlidxLvl))
-
-static void fts5PutU16(u8 *aOut, u16 iVal){
-  aOut[0] = (iVal>>8);
-  aOut[1] = (iVal&0xFF);
-}
-
-static u16 fts5GetU16(const u8 *aIn){
-  return ((u16)aIn[0] << 8) + aIn[1];
-}
-
-/*
-** The only argument points to a buffer at least 8 bytes in size. This
-** function interprets the first 8 bytes of the buffer as a 64-bit big-endian
-** unsigned integer and returns the result.
-*/
-static u64 fts5GetU64(u8 *a){
-  return ((u64)a[0] << 56)
-       + ((u64)a[1] << 48)
-       + ((u64)a[2] << 40)
-       + ((u64)a[3] << 32)
-       + ((u64)a[4] << 24)
-       + ((u64)a[5] << 16)
-       + ((u64)a[6] << 8)
-       + ((u64)a[7] << 0);
-}
-
-/*
-** The only argument points to a buffer at least 4 bytes in size. This
-** function interprets the first 4 bytes of the buffer as a 32-bit big-endian
-** unsigned integer and returns the result.
-*/
-static u32 fts5GetU32(const u8 *a){
-  return ((u32)a[0] << 24)
-       + ((u32)a[1] << 16)
-       + ((u32)a[2] << 8)
-       + ((u32)a[3] << 0);
-}
-
-/*
-** Write iVal, formated as a 64-bit big-endian unsigned integer, to the
-** buffer indicated by the first argument.
-*/
-static void fts5PutU64(u8 *a, u64 iVal){
-  a[0] = ((iVal >> 56) & 0xFF);
-  a[1] = ((iVal >> 48) & 0xFF);
-  a[2] = ((iVal >> 40) & 0xFF);
-  a[3] = ((iVal >> 32) & 0xFF);
-  a[4] = ((iVal >> 24) & 0xFF);
-  a[5] = ((iVal >> 16) & 0xFF);
-  a[6] = ((iVal >>  8) & 0xFF);
-  a[7] = ((iVal >>  0) & 0xFF);
-}
-
-/*
-** Write iVal, formated as a 32-bit big-endian unsigned integer, to the
-** buffer indicated by the first argument.
-*/
-static void fts5PutU32(u8 *a, u32 iVal){
-  a[0] = ((iVal >> 24) & 0xFF);
-  a[1] = ((iVal >> 16) & 0xFF);
-  a[2] = ((iVal >>  8) & 0xFF);
-  a[3] = ((iVal >>  0) & 0xFF);
-}
-
-/*
-** Allocate and return a buffer at least nByte bytes in size.
-**
-** If an OOM error is encountered, return NULL and set the error code in
-** the Fts5Index handle passed as the first argument.
-*/
-static void *fts5IdxMalloc(Fts5Index *p, sqlite3_int64 nByte){
-  return sqlite3Fts5MallocZero(&p->rc, nByte);
-}
-
-/*
-** Compare the contents of the pLeft buffer with the pRight/nRight blob.
-**
-** Return -ve if pLeft is smaller than pRight, 0 if they are equal or
-** +ve if pRight is smaller than pLeft. In other words:
-**
-**     res = *pLeft - *pRight
-*/
-#ifdef SQLITE_DEBUG
-static int fts5BufferCompareBlob(
-  Fts5Buffer *pLeft,              /* Left hand side of comparison */
-  const u8 *pRight, int nRight    /* Right hand side of comparison */
-){
-  int nCmp = MIN(pLeft->n, nRight);
-  int res = memcmp(pLeft->p, pRight, nCmp);
-  return (res==0 ? (pLeft->n - nRight) : res);
-}
-#endif
-
-/*
-** Compare the contents of the two buffers using memcmp(). If one buffer
-** is a prefix of the other, it is considered the lesser.
-**
-** Return -ve if pLeft is smaller than pRight, 0 if they are equal or
-** +ve if pRight is smaller than pLeft. In other words:
-**
-**     res = *pLeft - *pRight
-*/
-static int fts5BufferCompare(Fts5Buffer *pLeft, Fts5Buffer *pRight){
-  int nCmp, res;
-  nCmp = MIN(pLeft->n, pRight->n);
-  assert( nCmp<=0 || pLeft->p!=0 );
-  assert( nCmp<=0 || pRight->p!=0 );
-  res = fts5Memcmp(pLeft->p, pRight->p, nCmp);
-  return (res==0 ? (pLeft->n - pRight->n) : res);
-}
-
-static int fts5LeafFirstTermOff(Fts5Data *pLeaf){
-  int ret;
-  fts5GetVarint32(&pLeaf->p[pLeaf->szLeaf], ret);
-  return ret;
-}
-
-/*
-** Close the read-only blob handle, if it is open.
-*/
-static void fts5IndexCloseReader(Fts5Index *p){
-  if( p->pReader ){
-    int rc;
-    sqlite3_blob *pReader = p->pReader;
-    p->pReader = 0;
-    rc = sqlite3_blob_close(pReader);
-    if( p->rc==SQLITE_OK ) p->rc = rc;
-  }
-}
-
-/*
-** Retrieve a record from the %_data table.
-**
-** If an error occurs, NULL is returned and an error left in the
-** Fts5Index object.
-*/
-static Fts5Data *fts5DataRead(Fts5Index *p, i64 iRowid){
-  Fts5Data *pRet = 0;
-  if( p->rc==SQLITE_OK ){
-    int rc = SQLITE_OK;
-
-    if( p->pReader ){
-      /* This call may return SQLITE_ABORT if there has been a savepoint
-      ** rollback since it was last used. In this case a new blob handle
-      ** is required.  */
-      sqlite3_blob *pBlob = p->pReader;
-      p->pReader = 0;
-      rc = sqlite3_blob_reopen(pBlob, iRowid);
-      assert( p->pReader==0 );
-      p->pReader = pBlob;
-      if( rc!=SQLITE_OK ){
-        fts5IndexCloseReader(p);
-      }
-      if( rc==SQLITE_ABORT ) rc = SQLITE_OK;
-    }
-
-    /* If the blob handle is not open at this point, open it and seek
-    ** to the requested entry.  */
-    if( p->pReader==0 && rc==SQLITE_OK ){
-      Fts5Config *pConfig = p->pConfig;
-      rc = sqlite3_blob_open(pConfig->db,
-          pConfig->zDb, p->zDataTbl, "block", iRowid, 0, &p->pReader
-      );
-    }
-
-    /* If either of the sqlite3_blob_open() or sqlite3_blob_reopen() calls
-    ** above returned SQLITE_ERROR, return SQLITE_CORRUPT_VTAB instead.
-    ** All the reasons those functions might return SQLITE_ERROR - missing
-    ** table, missing row, non-blob/text in block column - indicate
-    ** backing store corruption.  */
-    if( rc==SQLITE_ERROR ) rc = FTS5_CORRUPT_ROWID(p, iRowid);
-
-    if( rc==SQLITE_OK ){
-      u8 *aOut = 0;               /* Read blob data into this buffer */
-      i64 nByte = sqlite3_blob_bytes(p->pReader);
-      i64 szData = (sizeof(Fts5Data) + 7) & ~7;
-      i64 nAlloc = szData + nByte + FTS5_DATA_PADDING;
-      pRet = (Fts5Data*)sqlite3_malloc64(nAlloc);
-      if( pRet ){
-        pRet->nn = nByte;
-        aOut = pRet->p = (u8*)pRet + szData;
-      }else{
-        rc = SQLITE_NOMEM;
-      }
-
-      if( rc==SQLITE_OK ){
-        rc = sqlite3_blob_read(p->pReader, aOut, nByte, 0);
-      }
-      if( rc!=SQLITE_OK ){
-        sqlite3_free(pRet);
-        pRet = 0;
-      }else{
-        /* TODO1: Fix this */
-        pRet->p[nByte] = 0x00;
-        pRet->p[nByte+1] = 0x00;
-        pRet->szLeaf = fts5GetU16(&pRet->p[2]);
-      }
-    }
-    p->rc = rc;
-    p->nRead++;
-  }
-
-  assert( (pRet==0)==(p->rc!=SQLITE_OK) );
-  assert( pRet==0 || EIGHT_BYTE_ALIGNMENT( pRet->p ) );
-  return pRet;
-}
-
-
-/*
-** Release a reference to data record returned by an earlier call to
-** fts5DataRead().
-*/
-static void fts5DataRelease(Fts5Data *pData){
-  sqlite3_free(pData);
-}
-
-static Fts5Data *fts5LeafRead(Fts5Index *p, i64 iRowid){
-  Fts5Data *pRet = fts5DataRead(p, iRowid);
-  if( pRet ){
-    if( pRet->nn<4 || pRet->szLeaf>pRet->nn ){
-      FTS5_CORRUPT_ROWID(p, iRowid);
-      fts5DataRelease(pRet);
-      pRet = 0;
-    }
-  }
-  return pRet;
-}
-
-static int fts5IndexPrepareStmt(
-  Fts5Index *p,
-  sqlite3_stmt **ppStmt,
-  char *zSql
-){
-  if( p->rc==SQLITE_OK ){
-    if( zSql ){
-      int rc = sqlite3_prepare_v3(p->pConfig->db, zSql, -1,
-          SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB,
-          ppStmt, 0);
-      /* If this prepare() call fails with SQLITE_ERROR, then one of the
-      ** %_idx or %_data tables has been removed or modified. Call this
-      ** corruption.  */
-      p->rc = (rc==SQLITE_ERROR ? SQLITE_CORRUPT : rc);
-    }else{
-      p->rc = SQLITE_NOMEM;
-    }
-  }
-  sqlite3_free(zSql);
-  return p->rc;
-}
-
-
-/*
-** INSERT OR REPLACE a record into the %_data table.
-*/
-static void fts5DataWrite(Fts5Index *p, i64 iRowid, const u8 *pData, int nData){
-  if( p->rc!=SQLITE_OK ) return;
-
-  if( p->pWriter==0 ){
-    Fts5Config *pConfig = p->pConfig;
-    fts5IndexPrepareStmt(p, &p->pWriter, sqlite3_mprintf(
-          "REPLACE INTO '%q'.'%q_data'(id, block) VALUES(?,?)",
-          pConfig->zDb, pConfig->zName
-    ));
-    if( p->rc ) return;
-  }
-
-  sqlite3_bind_int64(p->pWriter, 1, iRowid);
-  sqlite3_bind_blob(p->pWriter, 2, pData, nData, SQLITE_STATIC);
-  sqlite3_step(p->pWriter);
-  p->rc = sqlite3_reset(p->pWriter);
-  sqlite3_bind_null(p->pWriter, 2);
-}
-
-/*
-** Execute the following SQL:
-**
-**     DELETE FROM %_data WHERE id BETWEEN $iFirst AND $iLast
-*/
-static void fts5DataDelete(Fts5Index *p, i64 iFirst, i64 iLast){
-  if( p->rc!=SQLITE_OK ) return;
-
-  if( p->pDeleter==0 ){
-    Fts5Config *pConfig = p->pConfig;
-    char *zSql = sqlite3_mprintf(
-        "DELETE FROM '%q'.'%q_data' WHERE id>=? AND id<=?",
-          pConfig->zDb, pConfig->zName
-    );
-    if( fts5IndexPrepareStmt(p, &p->pDeleter, zSql) ) return;
-  }
-
-  sqlite3_bind_int64(p->pDeleter, 1, iFirst);
-  sqlite3_bind_int64(p->pDeleter, 2, iLast);
-  sqlite3_step(p->pDeleter);
-  p->rc = sqlite3_reset(p->pDeleter);
-}
-
-/*
-** Remove all records associated with segment iSegid.
-*/
-static void fts5DataRemoveSegment(Fts5Index *p, Fts5StructureSegment *pSeg){
-  int iSegid = pSeg->iSegid;
-  i64 iFirst = FTS5_SEGMENT_ROWID(iSegid, 0);
-  i64 iLast = FTS5_SEGMENT_ROWID(iSegid+1, 0)-1;
-  fts5DataDelete(p, iFirst, iLast);
-
-  if( pSeg->nPgTombstone ){
-    i64 iTomb1 = FTS5_TOMBSTONE_ROWID(iSegid, 0);
-    i64 iTomb2 = FTS5_TOMBSTONE_ROWID(iSegid, pSeg->nPgTombstone-1);
-    fts5DataDelete(p, iTomb1, iTomb2);
-  }
-  if( p->pIdxDeleter==0 ){
-    Fts5Config *pConfig = p->pConfig;
-    fts5IndexPrepareStmt(p, &p->pIdxDeleter, sqlite3_mprintf(
-          "DELETE FROM '%q'.'%q_idx' WHERE segid=?",
-          pConfig->zDb, pConfig->zName
-    ));
-  }
-  if( p->rc==SQLITE_OK ){
-    sqlite3_bind_int(p->pIdxDeleter, 1, iSegid);
-    sqlite3_step(p->pIdxDeleter);
-    p->rc = sqlite3_reset(p->pIdxDeleter);
-  }
-}
-
-/*
-** Release a reference to an Fts5Structure object returned by an earlier
-** call to fts5StructureRead() or fts5StructureDecode().
-*/
-static void fts5StructureRelease(Fts5Structure *pStruct){
-  if( pStruct && 0>=(--pStruct->nRef) ){
-    int i;
-    assert( pStruct->nRef==0 );
-    for(i=0; i<pStruct->nLevel; i++){
-      sqlite3_free(pStruct->aLevel[i].aSeg);
-    }
-    sqlite3_free(pStruct);
-  }
-}
-
-static void fts5StructureRef(Fts5Structure *pStruct){
-  pStruct->nRef++;
-}
-
-static void *sqlite3Fts5StructureRef(Fts5Index *p){
-  fts5StructureRef(p->pStruct);
-  return (void*)p->pStruct;
-}
-static void sqlite3Fts5StructureRelease(void *p){
-  if( p ){
-    fts5StructureRelease((Fts5Structure*)p);
-  }
-}
-static int sqlite3Fts5StructureTest(Fts5Index *p, void *pStruct){
-  if( p->pStruct!=(Fts5Structure*)pStruct ){
-    return SQLITE_ABORT;
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Ensure that structure object (*pp) is writable.
-**
-** This function is a no-op if (*pRc) is not SQLITE_OK when it is called. If
-** an error occurs, (*pRc) is set to an SQLite error code before returning.
-*/
-static void fts5StructureMakeWritable(int *pRc, Fts5Structure **pp){
-  Fts5Structure *p = *pp;
-  if( *pRc==SQLITE_OK && p->nRef>1 ){
-    i64 nByte = SZ_FTS5STRUCTURE(p->nLevel);
-    Fts5Structure *pNew;
-    pNew = (Fts5Structure*)sqlite3Fts5MallocZero(pRc, nByte);
-    if( pNew ){
-      int i;
-      memcpy(pNew, p, nByte);
-      for(i=0; i<p->nLevel; i++) pNew->aLevel[i].aSeg = 0;
-      for(i=0; i<p->nLevel; i++){
-        Fts5StructureLevel *pLvl = &pNew->aLevel[i];
-        nByte = sizeof(Fts5StructureSegment) * pNew->aLevel[i].nSeg;
-        pLvl->aSeg = (Fts5StructureSegment*)sqlite3Fts5MallocZero(pRc, nByte);
-        if( pLvl->aSeg==0 ){
-          for(i=0; i<p->nLevel; i++){
-            sqlite3_free(pNew->aLevel[i].aSeg);
-          }
-          sqlite3_free(pNew);
-          return;
-        }
-        memcpy(pLvl->aSeg, p->aLevel[i].aSeg, nByte);
-      }
-      p->nRef--;
-      pNew->nRef = 1;
-    }
-    *pp = pNew;
-  }
-}
-
-/*
-** Deserialize and return the structure record currently stored in serialized
-** form within buffer pData/nData.
-**
-** The Fts5Structure.aLevel[] and each Fts5StructureLevel.aSeg[] array
-** are over-allocated by one slot. This allows the structure contents
-** to be more easily edited.
-**
-** If an error occurs, *ppOut is set to NULL and an SQLite error code
-** returned. Otherwise, *ppOut is set to point to the new object and
-** SQLITE_OK returned.
-*/
-static int fts5StructureDecode(
-  const u8 *pData,                /* Buffer containing serialized structure */
-  int nData,                      /* Size of buffer pData in bytes */
-  int *piCookie,                  /* Configuration cookie value */
-  Fts5Structure **ppOut           /* OUT: Deserialized object */
-){
-  int rc = SQLITE_OK;
-  int i = 0;
-  int iLvl;
-  int nLevel = 0;
-  int nSegment = 0;
-  sqlite3_int64 nByte;            /* Bytes of space to allocate at pRet */
-  Fts5Structure *pRet = 0;        /* Structure object to return */
-  int bStructureV2 = 0;           /* True for FTS5_STRUCTURE_V2 */
-  u64 nOriginCntr = 0;            /* Largest origin value seen so far */
-
-  /* Grab the cookie value */
-  if( piCookie ) *piCookie = sqlite3Fts5Get32(pData);
-  i = 4;
-
-  /* Check if this is a V2 structure record. Set bStructureV2 if it is. */
-  if( 0==memcmp(&pData[i], FTS5_STRUCTURE_V2, 4) ){
-    i += 4;
-    bStructureV2 = 1;
-  }
-
-  /* Read the total number of levels and segments from the start of the
-  ** structure record.  */
-  i += fts5GetVarint32(&pData[i], nLevel);
-  i += fts5GetVarint32(&pData[i], nSegment);
-  if( nLevel>FTS5_MAX_SEGMENT   || nLevel<0
-   || nSegment>FTS5_MAX_SEGMENT || nSegment<0
-  ){
-    return FTS5_CORRUPT;
-  }
-  nByte = SZ_FTS5STRUCTURE(nLevel);
-  pRet = (Fts5Structure*)sqlite3Fts5MallocZero(&rc, nByte);
-
-  if( pRet ){
-    pRet->nRef = 1;
-    pRet->nLevel = nLevel;
-    pRet->nSegment = nSegment;
-    i += sqlite3Fts5GetVarint(&pData[i], &pRet->nWriteCounter);
-
-    for(iLvl=0; rc==SQLITE_OK && iLvl<nLevel; iLvl++){
-      Fts5StructureLevel *pLvl = &pRet->aLevel[iLvl];
-      int nTotal = 0;
-      int iSeg;
-
-      if( i>=nData ){
-        rc = FTS5_CORRUPT;
-      }else{
-        i += fts5GetVarint32(&pData[i], pLvl->nMerge);
-        i += fts5GetVarint32(&pData[i], nTotal);
-        if( nTotal<pLvl->nMerge ) rc = FTS5_CORRUPT;
-        pLvl->aSeg = (Fts5StructureSegment*)sqlite3Fts5MallocZero(&rc,
-            nTotal * sizeof(Fts5StructureSegment)
-        );
-        nSegment -= nTotal;
-      }
-
-      if( rc==SQLITE_OK ){
-        pLvl->nSeg = nTotal;
-        for(iSeg=0; iSeg<nTotal; iSeg++){
-          Fts5StructureSegment *pSeg = &pLvl->aSeg[iSeg];
-          if( i>=nData ){
-            rc = FTS5_CORRUPT;
-            break;
-          }
-          assert( pSeg!=0 );
-          i += fts5GetVarint32(&pData[i], pSeg->iSegid);
-          i += fts5GetVarint32(&pData[i], pSeg->pgnoFirst);
-          i += fts5GetVarint32(&pData[i], pSeg->pgnoLast);
-          if( bStructureV2 ){
-            i += fts5GetVarint(&pData[i], &pSeg->iOrigin1);
-            i += fts5GetVarint(&pData[i], &pSeg->iOrigin2);
-            i += fts5GetVarint32(&pData[i], pSeg->nPgTombstone);
-            i += fts5GetVarint(&pData[i], &pSeg->nEntryTombstone);
-            i += fts5GetVarint(&pData[i], &pSeg->nEntry);
-            nOriginCntr = MAX(nOriginCntr, pSeg->iOrigin2);
-          }
-          if( pSeg->pgnoLast<pSeg->pgnoFirst ){
-            rc = FTS5_CORRUPT;
-            break;
-          }
-        }
-        if( iLvl>0 && pLvl[-1].nMerge && nTotal==0 ) rc = FTS5_CORRUPT;
-        if( iLvl==nLevel-1 && pLvl->nMerge ) rc = FTS5_CORRUPT;
-      }
-    }
-    if( nSegment!=0 && rc==SQLITE_OK ) rc = FTS5_CORRUPT;
-    if( bStructureV2 ){
-      pRet->nOriginCntr = nOriginCntr+1;
-    }
-
-    if( rc!=SQLITE_OK ){
-      fts5StructureRelease(pRet);
-      pRet = 0;
-    }
-  }
-
-  *ppOut = pRet;
-  return rc;
-}
-
-/*
-** Add a level to the Fts5Structure.aLevel[] array of structure object
-** (*ppStruct).
-*/
-static void fts5StructureAddLevel(int *pRc, Fts5Structure **ppStruct){
-  fts5StructureMakeWritable(pRc, ppStruct);
-  assert( (ppStruct!=0 && (*ppStruct)!=0) || (*pRc)!=SQLITE_OK );
-  if( *pRc==SQLITE_OK ){
-    Fts5Structure *pStruct = *ppStruct;
-    int nLevel = pStruct->nLevel;
-    sqlite3_int64 nByte = SZ_FTS5STRUCTURE(nLevel+2);
-
-    pStruct = sqlite3_realloc64(pStruct, nByte);
-    if( pStruct ){
-      memset(&pStruct->aLevel[nLevel], 0, sizeof(Fts5StructureLevel));
-      pStruct->nLevel++;
-      *ppStruct = pStruct;
-    }else{
-      *pRc = SQLITE_NOMEM;
-    }
-  }
-}
-
-/*
-** Extend level iLvl so that there is room for at least nExtra more
-** segments.
-*/
-static void fts5StructureExtendLevel(
-  int *pRc,
-  Fts5Structure *pStruct,
-  int iLvl,
-  int nExtra,
-  int bInsert
-){
-  if( *pRc==SQLITE_OK ){
-    Fts5StructureLevel *pLvl = &pStruct->aLevel[iLvl];
-    Fts5StructureSegment *aNew;
-    sqlite3_int64 nByte;
-
-    nByte = (pLvl->nSeg + nExtra) * sizeof(Fts5StructureSegment);
-    aNew = sqlite3_realloc64(pLvl->aSeg, nByte);
-    if( aNew ){
-      if( bInsert==0 ){
-        memset(&aNew[pLvl->nSeg], 0, sizeof(Fts5StructureSegment) * nExtra);
-      }else{
-        int nMove = pLvl->nSeg * sizeof(Fts5StructureSegment);
-        memmove(&aNew[nExtra], aNew, nMove);
-        memset(aNew, 0, sizeof(Fts5StructureSegment) * nExtra);
-      }
-      pLvl->aSeg = aNew;
-    }else{
-      *pRc = SQLITE_NOMEM;
-    }
-  }
-}
-
-static Fts5Structure *fts5StructureReadUncached(Fts5Index *p){
-  Fts5Structure *pRet = 0;
-  Fts5Config *pConfig = p->pConfig;
-  int iCookie;                    /* Configuration cookie */
-  Fts5Data *pData;
-
-  pData = fts5DataRead(p, FTS5_STRUCTURE_ROWID);
-  if( p->rc==SQLITE_OK ){
-    /* TODO: Do we need this if the leaf-index is appended? Probably... */
-    memset(&pData->p[pData->nn], 0, FTS5_DATA_PADDING);
-    p->rc = fts5StructureDecode(pData->p, pData->nn, &iCookie, &pRet);
-    if( p->rc==SQLITE_OK ){
-      if( (pConfig->pgsz==0 || pConfig->iCookie!=iCookie) ){
-        p->rc = sqlite3Fts5ConfigLoad(pConfig, iCookie);
-      }
-    }else if( p->rc==SQLITE_CORRUPT_VTAB ){
-      sqlite3Fts5ConfigErrmsg(p->pConfig,
-          "fts5: corrupt structure record for table \"%s\"", p->pConfig->zName
-      );
-    }
-    fts5DataRelease(pData);
-    if( p->rc!=SQLITE_OK ){
-      fts5StructureRelease(pRet);
-      pRet = 0;
-    }
-  }
-
-  return pRet;
-}
-
-static i64 fts5IndexDataVersion(Fts5Index *p){
-  i64 iVersion = 0;
-
-  if( p->rc==SQLITE_OK ){
-    if( p->pDataVersion==0 ){
-      p->rc = fts5IndexPrepareStmt(p, &p->pDataVersion,
-          sqlite3_mprintf("PRAGMA %Q.data_version", p->pConfig->zDb)
-          );
-      if( p->rc ) return 0;
-    }
-
-    if( SQLITE_ROW==sqlite3_step(p->pDataVersion) ){
-      iVersion = sqlite3_column_int64(p->pDataVersion, 0);
-    }
-    p->rc = sqlite3_reset(p->pDataVersion);
-  }
-
-  return iVersion;
-}
-
-/*
-** Read, deserialize and return the structure record.
-**
-** The Fts5Structure.aLevel[] and each Fts5StructureLevel.aSeg[] array
-** are over-allocated as described for function fts5StructureDecode()
-** above.
-**
-** If an error occurs, NULL is returned and an error code left in the
-** Fts5Index handle. If an error has already occurred when this function
-** is called, it is a no-op.
-*/
-static Fts5Structure *fts5StructureRead(Fts5Index *p){
-
-  if( p->pStruct==0 ){
-    p->iStructVersion = fts5IndexDataVersion(p);
-    if( p->rc==SQLITE_OK ){
-      p->pStruct = fts5StructureReadUncached(p);
-    }
-  }
-
-#if 0
-  else{
-    Fts5Structure *pTest = fts5StructureReadUncached(p);
-    if( pTest ){
-      int i, j;
-      assert_nc( p->pStruct->nSegment==pTest->nSegment );
-      assert_nc( p->pStruct->nLevel==pTest->nLevel );
-      for(i=0; i<pTest->nLevel; i++){
-        assert_nc( p->pStruct->aLevel[i].nMerge==pTest->aLevel[i].nMerge );
-        assert_nc( p->pStruct->aLevel[i].nSeg==pTest->aLevel[i].nSeg );
-        for(j=0; j<pTest->aLevel[i].nSeg; j++){
-          Fts5StructureSegment *p1 = &pTest->aLevel[i].aSeg[j];
-          Fts5StructureSegment *p2 = &p->pStruct->aLevel[i].aSeg[j];
-          assert_nc( p1->iSegid==p2->iSegid );
-          assert_nc( p1->pgnoFirst==p2->pgnoFirst );
-          assert_nc( p1->pgnoLast==p2->pgnoLast );
-        }
-      }
-      fts5StructureRelease(pTest);
-    }
-  }
-#endif
-
-  if( p->rc!=SQLITE_OK ) return 0;
-  assert( p->iStructVersion!=0 );
-  assert( p->pStruct!=0 );
-  fts5StructureRef(p->pStruct);
-  return p->pStruct;
-}
-
-static void fts5StructureInvalidate(Fts5Index *p){
-  if( p->pStruct ){
-    fts5StructureRelease(p->pStruct);
-    p->pStruct = 0;
-  }
-}
-
-/*
-** Return the total number of segments in index structure pStruct. This
-** function is only ever used as part of assert() conditions.
-*/
-#ifdef SQLITE_DEBUG
-static int fts5StructureCountSegments(Fts5Structure *pStruct){
-  int nSegment = 0;               /* Total number of segments */
-  if( pStruct ){
-    int iLvl;                     /* Used to iterate through levels */
-    for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
-      nSegment += pStruct->aLevel[iLvl].nSeg;
-    }
-  }
-
-  return nSegment;
-}
-#endif
-
-#define fts5BufferSafeAppendBlob(pBuf, pBlob, nBlob) {     \
-  assert( (pBuf)->nSpace>=((pBuf)->n+nBlob) );             \
-  memcpy(&(pBuf)->p[(pBuf)->n], pBlob, nBlob);             \
-  (pBuf)->n += nBlob;                                      \
-}
-
-#define fts5BufferSafeAppendVarint(pBuf, iVal) {                \
-  (pBuf)->n += sqlite3Fts5PutVarint(&(pBuf)->p[(pBuf)->n], (iVal));  \
-  assert( (pBuf)->nSpace>=(pBuf)->n );                          \
-}
-
-
-/*
-** Serialize and store the "structure" record.
-**
-** If an error occurs, leave an error code in the Fts5Index object. If an
-** error has already occurred, this function is a no-op.
-*/
-static void fts5StructureWrite(Fts5Index *p, Fts5Structure *pStruct){
-  if( p->rc==SQLITE_OK ){
-    Fts5Buffer buf;               /* Buffer to serialize record into */
-    int iLvl;                     /* Used to iterate through levels */
-    int iCookie;                  /* Cookie value to store */
-    int nHdr = (pStruct->nOriginCntr>0 ? (4+4+9+9+9) : (4+9+9));
-
-    assert( pStruct->nSegment==fts5StructureCountSegments(pStruct) );
-    memset(&buf, 0, sizeof(Fts5Buffer));
-
-    /* Append the current configuration cookie */
-    iCookie = p->pConfig->iCookie;
-    if( iCookie<0 ) iCookie = 0;
-
-    if( 0==sqlite3Fts5BufferSize(&p->rc, &buf, nHdr) ){
-      sqlite3Fts5Put32(buf.p, iCookie);
-      buf.n = 4;
-      if( pStruct->nOriginCntr>0 ){
-        fts5BufferSafeAppendBlob(&buf, FTS5_STRUCTURE_V2, 4);
-      }
-      fts5BufferSafeAppendVarint(&buf, pStruct->nLevel);
-      fts5BufferSafeAppendVarint(&buf, pStruct->nSegment);
-      fts5BufferSafeAppendVarint(&buf, (i64)pStruct->nWriteCounter);
-    }
-
-    for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
-      int iSeg;                     /* Used to iterate through segments */
-      Fts5StructureLevel *pLvl = &pStruct->aLevel[iLvl];
-      fts5BufferAppendVarint(&p->rc, &buf, pLvl->nMerge);
-      fts5BufferAppendVarint(&p->rc, &buf, pLvl->nSeg);
-      assert( pLvl->nMerge<=pLvl->nSeg );
-
-      for(iSeg=0; iSeg<pLvl->nSeg; iSeg++){
-        Fts5StructureSegment *pSeg = &pLvl->aSeg[iSeg];
-        fts5BufferAppendVarint(&p->rc, &buf, pSeg->iSegid);
-        fts5BufferAppendVarint(&p->rc, &buf, pSeg->pgnoFirst);
-        fts5BufferAppendVarint(&p->rc, &buf, pSeg->pgnoLast);
-        if( pStruct->nOriginCntr>0 ){
-          fts5BufferAppendVarint(&p->rc, &buf, pSeg->iOrigin1);
-          fts5BufferAppendVarint(&p->rc, &buf, pSeg->iOrigin2);
-          fts5BufferAppendVarint(&p->rc, &buf, pSeg->nPgTombstone);
-          fts5BufferAppendVarint(&p->rc, &buf, pSeg->nEntryTombstone);
-          fts5BufferAppendVarint(&p->rc, &buf, pSeg->nEntry);
-        }
-      }
-    }
-
-    fts5DataWrite(p, FTS5_STRUCTURE_ROWID, buf.p, buf.n);
-    fts5BufferFree(&buf);
-  }
-}
-
-#if 0
-static void fts5DebugStructure(int*,Fts5Buffer*,Fts5Structure*);
-static void fts5PrintStructure(const char *zCaption, Fts5Structure *pStruct){
-  int rc = SQLITE_OK;
-  Fts5Buffer buf;
-  memset(&buf, 0, sizeof(buf));
-  fts5DebugStructure(&rc, &buf, pStruct);
-  fprintf(stdout, "%s: %s\n", zCaption, buf.p);
-  fflush(stdout);
-  fts5BufferFree(&buf);
-}
-#else
-# define fts5PrintStructure(x,y)
-#endif
-
-static int fts5SegmentSize(Fts5StructureSegment *pSeg){
-  return 1 + pSeg->pgnoLast - pSeg->pgnoFirst;
-}
-
-/*
-** Return a copy of index structure pStruct. Except, promote as many
-** segments as possible to level iPromote. If an OOM occurs, NULL is
-** returned.
-*/
-static void fts5StructurePromoteTo(
-  Fts5Index *p,
-  int iPromote,
-  int szPromote,
-  Fts5Structure *pStruct
-){
-  int il, is;
-  Fts5StructureLevel *pOut = &pStruct->aLevel[iPromote];
-
-  if( pOut->nMerge==0 ){
-    for(il=iPromote+1; il<pStruct->nLevel; il++){
-      Fts5StructureLevel *pLvl = &pStruct->aLevel[il];
-      if( pLvl->nMerge ) return;
-      for(is=pLvl->nSeg-1; is>=0; is--){
-        int sz = fts5SegmentSize(&pLvl->aSeg[is]);
-        if( sz>szPromote ) return;
-        fts5StructureExtendLevel(&p->rc, pStruct, iPromote, 1, 1);
-        if( p->rc ) return;
-        memcpy(pOut->aSeg, &pLvl->aSeg[is], sizeof(Fts5StructureSegment));
-        pOut->nSeg++;
-        pLvl->nSeg--;
-      }
-    }
-  }
-}
-
-/*
-** A new segment has just been written to level iLvl of index structure
-** pStruct. This function determines if any segments should be promoted
-** as a result. Segments are promoted in two scenarios:
-**
-**   a) If the segment just written is smaller than one or more segments
-**      within the previous populated level, it is promoted to the previous
-**      populated level.
-**
-**   b) If the segment just written is larger than the newest segment on
-**      the next populated level, then that segment, and any other adjacent
-**      segments that are also smaller than the one just written, are
-**      promoted.
-**
-** If one or more segments are promoted, the structure object is updated
-** to reflect this.
-*/
-static void fts5StructurePromote(
-  Fts5Index *p,                   /* FTS5 backend object */
-  int iLvl,                       /* Index level just updated */
-  Fts5Structure *pStruct          /* Index structure */
-){
-  if( p->rc==SQLITE_OK ){
-    int iTst;
-    int iPromote = -1;
-    int szPromote = 0;            /* Promote anything this size or smaller */
-    Fts5StructureSegment *pSeg;   /* Segment just written */
-    int szSeg;                    /* Size of segment just written */
-    int nSeg = pStruct->aLevel[iLvl].nSeg;
-
-    if( nSeg==0 ) return;
-    pSeg = &pStruct->aLevel[iLvl].aSeg[pStruct->aLevel[iLvl].nSeg-1];
-    szSeg = (1 + pSeg->pgnoLast - pSeg->pgnoFirst);
-
-    /* Check for condition (a) */
-    for(iTst=iLvl-1; iTst>=0 && pStruct->aLevel[iTst].nSeg==0; iTst--);
-    if( iTst>=0 ){
-      int i;
-      int szMax = 0;
-      Fts5StructureLevel *pTst = &pStruct->aLevel[iTst];
-      assert( pTst->nMerge==0 );
-      for(i=0; i<pTst->nSeg; i++){
-        int sz = pTst->aSeg[i].pgnoLast - pTst->aSeg[i].pgnoFirst + 1;
-        if( sz>szMax ) szMax = sz;
-      }
-      if( szMax>=szSeg ){
-        /* Condition (a) is true. Promote the newest segment on level
-        ** iLvl to level iTst.  */
-        iPromote = iTst;
-        szPromote = szMax;
-      }
-    }
-
-    /* If condition (a) is not met, assume (b) is true. StructurePromoteTo()
-    ** is a no-op if it is not.  */
-    if( iPromote<0 ){
-      iPromote = iLvl;
-      szPromote = szSeg;
-    }
-    fts5StructurePromoteTo(p, iPromote, szPromote, pStruct);
-  }
-}
-
-
-/*
-** Advance the iterator passed as the only argument. If the end of the
-** doclist-index page is reached, return non-zero.
-*/
-static int fts5DlidxLvlNext(Fts5DlidxLvl *pLvl){
-  Fts5Data *pData = pLvl->pData;
-
-  if( pLvl->iOff==0 ){
-    assert( pLvl->bEof==0 );
-    pLvl->iOff = 1;
-    pLvl->iOff += fts5GetVarint32(&pData->p[1], pLvl->iLeafPgno);
-    pLvl->iOff += fts5GetVarint(&pData->p[pLvl->iOff], (u64*)&pLvl->iRowid);
-    pLvl->iFirstOff = pLvl->iOff;
-  }else{
-    int iOff;
-    for(iOff=pLvl->iOff; iOff<pData->nn; iOff++){
-      if( pData->p[iOff] ) break;
-    }
-
-    if( iOff<pData->nn ){
-      u64 iVal;
-      pLvl->iLeafPgno += (iOff - pLvl->iOff) + 1;
-      iOff += fts5GetVarint(&pData->p[iOff], &iVal);
-      pLvl->iRowid += iVal;
-      pLvl->iOff = iOff;
-    }else{
-      pLvl->bEof = 1;
-    }
-  }
-
-  return pLvl->bEof;
-}
-
-/*
-** Advance the iterator passed as the only argument.
-*/
-static int fts5DlidxIterNextR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
-  Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
-
-  assert( iLvl<pIter->nLvl );
-  if( fts5DlidxLvlNext(pLvl) ){
-    if( (iLvl+1) < pIter->nLvl ){
-      fts5DlidxIterNextR(p, pIter, iLvl+1);
-      if( pLvl[1].bEof==0 ){
-        fts5DataRelease(pLvl->pData);
-        memset(pLvl, 0, sizeof(Fts5DlidxLvl));
-        pLvl->pData = fts5DataRead(p,
-            FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
-        );
-        if( pLvl->pData ) fts5DlidxLvlNext(pLvl);
-      }
-    }
-  }
-
-  return pIter->aLvl[0].bEof;
-}
-static int fts5DlidxIterNext(Fts5Index *p, Fts5DlidxIter *pIter){
-  return fts5DlidxIterNextR(p, pIter, 0);
-}
-
-/*
-** The iterator passed as the first argument has the following fields set
-** as follows. This function sets up the rest of the iterator so that it
-** points to the first rowid in the doclist-index.
-**
-**   pData:
-**     pointer to doclist-index record,
-**
-** When this function is called pIter->iLeafPgno is the page number the
-** doclist is associated with (the one featuring the term).
-*/
-static int fts5DlidxIterFirst(Fts5DlidxIter *pIter){
-  int i;
-  for(i=0; i<pIter->nLvl; i++){
-    fts5DlidxLvlNext(&pIter->aLvl[i]);
-  }
-  return pIter->aLvl[0].bEof;
-}
-
-
-static int fts5DlidxIterEof(Fts5Index *p, Fts5DlidxIter *pIter){
-  return p->rc!=SQLITE_OK || pIter->aLvl[0].bEof;
-}
-
-static void fts5DlidxIterLast(Fts5Index *p, Fts5DlidxIter *pIter){
-  int i;
-
-  /* Advance each level to the last entry on the last page */
-  for(i=pIter->nLvl-1; p->rc==SQLITE_OK && i>=0; i--){
-    Fts5DlidxLvl *pLvl = &pIter->aLvl[i];
-    while( fts5DlidxLvlNext(pLvl)==0 );
-    pLvl->bEof = 0;
-
-    if( i>0 ){
-      Fts5DlidxLvl *pChild = &pLvl[-1];
-      fts5DataRelease(pChild->pData);
-      memset(pChild, 0, sizeof(Fts5DlidxLvl));
-      pChild->pData = fts5DataRead(p,
-          FTS5_DLIDX_ROWID(pIter->iSegid, i-1, pLvl->iLeafPgno)
-      );
-    }
-  }
-}
-
-/*
-** Move the iterator passed as the only argument to the previous entry.
-*/
-static int fts5DlidxLvlPrev(Fts5DlidxLvl *pLvl){
-  int iOff = pLvl->iOff;
-
-  assert( pLvl->bEof==0 );
-  if( iOff<=pLvl->iFirstOff ){
-    pLvl->bEof = 1;
-  }else{
-    u8 *a = pLvl->pData->p;
-
-    pLvl->iOff = 0;
-    fts5DlidxLvlNext(pLvl);
-    while( 1 ){
-      int nZero = 0;
-      int ii = pLvl->iOff;
-      u64 delta = 0;
-
-      while( a[ii]==0 ){
-        nZero++;
-        ii++;
-      }
-      ii += sqlite3Fts5GetVarint(&a[ii], &delta);
-
-      if( ii>=iOff ) break;
-      pLvl->iLeafPgno += nZero+1;
-      pLvl->iRowid += delta;
-      pLvl->iOff = ii;
-    }
-  }
-
-  return pLvl->bEof;
-}
-
-static int fts5DlidxIterPrevR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
-  Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
-
-  assert( iLvl<pIter->nLvl );
-  if( fts5DlidxLvlPrev(pLvl) ){
-    if( (iLvl+1) < pIter->nLvl ){
-      fts5DlidxIterPrevR(p, pIter, iLvl+1);
-      if( pLvl[1].bEof==0 ){
-        fts5DataRelease(pLvl->pData);
-        memset(pLvl, 0, sizeof(Fts5DlidxLvl));
-        pLvl->pData = fts5DataRead(p,
-            FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
-        );
-        if( pLvl->pData ){
-          while( fts5DlidxLvlNext(pLvl)==0 );
-          pLvl->bEof = 0;
-        }
-      }
-    }
-  }
-
-  return pIter->aLvl[0].bEof;
-}
-static int fts5DlidxIterPrev(Fts5Index *p, Fts5DlidxIter *pIter){
-  return fts5DlidxIterPrevR(p, pIter, 0);
-}
-
-/*
-** Free a doclist-index iterator object allocated by fts5DlidxIterInit().
-*/
-static void fts5DlidxIterFree(Fts5DlidxIter *pIter){
-  if( pIter ){
-    int i;
-    for(i=0; i<pIter->nLvl; i++){
-      fts5DataRelease(pIter->aLvl[i].pData);
-    }
-    sqlite3_free(pIter);
-  }
-}
-
-static Fts5DlidxIter *fts5DlidxIterInit(
-  Fts5Index *p,                   /* Fts5 Backend to iterate within */
-  int bRev,                       /* True for ORDER BY ASC */
-  int iSegid,                     /* Segment id */
-  int iLeafPg                     /* Leaf page number to load dlidx for */
-){
-  Fts5DlidxIter *pIter = 0;
-  int i;
-  int bDone = 0;
-
-  for(i=0; p->rc==SQLITE_OK && bDone==0; i++){
-    sqlite3_int64 nByte = SZ_FTS5DLIDXITER(i+1);
-    Fts5DlidxIter *pNew;
-
-    pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
-    if( pNew==0 ){
-      p->rc = SQLITE_NOMEM;
-    }else{
-      i64 iRowid = FTS5_DLIDX_ROWID(iSegid, i, iLeafPg);
-      Fts5DlidxLvl *pLvl = &pNew->aLvl[i];
-      pIter = pNew;
-      memset(pLvl, 0, sizeof(Fts5DlidxLvl));
-      pLvl->pData = fts5DataRead(p, iRowid);
-      if( pLvl->pData && (pLvl->pData->p[0] & 0x0001)==0 ){
-        bDone = 1;
-      }
-      pIter->nLvl = i+1;
-    }
-  }
-
-  if( p->rc==SQLITE_OK ){
-    pIter->iSegid = iSegid;
-    if( bRev==0 ){
-      fts5DlidxIterFirst(pIter);
-    }else{
-      fts5DlidxIterLast(p, pIter);
-    }
-  }
-
-  if( p->rc!=SQLITE_OK ){
-    fts5DlidxIterFree(pIter);
-    pIter = 0;
-  }
-
-  return pIter;
-}
-
-static i64 fts5DlidxIterRowid(Fts5DlidxIter *pIter){
-  return pIter->aLvl[0].iRowid;
-}
-static int fts5DlidxIterPgno(Fts5DlidxIter *pIter){
-  return pIter->aLvl[0].iLeafPgno;
-}
-
-/*
-** Load the next leaf page into the segment iterator.
-*/
-static void fts5SegIterNextPage(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5SegIter *pIter              /* Iterator to advance to next page */
-){
-  Fts5Data *pLeaf;
-  Fts5StructureSegment *pSeg = pIter->pSeg;
-  fts5DataRelease(pIter->pLeaf);
-  pIter->iLeafPgno++;
-  if( pIter->pNextLeaf ){
-    pIter->pLeaf = pIter->pNextLeaf;
-    pIter->pNextLeaf = 0;
-  }else if( pIter->iLeafPgno<=pSeg->pgnoLast ){
-    pIter->pLeaf = fts5LeafRead(p,
-        FTS5_SEGMENT_ROWID(pSeg->iSegid, pIter->iLeafPgno)
-    );
-  }else{
-    pIter->pLeaf = 0;
-  }
-  pLeaf = pIter->pLeaf;
-
-  if( pLeaf ){
-    pIter->iPgidxOff = pLeaf->szLeaf;
-    if( fts5LeafIsTermless(pLeaf) ){
-      pIter->iEndofDoclist = pLeaf->nn+1;
-    }else{
-      pIter->iPgidxOff += fts5GetVarint32(&pLeaf->p[pIter->iPgidxOff],
-          pIter->iEndofDoclist
-      );
-    }
-  }
-}
-
-/*
-** Argument p points to a buffer containing a varint to be interpreted as a
-** position list size field. Read the varint and return the number of bytes
-** read. Before returning, set *pnSz to the number of bytes in the position
-** list, and *pbDel to true if the delete flag is set, or false otherwise.
-*/
-static int fts5GetPoslistSize(const u8 *p, int *pnSz, int *pbDel){
-  int nSz;
-  int n = 0;
-  fts5FastGetVarint32(p, n, nSz);
-  assert_nc( nSz>=0 );
-  *pnSz = nSz/2;
-  *pbDel = nSz & 0x0001;
-  return n;
-}
-
-/*
-** Fts5SegIter.iLeafOffset currently points to the first byte of a
-** position-list size field. Read the value of the field and store it
-** in the following variables:
-**
-**   Fts5SegIter.nPos
-**   Fts5SegIter.bDel
-**
-** Leave Fts5SegIter.iLeafOffset pointing to the first byte of the
-** position list content (if any).
-*/
-static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){
-  if( p->rc==SQLITE_OK ){
-    int iOff = pIter->iLeafOffset;  /* Offset to read at */
-    ASSERT_SZLEAF_OK(pIter->pLeaf);
-    if( p->pConfig->eDetail==FTS5_DETAIL_NONE ){
-      int iEod = MIN(pIter->iEndofDoclist, pIter->pLeaf->szLeaf);
-      pIter->bDel = 0;
-      pIter->nPos = 1;
-      if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
-        pIter->bDel = 1;
-        iOff++;
-        if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
-          pIter->nPos = 1;
-          iOff++;
-        }else{
-          pIter->nPos = 0;
-        }
-      }
-    }else{
-      int nSz;
-      fts5FastGetVarint32(pIter->pLeaf->p, iOff, nSz);
-      pIter->bDel = (nSz & 0x0001);
-      pIter->nPos = nSz>>1;
-      assert_nc( pIter->nPos>=0 );
-    }
-    pIter->iLeafOffset = iOff;
-  }
-}
-
-static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
-  u8 *a = pIter->pLeaf->p;        /* Buffer to read data from */
-  i64 iOff = pIter->iLeafOffset;
-
-  ASSERT_SZLEAF_OK(pIter->pLeaf);
-  while( iOff>=pIter->pLeaf->szLeaf ){
-    fts5SegIterNextPage(p, pIter);
-    if( pIter->pLeaf==0 ){
-      if( p->rc==SQLITE_OK ) FTS5_CORRUPT_ITER(p, pIter);
-      return;
-    }
-    iOff = 4;
-    a = pIter->pLeaf->p;
-  }
-  iOff += sqlite3Fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
-  pIter->iLeafOffset = iOff;
-}
-
-/*
-** Fts5SegIter.iLeafOffset currently points to the first byte of the
-** "nSuffix" field of a term. Function parameter nKeep contains the value
-** of the "nPrefix" field (if there was one - it is passed 0 if this is
-** the first term in the segment).
-**
-** This function populates:
-**
-**   Fts5SegIter.term
-**   Fts5SegIter.rowid
-**
-** accordingly and leaves (Fts5SegIter.iLeafOffset) set to the content of
-** the first position list. The position list belonging to document
-** (Fts5SegIter.iRowid).
-*/
-static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
-  u8 *a = pIter->pLeaf->p;        /* Buffer to read data from */
-  i64 iOff = pIter->iLeafOffset;  /* Offset to read at */
-  int nNew;                       /* Bytes of new data */
-
-  iOff += fts5GetVarint32(&a[iOff], nNew);
-  if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
-    FTS5_CORRUPT_ITER(p, pIter);
-    return;
-  }
-  pIter->term.n = nKeep;
-  fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
-  assert( pIter->term.n<=pIter->term.nSpace );
-  iOff += nNew;
-  pIter->iTermLeafOffset = iOff;
-  pIter->iTermLeafPgno = pIter->iLeafPgno;
-  pIter->iLeafOffset = iOff;
-
-  if( pIter->iPgidxOff>=pIter->pLeaf->nn ){
-    pIter->iEndofDoclist = pIter->pLeaf->nn+1;
-  }else{
-    int nExtra;
-    pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], nExtra);
-    pIter->iEndofDoclist += nExtra;
-  }
-
-  fts5SegIterLoadRowid(p, pIter);
-}
-
-static void fts5SegIterNext(Fts5Index*, Fts5SegIter*, int*);
-static void fts5SegIterNext_Reverse(Fts5Index*, Fts5SegIter*, int*);
-static void fts5SegIterNext_None(Fts5Index*, Fts5SegIter*, int*);
-
-static void fts5SegIterSetNext(Fts5Index *p, Fts5SegIter *pIter){
-  if( pIter->flags & FTS5_SEGITER_REVERSE ){
-    pIter->xNext = fts5SegIterNext_Reverse;
-  }else if( p->pConfig->eDetail==FTS5_DETAIL_NONE ){
-    pIter->xNext = fts5SegIterNext_None;
-  }else{
-    pIter->xNext = fts5SegIterNext;
-  }
-}
-
-/*
-** Allocate a tombstone hash page array object (pIter->pTombArray) for
-** the iterator passed as the second argument. If an OOM error occurs,
-** leave an error in the Fts5Index object.
-*/
-static void fts5SegIterAllocTombstone(Fts5Index *p, Fts5SegIter *pIter){
-  const i64 nTomb = (i64)pIter->pSeg->nPgTombstone;
-  if( nTomb>0 ){
-    i64 nByte = SZ_FTS5TOMBSTONEARRAY(nTomb+1);
-    Fts5TombstoneArray *pNew;
-    pNew = (Fts5TombstoneArray*)sqlite3Fts5MallocZero(&p->rc, nByte);
-    if( pNew ){
-      pNew->nTombstone = nTomb;
-      pNew->nRef = 1;
-      pIter->pTombArray = pNew;
-    }
-  }
-}
-
-/*
-** Initialize the iterator object pIter to iterate through the entries in
-** segment pSeg. The iterator is left pointing to the first entry when
-** this function returns.
-**
-** If an error occurs, Fts5Index.rc is set to an appropriate error code. If
-** an error has already occurred when this function is called, it is a no-op.
-*/
-static void fts5SegIterInit(
-  Fts5Index *p,                   /* FTS index object */
-  Fts5StructureSegment *pSeg,     /* Description of segment */
-  Fts5SegIter *pIter              /* Object to populate */
-){
-  if( pSeg->pgnoFirst==0 ){
-    /* This happens if the segment is being used as an input to an incremental
-    ** merge and all data has already been "trimmed". See function
-    ** fts5TrimSegments() for details. In this case leave the iterator empty.
-    ** The caller will see the (pIter->pLeaf==0) and assume the iterator is
-    ** at EOF already. */
-    assert( pIter->pLeaf==0 );
-    return;
-  }
-
-  if( p->rc==SQLITE_OK ){
-    memset(pIter, 0, sizeof(*pIter));
-    fts5SegIterSetNext(p, pIter);
-    pIter->pSeg = pSeg;
-    pIter->iLeafPgno = pSeg->pgnoFirst-1;
-    do {
-      fts5SegIterNextPage(p, pIter);
-    }while( p->rc==SQLITE_OK && pIter->pLeaf && pIter->pLeaf->nn==4 );
-  }
-
-  if( p->rc==SQLITE_OK && pIter->pLeaf ){
-    pIter->iLeafOffset = 4;
-    assert( pIter->pLeaf!=0 );
-    assert_nc( pIter->pLeaf->nn>4 );
-    assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 );
-    pIter->iPgidxOff = pIter->pLeaf->szLeaf+1;
-    fts5SegIterLoadTerm(p, pIter, 0);
-    fts5SegIterLoadNPos(p, pIter);
-    fts5SegIterAllocTombstone(p, pIter);
-  }
-}
-
-/*
-** This function is only ever called on iterators created by calls to
-** Fts5IndexQuery() with the FTS5INDEX_QUERY_DESC flag set.
-**
-** The iterator is in an unusual state when this function is called: the
-** Fts5SegIter.iLeafOffset variable is set to the offset of the start of
-** the position-list size field for the first relevant rowid on the page.
-** Fts5SegIter.rowid is set, but nPos and bDel are not.
-**
-** This function advances the iterator so that it points to the last
-** relevant rowid on the page and, if necessary, initializes the
-** aRowidOffset[] and iRowidOffset variables. At this point the iterator
-** is in its regular state - Fts5SegIter.iLeafOffset points to the first
-** byte of the position list content associated with said rowid.
-*/
-static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
-  int eDetail = p->pConfig->eDetail;
-  int n = pIter->pLeaf->szLeaf;
-  int i = pIter->iLeafOffset;
-  u8 *a = pIter->pLeaf->p;
-  int iRowidOffset = 0;
-
-  if( n>pIter->iEndofDoclist ){
-    n = pIter->iEndofDoclist;
-  }
-
-  ASSERT_SZLEAF_OK(pIter->pLeaf);
-  while( 1 ){
-    u64 iDelta = 0;
-
-    if( i>=n ) break;
-    if( eDetail==FTS5_DETAIL_NONE ){
-      /* todo */
-      if( i<n && a[i]==0 ){
-        i++;
-        if( i<n && a[i]==0 ) i++;
-      }
-    }else{
-      int nPos;
-      int bDummy;
-      i += fts5GetPoslistSize(&a[i], &nPos, &bDummy);
-      i += nPos;
-    }
-    if( i>=n ) break;
-    i += fts5GetVarint(&a[i], &iDelta);
-    pIter->iRowid += iDelta;
-
-    /* If necessary, grow the pIter->aRowidOffset[] array. */
-    if( iRowidOffset>=pIter->nRowidOffset ){
-      i64 nNew = pIter->nRowidOffset + 8;
-      int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
-      if( aNew==0 ){
-        p->rc = SQLITE_NOMEM;
-        break;
-      }
-      pIter->aRowidOffset = aNew;
-      pIter->nRowidOffset = nNew;
-    }
-
-    pIter->aRowidOffset[iRowidOffset++] = pIter->iLeafOffset;
-    pIter->iLeafOffset = i;
-  }
-  pIter->iRowidOffset = iRowidOffset;
-  fts5SegIterLoadNPos(p, pIter);
-}
-
-/*
-**
-*/
-static void fts5SegIterReverseNewPage(Fts5Index *p, Fts5SegIter *pIter){
-  assert( pIter->flags & FTS5_SEGITER_REVERSE );
-  assert( pIter->flags & FTS5_SEGITER_ONETERM );
-
-  fts5DataRelease(pIter->pLeaf);
-  pIter->pLeaf = 0;
-  while( p->rc==SQLITE_OK && pIter->iLeafPgno>pIter->iTermLeafPgno ){
-    Fts5Data *pNew;
-    pIter->iLeafPgno--;
-    pNew = fts5DataRead(p, FTS5_SEGMENT_ROWID(
-          pIter->pSeg->iSegid, pIter->iLeafPgno
-    ));
-    if( pNew ){
-      /* iTermLeafOffset may be equal to szLeaf if the term is the last
-      ** thing on the page - i.e. the first rowid is on the following page.
-      ** In this case leave pIter->pLeaf==0, this iterator is at EOF. */
-      if( pIter->iLeafPgno==pIter->iTermLeafPgno ){
-        assert( pIter->pLeaf==0 );
-        if( pIter->iTermLeafOffset<pNew->szLeaf ){
-          pIter->pLeaf = pNew;
-          pIter->iLeafOffset = pIter->iTermLeafOffset;
-        }
-      }else{
-        int iRowidOff;
-        iRowidOff = fts5LeafFirstRowidOff(pNew);
-        if( iRowidOff ){
-          if( iRowidOff>=pNew->szLeaf ){
-            FTS5_CORRUPT_ITER(p, pIter);
-          }else{
-            pIter->pLeaf = pNew;
-            pIter->iLeafOffset = iRowidOff;
-          }
-        }
-      }
-
-      if( pIter->pLeaf ){
-        u8 *a = &pIter->pLeaf->p[pIter->iLeafOffset];
-        pIter->iLeafOffset += fts5GetVarint(a, (u64*)&pIter->iRowid);
-        break;
-      }else{
-        fts5DataRelease(pNew);
-      }
-    }
-  }
-
-  if( pIter->pLeaf ){
-    pIter->iEndofDoclist = pIter->pLeaf->nn+1;
-    fts5SegIterReverseInitPage(p, pIter);
-  }
-}
-
-/*
-** Return true if the iterator passed as the second argument currently
-** points to a delete marker. A delete marker is an entry with a 0 byte
-** position-list.
-*/
-static int fts5MultiIterIsEmpty(Fts5Index *p, Fts5Iter *pIter){
-  Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
-  return (p->rc==SQLITE_OK && pSeg->pLeaf && pSeg->nPos==0);
-}
-
-/*
-** Advance iterator pIter to the next entry.
-**
-** This version of fts5SegIterNext() is only used by reverse iterators.
-*/
-static void fts5SegIterNext_Reverse(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5SegIter *pIter,             /* Iterator to advance */
-  int *pbUnused                   /* Unused */
-){
-  assert( pIter->flags & FTS5_SEGITER_REVERSE );
-  assert( pIter->pNextLeaf==0 );
-  UNUSED_PARAM(pbUnused);
-
-  if( pIter->iRowidOffset>0 ){
-    u8 *a = pIter->pLeaf->p;
-    int iOff;
-    u64 iDelta;
-
-    pIter->iRowidOffset--;
-    pIter->iLeafOffset = pIter->aRowidOffset[pIter->iRowidOffset];
-    fts5SegIterLoadNPos(p, pIter);
-    iOff = pIter->iLeafOffset;
-    if( p->pConfig->eDetail!=FTS5_DETAIL_NONE ){
-      iOff += pIter->nPos;
-    }
-    fts5GetVarint(&a[iOff], &iDelta);
-    pIter->iRowid -= iDelta;
-  }else{
-    fts5SegIterReverseNewPage(p, pIter);
-  }
-}
-
-/*
-** Advance iterator pIter to the next entry.
-**
-** This version of fts5SegIterNext() is only used if detail=none and the
-** iterator is not a reverse direction iterator.
-*/
-static void fts5SegIterNext_None(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5SegIter *pIter,             /* Iterator to advance */
-  int *pbNewTerm                  /* OUT: Set for new term */
-){
-  int iOff;
-
-  assert( p->rc==SQLITE_OK );
-  assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
-  assert( p->pConfig->eDetail==FTS5_DETAIL_NONE );
-
-  ASSERT_SZLEAF_OK(pIter->pLeaf);
-  iOff = pIter->iLeafOffset;
-
-  /* Next entry is on the next page */
-  while( pIter->pSeg && iOff>=pIter->pLeaf->szLeaf ){
-    fts5SegIterNextPage(p, pIter);
-    if( p->rc || pIter->pLeaf==0 ) return;
-    pIter->iRowid = 0;
-    iOff = 4;
-  }
-
-  if( iOff<pIter->iEndofDoclist ){
-    /* Next entry is on the current page */
-    u64 iDelta;
-    iOff += sqlite3Fts5GetVarint(&pIter->pLeaf->p[iOff], (u64*)&iDelta);
-    pIter->iLeafOffset = iOff;
-    pIter->iRowid += iDelta;
-  }else if( (pIter->flags & FTS5_SEGITER_ONETERM)==0 ){
-    if( pIter->pSeg ){
-      int nKeep = 0;
-      if( iOff!=fts5LeafFirstTermOff(pIter->pLeaf) ){
-        iOff += fts5GetVarint32(&pIter->pLeaf->p[iOff], nKeep);
-      }
-      pIter->iLeafOffset = iOff;
-      fts5SegIterLoadTerm(p, pIter, nKeep);
-    }else{
-      const u8 *pList = 0;
-      const char *zTerm = 0;
-      int nTerm = 0;
-      int nList;
-      sqlite3Fts5HashScanNext(p->pHash);
-      sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &nTerm, &pList, &nList);
-      if( pList==0 ) goto next_none_eof;
-      pIter->pLeaf->p = (u8*)pList;
-      pIter->pLeaf->nn = nList;
-      pIter->pLeaf->szLeaf = nList;
-      pIter->iEndofDoclist = nList;
-      sqlite3Fts5BufferSet(&p->rc,&pIter->term, nTerm, (u8*)zTerm);
-      pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
-    }
-
-    if( pbNewTerm ) *pbNewTerm = 1;
-  }else{
-    goto next_none_eof;
-  }
-
-  fts5SegIterLoadNPos(p, pIter);
-
-  return;
- next_none_eof:
-  fts5DataRelease(pIter->pLeaf);
-  pIter->pLeaf = 0;
-}
-
-
-/*
-** Advance iterator pIter to the next entry.
-**
-** If an error occurs, Fts5Index.rc is set to an appropriate error code. It
-** is not considered an error if the iterator reaches EOF. If an error has
-** already occurred when this function is called, it is a no-op.
-*/
-static void fts5SegIterNext(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5SegIter *pIter,             /* Iterator to advance */
-  int *pbNewTerm                  /* OUT: Set for new term */
-){
-  Fts5Data *pLeaf = pIter->pLeaf;
-  int iOff;
-  int bNewTerm = 0;
-  int nKeep = 0;
-  u8 *a;
-  int n;
-
-  assert( pbNewTerm==0 || *pbNewTerm==0 );
-  assert( p->pConfig->eDetail!=FTS5_DETAIL_NONE );
-
-  /* Search for the end of the position list within the current page. */
-  a = pLeaf->p;
-  n = pLeaf->szLeaf;
-
-  ASSERT_SZLEAF_OK(pLeaf);
-  iOff = pIter->iLeafOffset + pIter->nPos;
-
-  if( iOff<n ){
-    /* The next entry is on the current page. */
-    assert_nc( iOff<=pIter->iEndofDoclist );
-    if( iOff>=pIter->iEndofDoclist ){
-      bNewTerm = 1;
-      if( iOff!=fts5LeafFirstTermOff(pLeaf) ){
-        iOff += fts5GetVarint32(&a[iOff], nKeep);
-      }
-    }else{
-      u64 iDelta;
-      iOff += sqlite3Fts5GetVarint(&a[iOff], &iDelta);
-      pIter->iRowid += iDelta;
-      assert_nc( iDelta>0 );
-    }
-    pIter->iLeafOffset = iOff;
-
-  }else if( pIter->pSeg==0 ){
-    const u8 *pList = 0;
-    const char *zTerm = 0;
-    int nTerm = 0;
-    int nList = 0;
-    assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
-    if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
-      sqlite3Fts5HashScanNext(p->pHash);
-      sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &nTerm, &pList, &nList);
-    }
-    if( pList==0 ){
-      fts5DataRelease(pIter->pLeaf);
-      pIter->pLeaf = 0;
-    }else{
-      pIter->pLeaf->p = (u8*)pList;
-      pIter->pLeaf->nn = nList;
-      pIter->pLeaf->szLeaf = nList;
-      pIter->iEndofDoclist = nList+1;
-      sqlite3Fts5BufferSet(&p->rc, &pIter->term, nTerm, (u8*)zTerm);
-      pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
-      *pbNewTerm = 1;
-    }
-  }else{
-    iOff = 0;
-    /* Next entry is not on the current page */
-    while( iOff==0 ){
-      fts5SegIterNextPage(p, pIter);
-      pLeaf = pIter->pLeaf;
-      if( pLeaf==0 ) break;
-      ASSERT_SZLEAF_OK(pLeaf);
-      if( (iOff = fts5LeafFirstRowidOff(pLeaf)) && iOff<pLeaf->szLeaf ){
-        iOff += sqlite3Fts5GetVarint(&pLeaf->p[iOff], (u64*)&pIter->iRowid);
-        pIter->iLeafOffset = iOff;
-
-        if( pLeaf->nn>pLeaf->szLeaf ){
-          pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
-              &pLeaf->p[pLeaf->szLeaf], pIter->iEndofDoclist
-          );
-        }
-      }
-      else if( pLeaf->nn>pLeaf->szLeaf ){
-        pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
-            &pLeaf->p[pLeaf->szLeaf], iOff
-        );
-        pIter->iLeafOffset = iOff;
-        pIter->iEndofDoclist = iOff;
-        bNewTerm = 1;
-      }
-      assert_nc( iOff<pLeaf->szLeaf );
-      if( iOff>pLeaf->szLeaf ){
-        FTS5_CORRUPT_ITER(p, pIter);
-        return;
-      }
-    }
-  }
-
-  /* Check if the iterator is now at EOF. If so, return early. */
-  if( pIter->pLeaf ){
-    if( bNewTerm ){
-      if( pIter->flags & FTS5_SEGITER_ONETERM ){
-        fts5DataRelease(pIter->pLeaf);
-        pIter->pLeaf = 0;
-      }else{
-        fts5SegIterLoadTerm(p, pIter, nKeep);
-        fts5SegIterLoadNPos(p, pIter);
-        if( pbNewTerm ) *pbNewTerm = 1;
-      }
-    }else{
-      /* The following could be done by calling fts5SegIterLoadNPos(). But
-      ** this block is particularly performance critical, so equivalent
-      ** code is inlined.  */
-      int nSz;
-      assert_nc( pIter->iLeafOffset<=pIter->pLeaf->nn );
-      fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
-      pIter->bDel = (nSz & 0x0001);
-      pIter->nPos = nSz>>1;
-      assert_nc( pIter->nPos>=0 );
-    }
-  }
-}
-
-#define SWAPVAL(T, a, b) { T tmp; tmp=a; a=b; b=tmp; }
-
-#define fts5IndexSkipVarint(a, iOff) {            \
-  int iEnd = iOff+9;                              \
-  while( (a[iOff++] & 0x80) && iOff<iEnd );       \
-}
-
-/*
-** Iterator pIter currently points to the first rowid in a doclist. This
-** function sets the iterator up so that iterates in reverse order through
-** the doclist.
-*/
-static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
-  Fts5DlidxIter *pDlidx = pIter->pDlidx;
-  Fts5Data *pLast = 0;
-  int pgnoLast = 0;
-
-  if( pDlidx && p->pConfig->iVersion==FTS5_CURRENT_VERSION ){
-    int iSegid = pIter->pSeg->iSegid;
-    pgnoLast = fts5DlidxIterPgno(pDlidx);
-    pLast = fts5LeafRead(p, FTS5_SEGMENT_ROWID(iSegid, pgnoLast));
-  }else{
-    Fts5Data *pLeaf = pIter->pLeaf;         /* Current leaf data */
-
-    /* Currently, Fts5SegIter.iLeafOffset points to the first byte of
-    ** position-list content for the current rowid. Back it up so that it
-    ** points to the start of the position-list size field. */
-    int iPoslist;
-    if( pIter->iTermLeafPgno==pIter->iLeafPgno ){
-      iPoslist = pIter->iTermLeafOffset;
-    }else{
-      iPoslist = 4;
-    }
-    fts5IndexSkipVarint(pLeaf->p, iPoslist);
-    pIter->iLeafOffset = iPoslist;
-
-    /* If this condition is true then the largest rowid for the current
-    ** term may not be stored on the current page. So search forward to
-    ** see where said rowid really is.  */
-    if( pIter->iEndofDoclist>=pLeaf->szLeaf ){
-      int pgno;
-      Fts5StructureSegment *pSeg = pIter->pSeg;
-
-      /* The last rowid in the doclist may not be on the current page. Search
-      ** forward to find the page containing the last rowid.  */
-      for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
-        i64 iAbs = FTS5_SEGMENT_ROWID(pSeg->iSegid, pgno);
-        Fts5Data *pNew = fts5LeafRead(p, iAbs);
-        if( pNew ){
-          int iRowid, bTermless;
-          iRowid = fts5LeafFirstRowidOff(pNew);
-          bTermless = fts5LeafIsTermless(pNew);
-          if( iRowid ){
-            SWAPVAL(Fts5Data*, pNew, pLast);
-            pgnoLast = pgno;
-          }
-          fts5DataRelease(pNew);
-          if( bTermless==0 ) break;
-        }
-      }
-    }
-  }
-
-  /* If pLast is NULL at this point, then the last rowid for this doclist
-  ** lies on the page currently indicated by the iterator. In this case
-  ** pIter->iLeafOffset is already set to point to the position-list size
-  ** field associated with the first relevant rowid on the page.
-  **
-  ** Or, if pLast is non-NULL, then it is the page that contains the last
-  ** rowid. In this case configure the iterator so that it points to the
-  ** first rowid on this page.
-  */
-  if( pLast ){
-    int iOff;
-    fts5DataRelease(pIter->pLeaf);
-    pIter->pLeaf = pLast;
-    pIter->iLeafPgno = pgnoLast;
-    if( p->rc==SQLITE_OK ){
-      iOff = fts5LeafFirstRowidOff(pLast);
-      if( iOff>pLast->szLeaf ){
-        FTS5_CORRUPT_ITER(p, pIter);
-        return;
-      }
-      iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
-      pIter->iLeafOffset = iOff;
-
-      if( fts5LeafIsTermless(pLast) ){
-        pIter->iEndofDoclist = pLast->nn+1;
-      }else{
-        pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
-      }
-    }
-  }
-
-  fts5SegIterReverseInitPage(p, pIter);
-}
-
-/*
-** Iterator pIter currently points to the first rowid of a doclist.
-** There is a doclist-index associated with the final term on the current
-** page. If the current term is the last term on the page, load the
-** doclist-index from disk and initialize an iterator at (pIter->pDlidx).
-*/
-static void fts5SegIterLoadDlidx(Fts5Index *p, Fts5SegIter *pIter){
-  int iSeg = pIter->pSeg->iSegid;
-  int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
-  Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
-
-  assert( pIter->flags & FTS5_SEGITER_ONETERM );
-  assert( pIter->pDlidx==0 );
-
-  /* Check if the current doclist ends on this page. If it does, return
-  ** early without loading the doclist-index (as it belongs to a different
-  ** term. */
-  if( pIter->iTermLeafPgno==pIter->iLeafPgno
-   && pIter->iEndofDoclist<pLeaf->szLeaf
-  ){
-    return;
-  }
-
-  pIter->pDlidx = fts5DlidxIterInit(p, bRev, iSeg, pIter->iTermLeafPgno);
-}
-
-/*
-** The iterator object passed as the second argument currently contains
-** no valid values except for the Fts5SegIter.pLeaf member variable. This
-** function searches the leaf page for a term matching (pTerm/nTerm).
-**
-** If the specified term is found on the page, then the iterator is left
-** pointing to it. If argument bGe is zero and the term is not found,
-** the iterator is left pointing at EOF.
-**
-** If bGe is non-zero and the specified term is not found, then the
-** iterator is left pointing to the smallest term in the segment that
-** is larger than the specified term, even if this term is not on the
-** current page.
-*/
-static void fts5LeafSeek(
-  Fts5Index *p,                   /* Leave any error code here */
-  int bGe,                        /* True for a >= search */
-  Fts5SegIter *pIter,             /* Iterator to seek */
-  const u8 *pTerm, int nTerm      /* Term to search for */
-){
-  u32 iOff;
-  const u8 *a = pIter->pLeaf->p;
-  u32 n = (u32)pIter->pLeaf->nn;
-
-  u32 nMatch = 0;
-  u32 nKeep = 0;
-  u32 nNew = 0;
-  u32 iTermOff;
-  u32 iPgidx;                     /* Current offset in pgidx */
-  int bEndOfPage = 0;
-
-  assert( p->rc==SQLITE_OK );
-
-  iPgidx = (u32)pIter->pLeaf->szLeaf;
-  iPgidx += fts5GetVarint32(&a[iPgidx], iTermOff);
-  iOff = iTermOff;
-  if( iOff>n ){
-    FTS5_CORRUPT_ITER(p, pIter);
-    return;
-  }
-
-  while( 1 ){
-
-    /* Figure out how many new bytes are in this term */
-    fts5FastGetVarint32(a, iOff, nNew);
-    if( nKeep<nMatch ){
-      goto search_failed;
-    }
-
-    assert( nKeep>=nMatch );
-    if( nKeep==nMatch ){
-      u32 nCmp;
-      u32 i;
-      nCmp = (u32)MIN(nNew, nTerm-nMatch);
-      for(i=0; i<nCmp; i++){
-        if( a[iOff+i]!=pTerm[nMatch+i] ) break;
-      }
-      nMatch += i;
-
-      if( (u32)nTerm==nMatch ){
-        if( i==nNew ){
-          goto search_success;
-        }else{
-          goto search_failed;
-        }
-      }else if( i<nNew && a[iOff+i]>pTerm[nMatch] ){
-        goto search_failed;
-      }
-    }
-
-    if( iPgidx>=n ){
-      bEndOfPage = 1;
-      break;
-    }
-
-    iPgidx += fts5GetVarint32(&a[iPgidx], nKeep);
-    iTermOff += nKeep;
-    iOff = iTermOff;
-
-    if( iOff>=n ){
-      FTS5_CORRUPT_ITER(p, pIter);
-      return;
-    }
-
-    /* Read the nKeep field of the next term. */
-    fts5FastGetVarint32(a, iOff, nKeep);
-  }
-
- search_failed:
-  if( bGe==0 ){
-    fts5DataRelease(pIter->pLeaf);
-    pIter->pLeaf = 0;
-    return;
-  }else if( bEndOfPage ){
-    do {
-      fts5SegIterNextPage(p, pIter);
-      if( pIter->pLeaf==0 ) return;
-      a = pIter->pLeaf->p;
-      if( fts5LeafIsTermless(pIter->pLeaf)==0 ){
-        iPgidx = (u32)pIter->pLeaf->szLeaf;
-        iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
-        if( iOff<4 || (i64)iOff>=pIter->pLeaf->szLeaf ){
-          FTS5_CORRUPT_ITER(p, pIter);
-          return;
-        }else{
-          nKeep = 0;
-          iTermOff = iOff;
-          n = (u32)pIter->pLeaf->nn;
-          iOff += fts5GetVarint32(&a[iOff], nNew);
-          break;
-        }
-      }
-    }while( 1 );
-  }
-
- search_success:
-  if( (i64)iOff+nNew>n || nNew<1 ){
-    FTS5_CORRUPT_ITER(p, pIter);
-    return;
-  }
-  pIter->iLeafOffset = iOff + nNew;
-  pIter->iTermLeafOffset = pIter->iLeafOffset;
-  pIter->iTermLeafPgno = pIter->iLeafPgno;
-
-  fts5BufferSet(&p->rc, &pIter->term, nKeep, pTerm);
-  fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
-
-  if( iPgidx>=n ){
-    pIter->iEndofDoclist = pIter->pLeaf->nn+1;
-  }else{
-    int nExtra;
-    iPgidx += fts5GetVarint32(&a[iPgidx], nExtra);
-    pIter->iEndofDoclist = iTermOff + nExtra;
-  }
-  pIter->iPgidxOff = iPgidx;
-
-  fts5SegIterLoadRowid(p, pIter);
-  fts5SegIterLoadNPos(p, pIter);
-}
-
-static sqlite3_stmt *fts5IdxSelectStmt(Fts5Index *p){
-  if( p->pIdxSelect==0 ){
-    Fts5Config *pConfig = p->pConfig;
-    fts5IndexPrepareStmt(p, &p->pIdxSelect, sqlite3_mprintf(
-          "SELECT pgno FROM '%q'.'%q_idx' WHERE "
-          "segid=? AND term<=? ORDER BY term DESC LIMIT 1",
-          pConfig->zDb, pConfig->zName
-    ));
-  }
-  return p->pIdxSelect;
-}
-
-/*
-** Initialize the object pIter to point to term pTerm/nTerm within segment
-** pSeg. If there is no such term in the index, the iterator is set to EOF.
-**
-** If an error occurs, Fts5Index.rc is set to an appropriate error code. If
-** an error has already occurred when this function is called, it is a no-op.
-*/
-static void fts5SegIterSeekInit(
-  Fts5Index *p,                   /* FTS5 backend */
-  const u8 *pTerm, int nTerm,     /* Term to seek to */
-  int flags,                      /* Mask of FTS5INDEX_XXX flags */
-  Fts5StructureSegment *pSeg,     /* Description of segment */
-  Fts5SegIter *pIter              /* Object to populate */
-){
-  int iPg = 1;
-  int bGe = (flags & FTS5INDEX_QUERY_SCAN);
-  int bDlidx = 0;                 /* True if there is a doclist-index */
-  sqlite3_stmt *pIdxSelect = 0;
-
-  assert( bGe==0 || (flags & FTS5INDEX_QUERY_DESC)==0 );
-  assert( pTerm && nTerm );
-  memset(pIter, 0, sizeof(*pIter));
-  pIter->pSeg = pSeg;
-
-  /* This block sets stack variable iPg to the leaf page number that may
-  ** contain term (pTerm/nTerm), if it is present in the segment. */
-  pIdxSelect = fts5IdxSelectStmt(p);
-  if( p->rc ) return;
-  sqlite3_bind_int(pIdxSelect, 1, pSeg->iSegid);
-  sqlite3_bind_blob(pIdxSelect, 2, pTerm, nTerm, SQLITE_STATIC);
-  if( SQLITE_ROW==sqlite3_step(pIdxSelect) ){
-    i64 val = sqlite3_column_int(pIdxSelect, 0);
-    iPg = (int)(val>>1);
-    bDlidx = (val & 0x0001);
-  }
-  p->rc = sqlite3_reset(pIdxSelect);
-  sqlite3_bind_null(pIdxSelect, 2);
-
-  if( iPg<pSeg->pgnoFirst ){
-    iPg = pSeg->pgnoFirst;
-    bDlidx = 0;
-  }
-
-  pIter->iLeafPgno = iPg - 1;
-  fts5SegIterNextPage(p, pIter);
-
-  if( pIter->pLeaf ){
-    fts5LeafSeek(p, bGe, pIter, pTerm, nTerm);
-  }
-
-  if( p->rc==SQLITE_OK && (bGe==0 || (flags & FTS5INDEX_QUERY_SCANONETERM)) ){
-    pIter->flags |= FTS5_SEGITER_ONETERM;
-    if( pIter->pLeaf ){
-      if( flags & FTS5INDEX_QUERY_DESC ){
-        pIter->flags |= FTS5_SEGITER_REVERSE;
-      }
-      if( bDlidx ){
-        fts5SegIterLoadDlidx(p, pIter);
-      }
-      if( flags & FTS5INDEX_QUERY_DESC ){
-        fts5SegIterReverse(p, pIter);
-      }
-    }
-  }
-
-  fts5SegIterSetNext(p, pIter);
-  if( 0==(flags & FTS5INDEX_QUERY_SCANONETERM) ){
-    fts5SegIterAllocTombstone(p, pIter);
-  }
-
-  /* Either:
-  **
-  **   1) an error has occurred, or
-  **   2) the iterator points to EOF, or
-  **   3) the iterator points to an entry with term (pTerm/nTerm), or
-  **   4) the FTS5INDEX_QUERY_SCAN flag was set and the iterator points
-  **      to an entry with a term greater than or equal to (pTerm/nTerm).
-  */
-  assert_nc( p->rc!=SQLITE_OK                                       /* 1 */
-   || pIter->pLeaf==0                                               /* 2 */
-   || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0          /* 3 */
-   || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0)  /* 4 */
-  );
-}
-
-
-/*
-** SQL used by fts5SegIterNextInit() to find the page to open.
-*/
-static sqlite3_stmt *fts5IdxNextStmt(Fts5Index *p){
-  if( p->pIdxNextSelect==0 ){
-    Fts5Config *pConfig = p->pConfig;
-    fts5IndexPrepareStmt(p, &p->pIdxNextSelect, sqlite3_mprintf(
-          "SELECT pgno FROM '%q'.'%q_idx' WHERE "
-          "segid=? AND term>? ORDER BY term ASC LIMIT 1",
-          pConfig->zDb, pConfig->zName
-    ));
-
-  }
-  return p->pIdxNextSelect;
-}
-
-/*
-** This is similar to fts5SegIterSeekInit(), except that it initializes
-** the segment iterator to point to the first term following the page
-** with pToken/nToken on it.
-*/
-static void fts5SegIterNextInit(
-  Fts5Index *p,
-  const char *pTerm, int nTerm,
-  Fts5StructureSegment *pSeg,     /* Description of segment */
-  Fts5SegIter *pIter              /* Object to populate */
-){
-  int iPg = -1;                   /* Page of segment to open */
-  int bDlidx = 0;
-  sqlite3_stmt *pSel = 0;         /* SELECT to find iPg */
-
-  pSel = fts5IdxNextStmt(p);
-  if( pSel ){
-    assert( p->rc==SQLITE_OK );
-    sqlite3_bind_int(pSel, 1, pSeg->iSegid);
-    sqlite3_bind_blob(pSel, 2, pTerm, nTerm, SQLITE_STATIC);
-
-    if( sqlite3_step(pSel)==SQLITE_ROW ){
-      i64 val = sqlite3_column_int64(pSel, 0);
-      iPg = (int)(val>>1);
-      bDlidx = (val & 0x0001);
-    }
-    p->rc = sqlite3_reset(pSel);
-    sqlite3_bind_null(pSel, 2);
-    if( p->rc ) return;
-  }
-
-  memset(pIter, 0, sizeof(*pIter));
-  pIter->pSeg = pSeg;
-  pIter->flags |= FTS5_SEGITER_ONETERM;
-  if( iPg>=0 ){
-    pIter->iLeafPgno = iPg - 1;
-    fts5SegIterNextPage(p, pIter);
-    fts5SegIterSetNext(p, pIter);
-  }
-  if( pIter->pLeaf ){
-    const u8 *a = pIter->pLeaf->p;
-    int iTermOff = 0;
-
-    pIter->iPgidxOff = pIter->pLeaf->szLeaf;
-    pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], iTermOff);
-    pIter->iLeafOffset = iTermOff;
-    fts5SegIterLoadTerm(p, pIter, 0);
-    fts5SegIterLoadNPos(p, pIter);
-    if( bDlidx ) fts5SegIterLoadDlidx(p, pIter);
-
-    assert( p->rc!=SQLITE_OK ||
-        fts5BufferCompareBlob(&pIter->term, (const u8*)pTerm, nTerm)>0
-    );
-  }
-}
-
-/*
-** Initialize the object pIter to point to term pTerm/nTerm within the
-** in-memory hash table. If there is no such term in the hash-table, the
-** iterator is set to EOF.
-**
-** If an error occurs, Fts5Index.rc is set to an appropriate error code. If
-** an error has already occurred when this function is called, it is a no-op.
-*/
-static void fts5SegIterHashInit(
-  Fts5Index *p,                   /* FTS5 backend */
-  const u8 *pTerm, int nTerm,     /* Term to seek to */
-  int flags,                      /* Mask of FTS5INDEX_XXX flags */
-  Fts5SegIter *pIter              /* Object to populate */
-){
-  int nList = 0;
-  const u8 *z = 0;
-  int n = 0;
-  Fts5Data *pLeaf = 0;
-
-  assert( p->pHash );
-  assert( p->rc==SQLITE_OK );
-
-  if( pTerm==0 || (flags & FTS5INDEX_QUERY_SCAN) ){
-    const u8 *pList = 0;
-
-    p->rc = sqlite3Fts5HashScanInit(p->pHash, (const char*)pTerm, nTerm);
-    sqlite3Fts5HashScanEntry(p->pHash, (const char**)&z, &n, &pList, &nList);
-    if( pList ){
-      pLeaf = fts5IdxMalloc(p, sizeof(Fts5Data));
-      if( pLeaf ){
-        pLeaf->p = (u8*)pList;
-      }
-    }
-
-    /* The call to sqlite3Fts5HashScanInit() causes the hash table to
-    ** fill the size field of all existing position lists. This means they
-    ** can no longer be appended to. Since the only scenario in which they
-    ** can be appended to is if the previous operation on this table was
-    ** a DELETE, by clearing the Fts5Index.bDelete flag we can avoid this
-    ** possibility altogether.  */
-    p->bDelete = 0;
-  }else{
-    p->rc = sqlite3Fts5HashQuery(p->pHash, sizeof(Fts5Data),
-        (const char*)pTerm, nTerm, (void**)&pLeaf, &nList
-    );
-    if( pLeaf ){
-      pLeaf->p = (u8*)&pLeaf[1];
-    }
-    z = pTerm;
-    n = nTerm;
-    pIter->flags |= FTS5_SEGITER_ONETERM;
-  }
-
-  if( pLeaf ){
-    sqlite3Fts5BufferSet(&p->rc, &pIter->term, n, z);
-    pLeaf->nn = pLeaf->szLeaf = nList;
-    pIter->pLeaf = pLeaf;
-    pIter->iLeafOffset = fts5GetVarint(pLeaf->p, (u64*)&pIter->iRowid);
-    pIter->iEndofDoclist = pLeaf->nn;
-
-    if( flags & FTS5INDEX_QUERY_DESC ){
-      pIter->flags |= FTS5_SEGITER_REVERSE;
-      fts5SegIterReverseInitPage(p, pIter);
-    }else{
-      fts5SegIterLoadNPos(p, pIter);
-    }
-  }
-
-  fts5SegIterSetNext(p, pIter);
-}
-
-/*
-** Array ap[] contains n elements. Release each of these elements using
-** fts5DataRelease(). Then free the array itself using sqlite3_free().
-*/
-static void fts5IndexFreeArray(Fts5Data **ap, int n){
-  if( ap ){
-    int ii;
-    for(ii=0; ii<n; ii++){
-      fts5DataRelease(ap[ii]);
-    }
-    sqlite3_free(ap);
-  }
-}
-
-/*
-** Decrement the ref-count of the object passed as the only argument. If it
-** reaches 0, free it and its contents.
-*/
-static void fts5TombstoneArrayDelete(Fts5TombstoneArray *p){
-  if( p ){
-    p->nRef--;
-    if( p->nRef<=0 ){
-      int ii;
-      for(ii=0; ii<p->nTombstone; ii++){
-        fts5DataRelease(p->apTombstone[ii]);
-      }
-      sqlite3_free(p);
-    }
-  }
-}
-
-/*
-** Zero the iterator passed as the only argument.
-*/
-static void fts5SegIterClear(Fts5SegIter *pIter){
-  fts5BufferFree(&pIter->term);
-  fts5DataRelease(pIter->pLeaf);
-  fts5DataRelease(pIter->pNextLeaf);
-  fts5TombstoneArrayDelete(pIter->pTombArray);
-  fts5DlidxIterFree(pIter->pDlidx);
-  sqlite3_free(pIter->aRowidOffset);
-  memset(pIter, 0, sizeof(Fts5SegIter));
-}
-
-#ifdef SQLITE_DEBUG
-
-/*
-** This function is used as part of the big assert() procedure implemented by
-** fts5AssertMultiIterSetup(). It ensures that the result currently stored
-** in *pRes is the correct result of comparing the current positions of the
-** two iterators.
-*/
-static void fts5AssertComparisonResult(
-  Fts5Iter *pIter,
-  Fts5SegIter *p1,
-  Fts5SegIter *p2,
-  Fts5CResult *pRes
-){
-  int i1 = p1 - pIter->aSeg;
-  int i2 = p2 - pIter->aSeg;
-
-  if( p1->pLeaf || p2->pLeaf ){
-    if( p1->pLeaf==0 ){
-      assert( pRes->iFirst==i2 );
-    }else if( p2->pLeaf==0 ){
-      assert( pRes->iFirst==i1 );
-    }else{
-      int nMin = MIN(p1->term.n, p2->term.n);
-      int res = fts5Memcmp(p1->term.p, p2->term.p, nMin);
-      if( res==0 ) res = p1->term.n - p2->term.n;
-
-      if( res==0 ){
-        assert( pRes->bTermEq==1 );
-        assert( p1->iRowid!=p2->iRowid );
-        res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : 1;
-      }else{
-        assert( pRes->bTermEq==0 );
-      }
-
-      if( res<0 ){
-        assert( pRes->iFirst==i1 );
-      }else{
-        assert( pRes->iFirst==i2 );
-      }
-    }
-  }
-}
-
-/*
-** This function is a no-op unless SQLITE_DEBUG is defined when this module
-** is compiled. In that case, this function is essentially an assert()
-** statement used to verify that the contents of the pIter->aFirst[] array
-** are correct.
-*/
-static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5Iter *pIter){
-  if( p->rc==SQLITE_OK ){
-    Fts5SegIter *pFirst = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
-    int i;
-
-    assert( (pFirst->pLeaf==0)==pIter->base.bEof );
-
-    /* Check that pIter->iSwitchRowid is set correctly. */
-    for(i=0; i<pIter->nSeg; i++){
-      Fts5SegIter *p1 = &pIter->aSeg[i];
-      assert( p1==pFirst
-           || p1->pLeaf==0
-           || fts5BufferCompare(&pFirst->term, &p1->term)
-           || p1->iRowid==pIter->iSwitchRowid
-           || (p1->iRowid<pIter->iSwitchRowid)==pIter->bRev
-      );
-    }
-
-    for(i=0; i<pIter->nSeg; i+=2){
-      Fts5SegIter *p1 = &pIter->aSeg[i];
-      Fts5SegIter *p2 = &pIter->aSeg[i+1];
-      Fts5CResult *pRes = &pIter->aFirst[(pIter->nSeg + i) / 2];
-      fts5AssertComparisonResult(pIter, p1, p2, pRes);
-    }
-
-    for(i=1; i<(pIter->nSeg / 2); i+=2){
-      Fts5SegIter *p1 = &pIter->aSeg[ pIter->aFirst[i*2].iFirst ];
-      Fts5SegIter *p2 = &pIter->aSeg[ pIter->aFirst[i*2+1].iFirst ];
-      Fts5CResult *pRes = &pIter->aFirst[i];
-      fts5AssertComparisonResult(pIter, p1, p2, pRes);
-    }
-  }
-}
-#else
-# define fts5AssertMultiIterSetup(x,y)
-#endif
-
-/*
-** Do the comparison necessary to populate pIter->aFirst[iOut].
-**
-** If the returned value is non-zero, then it is the index of an entry
-** in the pIter->aSeg[] array that is (a) not at EOF, and (b) pointing
-** to a key that is a duplicate of another, higher priority,
-** segment-iterator in the pSeg->aSeg[] array.
-*/
-static int fts5MultiIterDoCompare(Fts5Iter *pIter, int iOut){
-  int i1;                         /* Index of left-hand Fts5SegIter */
-  int i2;                         /* Index of right-hand Fts5SegIter */
-  int iRes;
-  Fts5SegIter *p1;                /* Left-hand Fts5SegIter */
-  Fts5SegIter *p2;                /* Right-hand Fts5SegIter */
-  Fts5CResult *pRes = &pIter->aFirst[iOut];
-
-  assert( iOut<pIter->nSeg && iOut>0 );
-  assert( pIter->bRev==0 || pIter->bRev==1 );
-
-  if( iOut>=(pIter->nSeg/2) ){
-    i1 = (iOut - pIter->nSeg/2) * 2;
-    i2 = i1 + 1;
-  }else{
-    i1 = pIter->aFirst[iOut*2].iFirst;
-    i2 = pIter->aFirst[iOut*2+1].iFirst;
-  }
-  p1 = &pIter->aSeg[i1];
-  p2 = &pIter->aSeg[i2];
-
-  pRes->bTermEq = 0;
-  if( p1->pLeaf==0 ){           /* If p1 is at EOF */
-    iRes = i2;
-  }else if( p2->pLeaf==0 ){     /* If p2 is at EOF */
-    iRes = i1;
-  }else{
-    int res = fts5BufferCompare(&p1->term, &p2->term);
-    if( res==0 ){
-      assert_nc( i2>i1 );
-      assert_nc( i2!=0 );
-      pRes->bTermEq = 1;
-      if( p1->iRowid==p2->iRowid ){
-        return i2;
-      }
-      res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : +1;
-    }
-    assert( res!=0 );
-    if( res<0 ){
-      iRes = i1;
-    }else{
-      iRes = i2;
-    }
-  }
-
-  pRes->iFirst = (u16)iRes;
-  return 0;
-}
-
-/*
-** Move the seg-iter so that it points to the first rowid on page iLeafPgno.
-** It is an error if leaf iLeafPgno does not exist. Unless the db is
-** a 'secure-delete' db, if it contains no rowids then this is also an error.
-*/
-static void fts5SegIterGotoPage(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5SegIter *pIter,             /* Iterator to advance */
-  int iLeafPgno
-){
-  assert( iLeafPgno>pIter->iLeafPgno );
-
-  if( iLeafPgno>pIter->pSeg->pgnoLast ){
-    FTS5_CORRUPT_IDX(p);
-  }else{
-    fts5DataRelease(pIter->pNextLeaf);
-    pIter->pNextLeaf = 0;
-    pIter->iLeafPgno = iLeafPgno-1;
-
-    while( p->rc==SQLITE_OK ){
-      int iOff;
-      fts5SegIterNextPage(p, pIter);
-      if( pIter->pLeaf==0 ) break;
-      iOff = fts5LeafFirstRowidOff(pIter->pLeaf);
-      if( iOff>0 ){
-        u8 *a = pIter->pLeaf->p;
-        int n = pIter->pLeaf->szLeaf;
-        if( iOff<4 || iOff>=n ){
-          FTS5_CORRUPT_IDX(p);
-        }else{
-          iOff += fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
-          pIter->iLeafOffset = iOff;
-          fts5SegIterLoadNPos(p, pIter);
-        }
-        break;
-      }
-    }
-  }
-}
-
-/*
-** Advance the iterator passed as the second argument until it is at or
-** past rowid iFrom. Regardless of the value of iFrom, the iterator is
-** always advanced at least once.
-*/
-static void fts5SegIterNextFrom(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5SegIter *pIter,             /* Iterator to advance */
-  i64 iMatch                      /* Advance iterator at least this far */
-){
-  int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
-  Fts5DlidxIter *pDlidx = pIter->pDlidx;
-  int iLeafPgno = pIter->iLeafPgno;
-  int bMove = 1;
-
-  assert( pIter->flags & FTS5_SEGITER_ONETERM );
-  assert( pIter->pDlidx );
-  assert( pIter->pLeaf );
-
-  if( bRev==0 ){
-    while( !fts5DlidxIterEof(p, pDlidx) && iMatch>fts5DlidxIterRowid(pDlidx) ){
-      iLeafPgno = fts5DlidxIterPgno(pDlidx);
-      fts5DlidxIterNext(p, pDlidx);
-    }
-    assert_nc( iLeafPgno>=pIter->iLeafPgno || p->rc );
-    if( iLeafPgno>pIter->iLeafPgno ){
-      fts5SegIterGotoPage(p, pIter, iLeafPgno);
-      bMove = 0;
-    }
-  }else{
-    assert( pIter->pNextLeaf==0 );
-    assert( iMatch<pIter->iRowid );
-    while( !fts5DlidxIterEof(p, pDlidx) && iMatch<fts5DlidxIterRowid(pDlidx) ){
-      fts5DlidxIterPrev(p, pDlidx);
-    }
-    iLeafPgno = fts5DlidxIterPgno(pDlidx);
-
-    assert( fts5DlidxIterEof(p, pDlidx) || iLeafPgno<=pIter->iLeafPgno );
-
-    if( iLeafPgno<pIter->iLeafPgno ){
-      pIter->iLeafPgno = iLeafPgno+1;
-      fts5SegIterReverseNewPage(p, pIter);
-      bMove = 0;
-    }
-  }
-
-  do{
-    if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
-    if( pIter->pLeaf==0 ) break;
-    if( bRev==0 && pIter->iRowid>=iMatch ) break;
-    if( bRev!=0 && pIter->iRowid<=iMatch ) break;
-    bMove = 1;
-  }while( p->rc==SQLITE_OK );
-}
-
-/*
-** Free the iterator object passed as the second argument.
-*/
-static void fts5MultiIterFree(Fts5Iter *pIter){
-  if( pIter ){
-    int i;
-    for(i=0; i<pIter->nSeg; i++){
-      fts5SegIterClear(&pIter->aSeg[i]);
-    }
-    fts5BufferFree(&pIter->poslist);
-    sqlite3_free(pIter);
-  }
-}
-
-static void fts5MultiIterAdvanced(
-  Fts5Index *p,                   /* FTS5 backend to iterate within */
-  Fts5Iter *pIter,                /* Iterator to update aFirst[] array for */
-  int iChanged,                   /* Index of sub-iterator just advanced */
-  int iMinset                     /* Minimum entry in aFirst[] to set */
-){
-  int i;
-  for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
-    int iEq;
-    if( (iEq = fts5MultiIterDoCompare(pIter, i)) ){
-      Fts5SegIter *pSeg = &pIter->aSeg[iEq];
-      assert( p->rc==SQLITE_OK );
-      pSeg->xNext(p, pSeg, 0);
-      i = pIter->nSeg + iEq;
-    }
-  }
-}
-
-/*
-** Sub-iterator iChanged of iterator pIter has just been advanced. It still
-** points to the same term though - just a different rowid. This function
-** attempts to update the contents of the pIter->aFirst[] accordingly.
-** If it does so successfully, 0 is returned. Otherwise 1.
-**
-** If non-zero is returned, the caller should call fts5MultiIterAdvanced()
-** on the iterator instead. That function does the same as this one, except
-** that it deals with more complicated cases as well.
-*/
-static int fts5MultiIterAdvanceRowid(
-  Fts5Iter *pIter,                /* Iterator to update aFirst[] array for */
-  int iChanged,                   /* Index of sub-iterator just advanced */
-  Fts5SegIter **ppFirst
-){
-  Fts5SegIter *pNew = &pIter->aSeg[iChanged];
-
-  if( pNew->iRowid==pIter->iSwitchRowid
-   || (pNew->iRowid<pIter->iSwitchRowid)==pIter->bRev
-  ){
-    int i;
-    Fts5SegIter *pOther = &pIter->aSeg[iChanged ^ 0x0001];
-    pIter->iSwitchRowid = pIter->bRev ? SMALLEST_INT64 : LARGEST_INT64;
-    for(i=(pIter->nSeg+iChanged)/2; 1; i=i/2){
-      Fts5CResult *pRes = &pIter->aFirst[i];
-
-      assert( pNew->pLeaf );
-      assert( pRes->bTermEq==0 || pOther->pLeaf );
-
-      if( pRes->bTermEq ){
-        if( pNew->iRowid==pOther->iRowid ){
-          return 1;
-        }else if( (pOther->iRowid>pNew->iRowid)==pIter->bRev ){
-          pIter->iSwitchRowid = pOther->iRowid;
-          pNew = pOther;
-        }else if( (pOther->iRowid>pIter->iSwitchRowid)==pIter->bRev ){
-          pIter->iSwitchRowid = pOther->iRowid;
-        }
-      }
-      pRes->iFirst = (u16)(pNew - pIter->aSeg);
-      if( i==1 ) break;
-
-      pOther = &pIter->aSeg[ pIter->aFirst[i ^ 0x0001].iFirst ];
-    }
-  }
-
-  *ppFirst = pNew;
-  return 0;
-}
-
-/*
-** Set the pIter->bEof variable based on the state of the sub-iterators.
-*/
-static void fts5MultiIterSetEof(Fts5Iter *pIter){
-  Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
-  pIter->base.bEof = pSeg->pLeaf==0;
-  pIter->iSwitchRowid = pSeg->iRowid;
-}
-
-/*
-** The argument to this macro must be an Fts5Data structure containing a
-** tombstone hash page. This macro returns the key-size of the hash-page.
-*/
-#define TOMBSTONE_KEYSIZE(pPg) (pPg->p[0]==4 ? 4 : 8)
-
-#define TOMBSTONE_NSLOT(pPg)   \
-  ((pPg->nn > 16) ? ((pPg->nn-8) / TOMBSTONE_KEYSIZE(pPg)) : 1)
-
-/*
-** Query a single tombstone hash table for rowid iRowid. Return true if
-** it is found or false otherwise. The tombstone hash table is one of
-** nHashTable tables.
-*/
-static int fts5IndexTombstoneQuery(
-  Fts5Data *pHash,                /* Hash table page to query */
-  int nHashTable,                 /* Number of pages attached to segment */
-  u64 iRowid                      /* Rowid to query hash for */
-){
-  const int szKey = TOMBSTONE_KEYSIZE(pHash);
-  const int nSlot = TOMBSTONE_NSLOT(pHash);
-  int iSlot = (iRowid / nHashTable) % nSlot;
-  int nCollide = nSlot;
-
-  if( iRowid==0 ){
-    return pHash->p[1];
-  }else if( szKey==4 ){
-    u32 *aSlot = (u32*)&pHash->p[8];
-    while( aSlot[iSlot] ){
-      if( fts5GetU32((u8*)&aSlot[iSlot])==iRowid ) return 1;
-      if( nCollide--==0 ) break;
-      iSlot = (iSlot+1)%nSlot;
-    }
-  }else{
-    u64 *aSlot = (u64*)&pHash->p[8];
-    while( aSlot[iSlot] ){
-      if( fts5GetU64((u8*)&aSlot[iSlot])==iRowid ) return 1;
-      if( nCollide--==0 ) break;
-      iSlot = (iSlot+1)%nSlot;
-    }
-  }
-
-  return 0;
-}
-
-/*
-** Return true if the iterator passed as the only argument points
-** to an segment entry for which there is a tombstone. Return false
-** if there is no tombstone or if the iterator is already at EOF.
-*/
-static int fts5MultiIterIsDeleted(Fts5Iter *pIter){
-  int iFirst = pIter->aFirst[1].iFirst;
-  Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
-  Fts5TombstoneArray *pArray = pSeg->pTombArray;
-
-  if( pSeg->pLeaf && pArray ){
-    /* Figure out which page the rowid might be present on. */
-    int iPg = ((u64)pSeg->iRowid) % pArray->nTombstone;
-    assert( iPg>=0 );
-
-    /* If tombstone hash page iPg has not yet been loaded from the
-    ** database, load it now. */
-    if( pArray->apTombstone[iPg]==0 ){
-      pArray->apTombstone[iPg] = fts5DataRead(pIter->pIndex,
-          FTS5_TOMBSTONE_ROWID(pSeg->pSeg->iSegid, iPg)
-      );
-      if( pArray->apTombstone[iPg]==0 ) return 0;
-    }
-
-    return fts5IndexTombstoneQuery(
-        pArray->apTombstone[iPg],
-        pArray->nTombstone,
-        pSeg->iRowid
-    );
-  }
-
-  return 0;
-}
-
-/*
-** Move the iterator to the next entry.
-**
-** If an error occurs, an error code is left in Fts5Index.rc. It is not
-** considered an error if the iterator reaches EOF, or if it is already at
-** EOF when this function is called.
-*/
-static void fts5MultiIterNext(
-  Fts5Index *p,
-  Fts5Iter *pIter,
-  int bFrom,                      /* True if argument iFrom is valid */
-  i64 iFrom                       /* Advance at least as far as this */
-){
-  int bUseFrom = bFrom;
-  assert( pIter->base.bEof==0 );
-  while( p->rc==SQLITE_OK ){
-    int iFirst = pIter->aFirst[1].iFirst;
-    int bNewTerm = 0;
-    Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
-    assert( p->rc==SQLITE_OK );
-    if( bUseFrom && pSeg->pDlidx ){
-      fts5SegIterNextFrom(p, pSeg, iFrom);
-    }else{
-      pSeg->xNext(p, pSeg, &bNewTerm);
-    }
-
-    if( pSeg->pLeaf==0 || bNewTerm
-     || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
-    ){
-      fts5MultiIterAdvanced(p, pIter, iFirst, 1);
-      fts5MultiIterSetEof(pIter);
-      pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
-      if( pSeg->pLeaf==0 ) return;
-    }
-
-    fts5AssertMultiIterSetup(p, pIter);
-    assert( pSeg==&pIter->aSeg[pIter->aFirst[1].iFirst] && pSeg->pLeaf );
-    if( (pIter->bSkipEmpty==0 || pSeg->nPos)
-      && 0==fts5MultiIterIsDeleted(pIter)
-    ){
-      pIter->xSetOutputs(pIter, pSeg);
-      return;
-    }
-    bUseFrom = 0;
-  }
-}
-
-static void fts5MultiIterNext2(
-  Fts5Index *p,
-  Fts5Iter *pIter,
-  int *pbNewTerm                  /* OUT: True if *might* be new term */
-){
-  assert( pIter->bSkipEmpty );
-  if( p->rc==SQLITE_OK ){
-    *pbNewTerm = 0;
-    do{
-      int iFirst = pIter->aFirst[1].iFirst;
-      Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
-      int bNewTerm = 0;
-
-      assert( p->rc==SQLITE_OK );
-      pSeg->xNext(p, pSeg, &bNewTerm);
-      if( pSeg->pLeaf==0 || bNewTerm
-       || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
-      ){
-        fts5MultiIterAdvanced(p, pIter, iFirst, 1);
-        fts5MultiIterSetEof(pIter);
-        *pbNewTerm = 1;
-      }
-      fts5AssertMultiIterSetup(p, pIter);
-
-    }while( (fts5MultiIterIsEmpty(p, pIter) || fts5MultiIterIsDeleted(pIter))
-         && (p->rc==SQLITE_OK)
-    );
-  }
-}
-
-static void fts5IterSetOutputs_Noop(Fts5Iter *pUnused1, Fts5SegIter *pUnused2){
-  UNUSED_PARAM2(pUnused1, pUnused2);
-}
-
-static Fts5Iter *fts5MultiIterAlloc(
-  Fts5Index *p,                   /* FTS5 backend to iterate within */
-  int nSeg
-){
-  Fts5Iter *pNew;
-  i64 nSlot;                      /* Power of two >= nSeg */
-
-  for(nSlot=2; nSlot<nSeg; nSlot=nSlot*2);
-  pNew = fts5IdxMalloc(p,
-      SZ_FTS5ITER(nSlot) +                /* pNew + pNew->aSeg[] */
-      sizeof(Fts5CResult) * nSlot         /* pNew->aFirst[] */
-  );
-  if( pNew ){
-    pNew->nSeg = nSlot;
-    pNew->aFirst = (Fts5CResult*)&pNew->aSeg[nSlot];
-    pNew->pIndex = p;
-    pNew->xSetOutputs = fts5IterSetOutputs_Noop;
-  }
-  return pNew;
-}
-
-static void fts5PoslistCallback(
-  Fts5Index *pUnused,
-  void *pContext,
-  const u8 *pChunk, int nChunk
-){
-  UNUSED_PARAM(pUnused);
-  assert_nc( nChunk>=0 );
-  if( nChunk>0 ){
-    fts5BufferSafeAppendBlob((Fts5Buffer*)pContext, pChunk, nChunk);
-  }
-}
-
-typedef struct PoslistCallbackCtx PoslistCallbackCtx;
-struct PoslistCallbackCtx {
-  Fts5Buffer *pBuf;               /* Append to this buffer */
-  Fts5Colset *pColset;            /* Restrict matches to this column */
-  int eState;                     /* See above */
-};
-
-typedef struct PoslistOffsetsCtx PoslistOffsetsCtx;
-struct PoslistOffsetsCtx {
-  Fts5Buffer *pBuf;               /* Append to this buffer */
-  Fts5Colset *pColset;            /* Restrict matches to this column */
-  int iRead;
-  int iWrite;
-};
-
-/*
-** TODO: Make this more efficient!
-*/
-static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
-  int i;
-  for(i=0; i<pColset->nCol; i++){
-    if( pColset->aiCol[i]==iCol ) return 1;
-  }
-  return 0;
-}
-
-static void fts5PoslistOffsetsCallback(
-  Fts5Index *pUnused,
-  void *pContext,
-  const u8 *pChunk, int nChunk
-){
-  PoslistOffsetsCtx *pCtx = (PoslistOffsetsCtx*)pContext;
-  UNUSED_PARAM(pUnused);
-  assert_nc( nChunk>=0 );
-  if( nChunk>0 ){
-    int i = 0;
-    while( i<nChunk ){
-      int iVal;
-      i += fts5GetVarint32(&pChunk[i], iVal);
-      iVal += pCtx->iRead - 2;
-      pCtx->iRead = iVal;
-      if( fts5IndexColsetTest(pCtx->pColset, iVal) ){
-        fts5BufferSafeAppendVarint(pCtx->pBuf, iVal + 2 - pCtx->iWrite);
-        pCtx->iWrite = iVal;
-      }
-    }
-  }
-}
-
-static void fts5PoslistFilterCallback(
-  Fts5Index *pUnused,
-  void *pContext,
-  const u8 *pChunk, int nChunk
-){
-  PoslistCallbackCtx *pCtx = (PoslistCallbackCtx*)pContext;
-  UNUSED_PARAM(pUnused);
-  assert_nc( nChunk>=0 );
-  if( nChunk>0 ){
-    /* Search through to find the first varint with value 1. This is the
-    ** start of the next columns hits. */
-    int i = 0;
-    int iStart = 0;
-
-    if( pCtx->eState==2 ){
-      int iCol;
-      fts5FastGetVarint32(pChunk, i, iCol);
-      if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
-        pCtx->eState = 1;
-        fts5BufferSafeAppendVarint(pCtx->pBuf, 1);
-      }else{
-        pCtx->eState = 0;
-      }
-    }
-
-    do {
-      while( i<nChunk && pChunk[i]!=0x01 ){
-        while( pChunk[i] & 0x80 ) i++;
-        i++;
-      }
-      if( pCtx->eState ){
-        fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
-      }
-      if( i<nChunk ){
-        int iCol;
-        iStart = i;
-        i++;
-        if( i>=nChunk ){
-          pCtx->eState = 2;
-        }else{
-          fts5FastGetVarint32(pChunk, i, iCol);
-          pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
-          if( pCtx->eState ){
-            fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
-            iStart = i;
-          }
-        }
-      }
-    }while( i<nChunk );
-  }
-}
-
-static void fts5ChunkIterate(
-  Fts5Index *p,                   /* Index object */
-  Fts5SegIter *pSeg,              /* Poslist of this iterator */
-  void *pCtx,                     /* Context pointer for xChunk callback */
-  void (*xChunk)(Fts5Index*, void*, const u8*, int)
-){
-  int nRem = pSeg->nPos;          /* Number of bytes still to come */
-  Fts5Data *pData = 0;
-  u8 *pChunk = &pSeg->pLeaf->p[pSeg->iLeafOffset];
-  int nChunk = MIN(nRem, pSeg->pLeaf->szLeaf - pSeg->iLeafOffset);
-  int pgno = pSeg->iLeafPgno;
-  int pgnoSave = 0;
-
-  /* This function does not work with detail=none databases. */
-  assert( p->pConfig->eDetail!=FTS5_DETAIL_NONE );
-
-  if( (pSeg->flags & FTS5_SEGITER_REVERSE)==0 ){
-    pgnoSave = pgno+1;
-  }
-
-  while( 1 ){
-    xChunk(p, pCtx, pChunk, nChunk);
-    nRem -= nChunk;
-    fts5DataRelease(pData);
-    if( nRem<=0 ){
-      break;
-    }else if( pSeg->pSeg==0 ){
-      FTS5_CORRUPT_IDX(p);
-      return;
-    }else{
-      pgno++;
-      pData = fts5LeafRead(p, FTS5_SEGMENT_ROWID(pSeg->pSeg->iSegid, pgno));
-      if( pData==0 ) break;
-      pChunk = &pData->p[4];
-      nChunk = MIN(nRem, pData->szLeaf - 4);
-      if( pgno==pgnoSave ){
-        assert( pSeg->pNextLeaf==0 );
-        pSeg->pNextLeaf = pData;
-        pData = 0;
-      }
-    }
-  }
-}
-
-/*
-** Iterator pIter currently points to a valid entry (not EOF). This
-** function appends the position list data for the current entry to
-** buffer pBuf. It does not make a copy of the position-list size
-** field.
-*/
-static void fts5SegiterPoslist(
-  Fts5Index *p,
-  Fts5SegIter *pSeg,
-  Fts5Colset *pColset,
-  Fts5Buffer *pBuf
-){
-  assert( pBuf!=0 );
-  assert( pSeg!=0 );
-  if( 0==fts5BufferGrow(&p->rc, pBuf, pSeg->nPos+FTS5_DATA_ZERO_PADDING) ){
-    assert( pBuf->p!=0 );
-    assert( pBuf->nSpace >= pBuf->n+pSeg->nPos+FTS5_DATA_ZERO_PADDING );
-    memset(&pBuf->p[pBuf->n+pSeg->nPos], 0, FTS5_DATA_ZERO_PADDING);
-    if( pColset==0 ){
-      fts5ChunkIterate(p, pSeg, (void*)pBuf, fts5PoslistCallback);
-    }else{
-      if( p->pConfig->eDetail==FTS5_DETAIL_FULL ){
-        PoslistCallbackCtx sCtx;
-        sCtx.pBuf = pBuf;
-        sCtx.pColset = pColset;
-        sCtx.eState = fts5IndexColsetTest(pColset, 0);
-        assert( sCtx.eState==0 || sCtx.eState==1 );
-        fts5ChunkIterate(p, pSeg, (void*)&sCtx, fts5PoslistFilterCallback);
-      }else{
-        PoslistOffsetsCtx sCtx;
-        memset(&sCtx, 0, sizeof(sCtx));
-        sCtx.pBuf = pBuf;
-        sCtx.pColset = pColset;
-        fts5ChunkIterate(p, pSeg, (void*)&sCtx, fts5PoslistOffsetsCallback);
-      }
-    }
-  }
-}
-
-/*
-** Parameter pPos points to a buffer containing a position list, size nPos.
-** This function filters it according to pColset (which must be non-NULL)
-** and sets pIter->base.pData/nData to point to the new position list.
-** If memory is required for the new position list, use buffer pIter->poslist.
-** Or, if the new position list is a contiguous subset of the input, set
-** pIter->base.pData/nData to point directly to it.
-**
-** This function is a no-op if *pRc is other than SQLITE_OK when it is
-** called. If an OOM error is encountered, *pRc is set to SQLITE_NOMEM
-** before returning.
-*/
-static void fts5IndexExtractColset(
-  int *pRc,
-  Fts5Colset *pColset,            /* Colset to filter on */
-  const u8 *pPos, int nPos,       /* Position list */
-  Fts5Iter *pIter
-){
-  if( *pRc==SQLITE_OK ){
-    const u8 *p = pPos;
-    const u8 *aCopy = p;
-    const u8 *pEnd = &p[nPos];    /* One byte past end of position list */
-    int i = 0;
-    int iCurrent = 0;
-
-    if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
-      return;
-    }
-
-    while( 1 ){
-      while( pColset->aiCol[i]<iCurrent ){
-        i++;
-        if( i==pColset->nCol ){
-          pIter->base.pData = pIter->poslist.p;
-          pIter->base.nData = pIter->poslist.n;
-          return;
-        }
-      }
-
-      /* Advance pointer p until it points to pEnd or an 0x01 byte that is
-      ** not part of a varint */
-      while( p<pEnd && *p!=0x01 ){
-        while( *p++ & 0x80 );
-      }
-
-      if( pColset->aiCol[i]==iCurrent ){
-        if( pColset->nCol==1 ){
-          pIter->base.pData = aCopy;
-          pIter->base.nData = p-aCopy;
-          return;
-        }
-        fts5BufferSafeAppendBlob(&pIter->poslist, aCopy, p-aCopy);
-      }
-      if( p>=pEnd ){
-        pIter->base.pData = pIter->poslist.p;
-        pIter->base.nData = pIter->poslist.n;
-        return;
-      }
-      aCopy = p++;
-      iCurrent = *p++;
-      if( iCurrent & 0x80 ){
-        p--;
-        p += fts5GetVarint32(p, iCurrent);
-      }
-    }
-  }
-
-}
-
-/*
-** xSetOutputs callback used by detail=none tables.
-*/
-static void fts5IterSetOutputs_None(Fts5Iter *pIter, Fts5SegIter *pSeg){
-  assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_NONE );
-  pIter->base.iRowid = pSeg->iRowid;
-  pIter->base.nData = pSeg->nPos;
-}
-
-/*
-** xSetOutputs callback used by detail=full and detail=col tables when no
-** column filters are specified.
-*/
-static void fts5IterSetOutputs_Nocolset(Fts5Iter *pIter, Fts5SegIter *pSeg){
-  pIter->base.iRowid = pSeg->iRowid;
-  pIter->base.nData = pSeg->nPos;
-
-  assert( pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_NONE );
-  assert( pIter->pColset==0 );
-
-  if( pSeg->iLeafOffset+pSeg->nPos<=pSeg->pLeaf->szLeaf ){
-    /* All data is stored on the current page. Populate the output
-    ** variables to point into the body of the page object. */
-    pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
-  }else{
-    /* The data is distributed over two or more pages. Copy it into the
-    ** Fts5Iter.poslist buffer and then set the output pointer to point
-    ** to this buffer.  */
-    fts5BufferZero(&pIter->poslist);
-    fts5SegiterPoslist(pIter->pIndex, pSeg, 0, &pIter->poslist);
-    pIter->base.pData = pIter->poslist.p;
-  }
-}
-
-/*
-** xSetOutputs callback used when the Fts5Colset object has nCol==0 (match
-** against no columns at all).
-*/
-static void fts5IterSetOutputs_ZeroColset(Fts5Iter *pIter, Fts5SegIter *pSeg){
-  UNUSED_PARAM(pSeg);
-  pIter->base.nData = 0;
-}
-
-/*
-** xSetOutputs callback used by detail=col when there is a column filter
-** and there are 100 or more columns. Also called as a fallback from
-** fts5IterSetOutputs_Col100 if the column-list spans more than one page.
-*/
-static void fts5IterSetOutputs_Col(Fts5Iter *pIter, Fts5SegIter *pSeg){
-  fts5BufferZero(&pIter->poslist);
-  fts5SegiterPoslist(pIter->pIndex, pSeg, pIter->pColset, &pIter->poslist);
-  pIter->base.iRowid = pSeg->iRowid;
-  pIter->base.pData = pIter->poslist.p;
-  pIter->base.nData = pIter->poslist.n;
-}
-
-/*
-** xSetOutputs callback used when:
-**
-**   * detail=col,
-**   * there is a column filter, and
-**   * the table contains 100 or fewer columns.
-**
-** The last point is to ensure all column numbers are stored as
-** single-byte varints.
-*/
-static void fts5IterSetOutputs_Col100(Fts5Iter *pIter, Fts5SegIter *pSeg){
-
-  assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
-  assert( pIter->pColset );
-
-  if( pSeg->iLeafOffset+pSeg->nPos>pSeg->pLeaf->szLeaf ){
-    fts5IterSetOutputs_Col(pIter, pSeg);
-  }else{
-    u8 *a = (u8*)&pSeg->pLeaf->p[pSeg->iLeafOffset];
-    u8 *pEnd = (u8*)&a[pSeg->nPos];
-    int iPrev = 0;
-    int *aiCol = pIter->pColset->aiCol;
-    int *aiColEnd = &aiCol[pIter->pColset->nCol];
-
-    u8 *aOut = pIter->poslist.p;
-    int iPrevOut = 0;
-
-    pIter->base.iRowid = pSeg->iRowid;
-
-    while( a<pEnd ){
-      iPrev += (int)a++[0] - 2;
-      while( *aiCol<iPrev ){
-        aiCol++;
-        if( aiCol==aiColEnd ) goto setoutputs_col_out;
-      }
-      if( *aiCol==iPrev ){
-        *aOut++ = (u8)((iPrev - iPrevOut) + 2);
-        iPrevOut = iPrev;
-      }
-    }
-
-setoutputs_col_out:
-    pIter->base.pData = pIter->poslist.p;
-    pIter->base.nData = aOut - pIter->poslist.p;
-  }
-}
-
-/*
-** xSetOutputs callback used by detail=full when there is a column filter.
-*/
-static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
-  Fts5Colset *pColset = pIter->pColset;
-  pIter->base.iRowid = pSeg->iRowid;
-
-  assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_FULL );
-  assert( pColset );
-
-  if( pSeg->iLeafOffset+pSeg->nPos<=pSeg->pLeaf->szLeaf ){
-    /* All data is stored on the current page. Populate the output
-    ** variables to point into the body of the page object. */
-    const u8 *a = &pSeg->pLeaf->p[pSeg->iLeafOffset];
-    int *pRc = &pIter->pIndex->rc;
-    fts5BufferZero(&pIter->poslist);
-    fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, pIter);
-  }else{
-    /* The data is distributed over two or more pages. Copy it into the
-    ** Fts5Iter.poslist buffer and then set the output pointer to point
-    ** to this buffer.  */
-    fts5BufferZero(&pIter->poslist);
-    fts5SegiterPoslist(pIter->pIndex, pSeg, pColset, &pIter->poslist);
-    pIter->base.pData = pIter->poslist.p;
-    pIter->base.nData = pIter->poslist.n;
-  }
-}
-
-static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){
-  assert( pIter!=0 || (*pRc)!=SQLITE_OK );
-  if( *pRc==SQLITE_OK ){
-    Fts5Config *pConfig = pIter->pIndex->pConfig;
-    if( pConfig->eDetail==FTS5_DETAIL_NONE ){
-      pIter->xSetOutputs = fts5IterSetOutputs_None;
-    }
-
-    else if( pIter->pColset==0 ){
-      pIter->xSetOutputs = fts5IterSetOutputs_Nocolset;
-    }
-
-    else if( pIter->pColset->nCol==0 ){
-      pIter->xSetOutputs = fts5IterSetOutputs_ZeroColset;
-    }
-
-    else if( pConfig->eDetail==FTS5_DETAIL_FULL ){
-      pIter->xSetOutputs = fts5IterSetOutputs_Full;
-    }
-
-    else{
-      assert( pConfig->eDetail==FTS5_DETAIL_COLUMNS );
-      if( pConfig->nCol<=100 ){
-        pIter->xSetOutputs = fts5IterSetOutputs_Col100;
-        sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
-      }else{
-        pIter->xSetOutputs = fts5IterSetOutputs_Col;
-      }
-    }
-  }
-}
-
-/*
-** All the component segment-iterators of pIter have been set up. This
-** functions finishes setup for iterator pIter itself.
-*/
-static void fts5MultiIterFinishSetup(Fts5Index *p, Fts5Iter *pIter){
-  int iIter;
-  for(iIter=pIter->nSeg-1; iIter>0; iIter--){
-    int iEq;
-    if( (iEq = fts5MultiIterDoCompare(pIter, iIter)) ){
-      Fts5SegIter *pSeg = &pIter->aSeg[iEq];
-      if( p->rc==SQLITE_OK ) pSeg->xNext(p, pSeg, 0);
-      fts5MultiIterAdvanced(p, pIter, iEq, iIter);
-    }
-  }
-  fts5MultiIterSetEof(pIter);
-  fts5AssertMultiIterSetup(p, pIter);
-
-  if( (pIter->bSkipEmpty && fts5MultiIterIsEmpty(p, pIter))
-   || fts5MultiIterIsDeleted(pIter)
-  ){
-    fts5MultiIterNext(p, pIter, 0, 0);
-  }else if( pIter->base.bEof==0 ){
-    Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
-    pIter->xSetOutputs(pIter, pSeg);
-  }
-}
-
-/*
-** Allocate a new Fts5Iter object.
-**
-** The new object will be used to iterate through data in structure pStruct.
-** If iLevel is -ve, then all data in all segments is merged. Or, if iLevel
-** is zero or greater, data from the first nSegment segments on level iLevel
-** is merged.
-**
-** The iterator initially points to the first term/rowid entry in the
-** iterated data.
-*/
-static void fts5MultiIterNew(
-  Fts5Index *p,                   /* FTS5 backend to iterate within */
-  Fts5Structure *pStruct,         /* Structure of specific index */
-  int flags,                      /* FTS5INDEX_QUERY_XXX flags */
-  Fts5Colset *pColset,            /* Colset to filter on (or NULL) */
-  const u8 *pTerm, int nTerm,     /* Term to seek to (or NULL/0) */
-  int iLevel,                     /* Level to iterate (-1 for all) */
-  int nSegment,                   /* Number of segments to merge (iLevel>=0) */
-  Fts5Iter **ppOut                /* New object */
-){
-  int nSeg = 0;                   /* Number of segment-iters in use */
-  int iIter = 0;                  /* */
-  int iSeg;                       /* Used to iterate through segments */
-  Fts5StructureLevel *pLvl;
-  Fts5Iter *pNew;
-
-  assert( (pTerm==0 && nTerm==0) || iLevel<0 );
-
-  /* Allocate space for the new multi-seg-iterator. */
-  if( p->rc==SQLITE_OK ){
-    if( iLevel<0 ){
-      assert( pStruct->nSegment==fts5StructureCountSegments(pStruct) );
-      nSeg = pStruct->nSegment;
-      nSeg += (p->pHash && 0==(flags & FTS5INDEX_QUERY_SKIPHASH));
-    }else{
-      nSeg = MIN(pStruct->aLevel[iLevel].nSeg, nSegment);
-    }
-  }
-  *ppOut = pNew = fts5MultiIterAlloc(p, nSeg);
-  if( pNew==0 ){
-    assert( p->rc!=SQLITE_OK );
-    goto fts5MultiIterNew_post_check;
-  }
-  pNew->bRev = (0!=(flags & FTS5INDEX_QUERY_DESC));
-  pNew->bSkipEmpty = (0!=(flags & FTS5INDEX_QUERY_SKIPEMPTY));
-  pNew->pColset = pColset;
-  if( (flags & FTS5INDEX_QUERY_NOOUTPUT)==0 ){
-    fts5IterSetOutputCb(&p->rc, pNew);
-  }
-
-  /* Initialize each of the component segment iterators. */
-  if( p->rc==SQLITE_OK ){
-    if( iLevel<0 ){
-      Fts5StructureLevel *pEnd = &pStruct->aLevel[pStruct->nLevel];
-      if( p->pHash && 0==(flags & FTS5INDEX_QUERY_SKIPHASH) ){
-        /* Add a segment iterator for the current contents of the hash table. */
-        Fts5SegIter *pIter = &pNew->aSeg[iIter++];
-        fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
-      }
-      for(pLvl=&pStruct->aLevel[0]; pLvl<pEnd; pLvl++){
-        for(iSeg=pLvl->nSeg-1; iSeg>=0; iSeg--){
-          Fts5StructureSegment *pSeg = &pLvl->aSeg[iSeg];
-          Fts5SegIter *pIter = &pNew->aSeg[iIter++];
-          if( pTerm==0 ){
-            fts5SegIterInit(p, pSeg, pIter);
-          }else{
-            fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
-          }
-        }
-      }
-    }else{
-      pLvl = &pStruct->aLevel[iLevel];
-      for(iSeg=nSeg-1; iSeg>=0; iSeg--){
-        fts5SegIterInit(p, &pLvl->aSeg[iSeg], &pNew->aSeg[iIter++]);
-      }
-    }
-    assert( iIter==nSeg );
-  }
-
-  /* If the above was successful, each component iterator now points
-  ** to the first entry in its segment. In this case initialize the
-  ** aFirst[] array. Or, if an error has occurred, free the iterator
-  ** object and set the output variable to NULL.  */
-  if( p->rc==SQLITE_OK ){
-    fts5MultiIterFinishSetup(p, pNew);
-  }else{
-    fts5MultiIterFree(pNew);
-    *ppOut = 0;
-  }
-
-fts5MultiIterNew_post_check:
-  assert( (*ppOut)!=0 || p->rc!=SQLITE_OK );
-  return;
-}
-
-/*
-** Create an Fts5Iter that iterates through the doclist provided
-** as the second argument.
-*/
-static void fts5MultiIterNew2(
-  Fts5Index *p,                   /* FTS5 backend to iterate within */
-  Fts5Data *pData,                /* Doclist to iterate through */
-  int bDesc,                      /* True for descending rowid order */
-  Fts5Iter **ppOut                /* New object */
-){
-  Fts5Iter *pNew;
-  pNew = fts5MultiIterAlloc(p, 2);
-  if( pNew ){
-    Fts5SegIter *pIter = &pNew->aSeg[1];
-    pIter->flags = FTS5_SEGITER_ONETERM;
-    if( pData->szLeaf>0 ){
-      pIter->pLeaf = pData;
-      pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
-      pIter->iEndofDoclist = pData->nn;
-      pNew->aFirst[1].iFirst = 1;
-      if( bDesc ){
-        pNew->bRev = 1;
-        pIter->flags |= FTS5_SEGITER_REVERSE;
-        fts5SegIterReverseInitPage(p, pIter);
-      }else{
-        fts5SegIterLoadNPos(p, pIter);
-      }
-      pData = 0;
-    }else{
-      pNew->base.bEof = 1;
-    }
-    fts5SegIterSetNext(p, pIter);
-
-    *ppOut = pNew;
-  }
-
-  fts5DataRelease(pData);
-}
-
-/*
-** Return true if the iterator is at EOF or if an error has occurred.
-** False otherwise.
-*/
-static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){
-  assert( pIter!=0 || p->rc!=SQLITE_OK );
-  assert( p->rc!=SQLITE_OK
-      || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof
-  );
-  return (p->rc || pIter->base.bEof);
-}
-
-/*
-** Return the rowid of the entry that the iterator currently points
-** to. If the iterator points to EOF when this function is called the
-** results are undefined.
-*/
-static i64 fts5MultiIterRowid(Fts5Iter *pIter){
-  assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
-  return pIter->aSeg[ pIter->aFirst[1].iFirst ].iRowid;
-}
-
-/*
-** Move the iterator to the next entry at or following iMatch.
-*/
-static void fts5MultiIterNextFrom(
-  Fts5Index *p,
-  Fts5Iter *pIter,
-  i64 iMatch
-){
-  while( 1 ){
-    i64 iRowid;
-    fts5MultiIterNext(p, pIter, 1, iMatch);
-    if( fts5MultiIterEof(p, pIter) ) break;
-    iRowid = fts5MultiIterRowid(pIter);
-    if( pIter->bRev==0 && iRowid>=iMatch ) break;
-    if( pIter->bRev!=0 && iRowid<=iMatch ) break;
-  }
-}
-
-/*
-** Return a pointer to a buffer containing the term associated with the
-** entry that the iterator currently points to.
-*/
-static const u8 *fts5MultiIterTerm(Fts5Iter *pIter, int *pn){
-  Fts5SegIter *p = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
-  *pn = p->term.n;
-  return p->term.p;
-}
-
-/*
-** Allocate a new segment-id for the structure pStruct. The new segment
-** id must be between 1 and 65335 inclusive, and must not be used by
-** any currently existing segment. If a free segment id cannot be found,
-** SQLITE_FULL is returned.
-**
-** If an error has already occurred, this function is a no-op. 0 is
-** returned in this case.
-*/
-static int fts5AllocateSegid(Fts5Index *p, Fts5Structure *pStruct){
-  int iSegid = 0;
-
-  if( p->rc==SQLITE_OK ){
-    if( pStruct->nSegment>=FTS5_MAX_SEGMENT ){
-      p->rc = SQLITE_FULL;
-    }else{
-      /* FTS5_MAX_SEGMENT is currently defined as 2000. So the following
-      ** array is 63 elements, or 252 bytes, in size.  */
-      u32 aUsed[(FTS5_MAX_SEGMENT+31) / 32];
-      int iLvl, iSeg;
-      int i;
-      u32 mask;
-      memset(aUsed, 0, sizeof(aUsed));
-      for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
-        for(iSeg=0; iSeg<pStruct->aLevel[iLvl].nSeg; iSeg++){
-          int iId = pStruct->aLevel[iLvl].aSeg[iSeg].iSegid;
-          if( iId<=FTS5_MAX_SEGMENT && iId>0 ){
-            aUsed[(iId-1) / 32] |= (u32)1 << ((iId-1) % 32);
-          }
-        }
-      }
-
-      for(i=0; aUsed[i]==0xFFFFFFFF; i++);
-      mask = aUsed[i];
-      for(iSegid=0; mask & ((u32)1 << iSegid); iSegid++);
-      iSegid += 1 + i*32;
-
-#ifdef SQLITE_DEBUG
-      for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
-        for(iSeg=0; iSeg<pStruct->aLevel[iLvl].nSeg; iSeg++){
-          assert_nc( iSegid!=pStruct->aLevel[iLvl].aSeg[iSeg].iSegid );
-        }
-      }
-      assert_nc( iSegid>0 && iSegid<=FTS5_MAX_SEGMENT );
-
-      {
-        sqlite3_stmt *pIdxSelect = fts5IdxSelectStmt(p);
-        if( p->rc==SQLITE_OK ){
-          u8 aBlob[2] = {0xff, 0xff};
-          sqlite3_bind_int(pIdxSelect, 1, iSegid);
-          sqlite3_bind_blob(pIdxSelect, 2, aBlob, 2, SQLITE_STATIC);
-          assert_nc( sqlite3_step(pIdxSelect)!=SQLITE_ROW );
-          p->rc = sqlite3_reset(pIdxSelect);
-          sqlite3_bind_null(pIdxSelect, 2);
-        }
-      }
-#endif
-    }
-  }
-
-  return iSegid;
-}
-
-/*
-** Discard all data currently cached in the hash-tables.
-*/
-static void fts5IndexDiscardData(Fts5Index *p){
-  assert( p->pHash || p->nPendingData==0 );
-  if( p->pHash ){
-    sqlite3Fts5HashClear(p->pHash);
-    p->nPendingData = 0;
-    p->nPendingRow = 0;
-    p->flushRc = SQLITE_OK;
-  }
-  p->nContentlessDelete = 0;
-}
-
-/*
-** Return the size of the prefix, in bytes, that buffer
-** (pNew/<length-unknown>) shares with buffer (pOld/nOld).
-**
-** Buffer (pNew/<length-unknown>) is guaranteed to be greater
-** than buffer (pOld/nOld).
-*/
-static int fts5PrefixCompress(int nOld, const u8 *pOld, const u8 *pNew){
-  int i;
-  for(i=0; i<nOld; i++){
-    if( pOld[i]!=pNew[i] ) break;
-  }
-  return i;
-}
-
-static void fts5WriteDlidxClear(
-  Fts5Index *p,
-  Fts5SegWriter *pWriter,
-  int bFlush                      /* If true, write dlidx to disk */
-){
-  int i;
-  assert( bFlush==0 || (pWriter->nDlidx>0 && pWriter->aDlidx[0].buf.n>0) );
-  for(i=0; i<pWriter->nDlidx; i++){
-    Fts5DlidxWriter *pDlidx = &pWriter->aDlidx[i];
-    if( pDlidx->buf.n==0 ) break;
-    if( bFlush ){
-      assert( pDlidx->pgno!=0 );
-      fts5DataWrite(p,
-          FTS5_DLIDX_ROWID(pWriter->iSegid, i, pDlidx->pgno),
-          pDlidx->buf.p, pDlidx->buf.n
-      );
-    }
-    sqlite3Fts5BufferZero(&pDlidx->buf);
-    pDlidx->bPrevValid = 0;
-  }
-}
-
-/*
-** Grow the pWriter->aDlidx[] array to at least nLvl elements in size.
-** Any new array elements are zeroed before returning.
-*/
-static int fts5WriteDlidxGrow(
-  Fts5Index *p,
-  Fts5SegWriter *pWriter,
-  int nLvl
-){
-  if( p->rc==SQLITE_OK && nLvl>=pWriter->nDlidx ){
-    Fts5DlidxWriter *aDlidx = (Fts5DlidxWriter*)sqlite3_realloc64(
-        pWriter->aDlidx, sizeof(Fts5DlidxWriter) * nLvl
-    );
-    if( aDlidx==0 ){
-      p->rc = SQLITE_NOMEM;
-    }else{
-      size_t nByte = sizeof(Fts5DlidxWriter) * (nLvl - pWriter->nDlidx);
-      memset(&aDlidx[pWriter->nDlidx], 0, nByte);
-      pWriter->aDlidx = aDlidx;
-      pWriter->nDlidx = nLvl;
-    }
-  }
-  return p->rc;
-}
-
-/*
-** If the current doclist-index accumulating in pWriter->aDlidx[] is large
-** enough, flush it to disk and return 1. Otherwise discard it and return
-** zero.
-*/
-static int fts5WriteFlushDlidx(Fts5Index *p, Fts5SegWriter *pWriter){
-  int bFlag = 0;
-
-  /* If there were FTS5_MIN_DLIDX_SIZE or more empty leaf pages written
-  ** to the database, also write the doclist-index to disk.  */
-  if( pWriter->aDlidx[0].buf.n>0 && pWriter->nEmpty>=FTS5_MIN_DLIDX_SIZE ){
-    bFlag = 1;
-  }
-  fts5WriteDlidxClear(p, pWriter, bFlag);
-  pWriter->nEmpty = 0;
-  return bFlag;
-}
-
-/*
-** This function is called whenever processing of the doclist for the
-** last term on leaf page (pWriter->iBtPage) is completed.
-**
-** The doclist-index for that term is currently stored in-memory within the
-** Fts5SegWriter.aDlidx[] array. If it is large enough, this function
-** writes it out to disk. Or, if it is too small to bother with, discards
-** it.
-**
-** Fts5SegWriter.btterm currently contains the first term on page iBtPage.
-*/
-static void fts5WriteFlushBtree(Fts5Index *p, Fts5SegWriter *pWriter){
-  int bFlag;
-
-  assert( pWriter->iBtPage || pWriter->nEmpty==0 );
-  if( pWriter->iBtPage==0 ) return;
-  bFlag = fts5WriteFlushDlidx(p, pWriter);
-
-  if( p->rc==SQLITE_OK ){
-    const char *z = (pWriter->btterm.n>0?(const char*)pWriter->btterm.p:"");
-    /* The following was already done in fts5WriteInit(): */
-    /* sqlite3_bind_int(p->pIdxWriter, 1, pWriter->iSegid); */
-    sqlite3_bind_blob(p->pIdxWriter, 2, z, pWriter->btterm.n, SQLITE_STATIC);
-    sqlite3_bind_int64(p->pIdxWriter, 3, bFlag + ((i64)pWriter->iBtPage<<1));
-    sqlite3_step(p->pIdxWriter);
-    p->rc = sqlite3_reset(p->pIdxWriter);
-    sqlite3_bind_null(p->pIdxWriter, 2);
-  }
-  pWriter->iBtPage = 0;
-}
-
-/*
-** This is called once for each leaf page except the first that contains
-** at least one term. Argument (nTerm/pTerm) is the split-key - a term that
-** is larger than all terms written to earlier leaves, and equal to or
-** smaller than the first term on the new leaf.
-**
-** If an error occurs, an error code is left in Fts5Index.rc. If an error
-** has already occurred when this function is called, it is a no-op.
-*/
-static void fts5WriteBtreeTerm(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5SegWriter *pWriter,         /* Writer object */
-  int nTerm, const u8 *pTerm      /* First term on new page */
-){
-  fts5WriteFlushBtree(p, pWriter);
-  if( p->rc==SQLITE_OK ){
-    fts5BufferSet(&p->rc, &pWriter->btterm, nTerm, pTerm);
-    pWriter->iBtPage = pWriter->writer.pgno;
-  }
-}
-
-/*
-** This function is called when flushing a leaf page that contains no
-** terms at all to disk.
-*/
-static void fts5WriteBtreeNoTerm(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5SegWriter *pWriter          /* Writer object */
-){
-  /* If there were no rowids on the leaf page either and the doclist-index
-  ** has already been started, append an 0x00 byte to it.  */
-  if( pWriter->bFirstRowidInPage && pWriter->aDlidx[0].buf.n>0 ){
-    Fts5DlidxWriter *pDlidx = &pWriter->aDlidx[0];
-    assert( pDlidx->bPrevValid );
-    sqlite3Fts5BufferAppendVarint(&p->rc, &pDlidx->buf, 0);
-  }
-
-  /* Increment the "number of sequential leaves without a term" counter. */
-  pWriter->nEmpty++;
-}
-
-static i64 fts5DlidxExtractFirstRowid(Fts5Buffer *pBuf){
-  i64 iRowid;
-  int iOff;
-
-  iOff = 1 + fts5GetVarint(&pBuf->p[1], (u64*)&iRowid);
-  fts5GetVarint(&pBuf->p[iOff], (u64*)&iRowid);
-  return iRowid;
-}
-
-/*
-** Rowid iRowid has just been appended to the current leaf page. It is the
-** first on the page. This function appends an appropriate entry to the current
-** doclist-index.
-*/
-static void fts5WriteDlidxAppend(
-  Fts5Index *p,
-  Fts5SegWriter *pWriter,
-  i64 iRowid
-){
-  int i;
-  int bDone = 0;
-
-  for(i=0; p->rc==SQLITE_OK && bDone==0; i++){
-    i64 iVal;
-    Fts5DlidxWriter *pDlidx = &pWriter->aDlidx[i];
-
-    if( pDlidx->buf.n>=p->pConfig->pgsz ){
-      /* The current doclist-index page is full. Write it to disk and push
-      ** a copy of iRowid (which will become the first rowid on the next
-      ** doclist-index leaf page) up into the next level of the b-tree
-      ** hierarchy. If the node being flushed is currently the root node,
-      ** also push its first rowid upwards. */
-      pDlidx->buf.p[0] = 0x01;    /* Not the root node */
-      fts5DataWrite(p,
-          FTS5_DLIDX_ROWID(pWriter->iSegid, i, pDlidx->pgno),
-          pDlidx->buf.p, pDlidx->buf.n
-      );
-      fts5WriteDlidxGrow(p, pWriter, i+2);
-      pDlidx = &pWriter->aDlidx[i];
-      if( p->rc==SQLITE_OK && pDlidx[1].buf.n==0 ){
-        i64 iFirst = fts5DlidxExtractFirstRowid(&pDlidx->buf);
-
-        /* This was the root node. Push its first rowid up to the new root. */
-        pDlidx[1].pgno = pDlidx->pgno;
-        sqlite3Fts5BufferAppendVarint(&p->rc, &pDlidx[1].buf, 0);
-        sqlite3Fts5BufferAppendVarint(&p->rc, &pDlidx[1].buf, pDlidx->pgno);
-        sqlite3Fts5BufferAppendVarint(&p->rc, &pDlidx[1].buf, iFirst);
-        pDlidx[1].bPrevValid = 1;
-        pDlidx[1].iPrev = iFirst;
-      }
-
-      sqlite3Fts5BufferZero(&pDlidx->buf);
-      pDlidx->bPrevValid = 0;
-      pDlidx->pgno++;
-    }else{
-      bDone = 1;
-    }
-
-    if( pDlidx->bPrevValid ){
-      iVal = (u64)iRowid - (u64)pDlidx->iPrev;
-    }else{
-      i64 iPgno = (i==0 ? pWriter->writer.pgno : pDlidx[-1].pgno);
-      assert( pDlidx->buf.n==0 );
-      sqlite3Fts5BufferAppendVarint(&p->rc, &pDlidx->buf, !bDone);
-      sqlite3Fts5BufferAppendVarint(&p->rc, &pDlidx->buf, iPgno);
-      iVal = iRowid;
-    }
-
-    sqlite3Fts5BufferAppendVarint(&p->rc, &pDlidx->buf, iVal);
-    pDlidx->bPrevValid = 1;
-    pDlidx->iPrev = iRowid;
-  }
-}
-
-static void fts5WriteFlushLeaf(Fts5Index *p, Fts5SegWriter *pWriter){
-  static const u8 zero[] = { 0x00, 0x00, 0x00, 0x00 };
-  Fts5PageWriter *pPage = &pWriter->writer;
-  i64 iRowid;
-
-  assert( (pPage->pgidx.n==0)==(pWriter->bFirstTermInPage) );
-
-  /* Set the szLeaf header field. */
-  assert( 0==fts5GetU16(&pPage->buf.p[2]) );
-  fts5PutU16(&pPage->buf.p[2], (u16)pPage->buf.n);
-
-  if( pWriter->bFirstTermInPage ){
-    /* No term was written to this page. */
-    assert( pPage->pgidx.n==0 );
-    fts5WriteBtreeNoTerm(p, pWriter);
-  }else{
-    /* Append the pgidx to the page buffer. Set the szLeaf header field. */
-    fts5BufferAppendBlob(&p->rc, &pPage->buf, pPage->pgidx.n, pPage->pgidx.p);
-  }
-
-  /* Write the page out to disk */
-  iRowid = FTS5_SEGMENT_ROWID(pWriter->iSegid, pPage->pgno);
-  fts5DataWrite(p, iRowid, pPage->buf.p, pPage->buf.n);
-
-  /* Initialize the next page. */
-  fts5BufferZero(&pPage->buf);
-  fts5BufferZero(&pPage->pgidx);
-  fts5BufferAppendBlob(&p->rc, &pPage->buf, 4, zero);
-  pPage->iPrevPgidx = 0;
-  pPage->pgno++;
-
-  /* Increase the leaves written counter */
-  pWriter->nLeafWritten++;
-
-  /* The new leaf holds no terms or rowids */
-  pWriter->bFirstTermInPage = 1;
-  pWriter->bFirstRowidInPage = 1;
-}
-
-/*
-** Append term pTerm/nTerm to the segment being written by the writer passed
-** as the second argument.
-**
-** If an error occurs, set the Fts5Index.rc error code. If an error has
-** already occurred, this function is a no-op.
-*/
-static void fts5WriteAppendTerm(
-  Fts5Index *p,
-  Fts5SegWriter *pWriter,
-  int nTerm, const u8 *pTerm
-){
-  int nPrefix;                    /* Bytes of prefix compression for term */
-  Fts5PageWriter *pPage = &pWriter->writer;
-  Fts5Buffer *pPgidx = &pWriter->writer.pgidx;
-  int nMin = MIN(pPage->term.n, nTerm);
-
-  assert( p->rc==SQLITE_OK );
-  assert( pPage->buf.n>=4 );
-  assert( pPage->buf.n>4 || pWriter->bFirstTermInPage );
-
-  /* If the current leaf page is full, flush it to disk. */
-  if( (pPage->buf.n + pPgidx->n + nTerm + 2)>=p->pConfig->pgsz ){
-    if( pPage->buf.n>4 ){
-      fts5WriteFlushLeaf(p, pWriter);
-      if( p->rc!=SQLITE_OK ) return;
-    }
-    fts5BufferGrow(&p->rc, &pPage->buf, nTerm+FTS5_DATA_PADDING);
-  }
-
-  /* TODO1: Updating pgidx here. */
-  pPgidx->n += sqlite3Fts5PutVarint(
-      &pPgidx->p[pPgidx->n], pPage->buf.n - pPage->iPrevPgidx
-  );
-  pPage->iPrevPgidx = pPage->buf.n;
-#if 0
-  fts5PutU16(&pPgidx->p[pPgidx->n], pPage->buf.n);
-  pPgidx->n += 2;
-#endif
-
-  if( pWriter->bFirstTermInPage ){
-    nPrefix = 0;
-    if( pPage->pgno!=1 ){
-      /* This is the first term on a leaf that is not the leftmost leaf in
-      ** the segment b-tree. In this case it is necessary to add a term to
-      ** the b-tree hierarchy that is (a) larger than the largest term
-      ** already written to the segment and (b) smaller than or equal to
-      ** this term. In other words, a prefix of (pTerm/nTerm) that is one
-      ** byte longer than the longest prefix (pTerm/nTerm) shares with the
-      ** previous term.
-      **
-      ** Usually, the previous term is available in pPage->term. The exception
-      ** is if this is the first term written in an incremental-merge step.
-      ** In this case the previous term is not available, so just write a
-      ** copy of (pTerm/nTerm) into the parent node. This is slightly
-      ** inefficient, but still correct.  */
-      int n = nTerm;
-      if( pPage->term.n ){
-        n = 1 + fts5PrefixCompress(nMin, pPage->term.p, pTerm);
-      }
-      fts5WriteBtreeTerm(p, pWriter, n, pTerm);
-      if( p->rc!=SQLITE_OK ) return;
-      pPage = &pWriter->writer;
-    }
-  }else{
-    nPrefix = fts5PrefixCompress(nMin, pPage->term.p, pTerm);
-    fts5BufferAppendVarint(&p->rc, &pPage->buf, nPrefix);
-  }
-
-  /* Append the number of bytes of new data, then the term data itself
-  ** to the page. */
-  fts5BufferAppendVarint(&p->rc, &pPage->buf, nTerm - nPrefix);
-  fts5BufferAppendBlob(&p->rc, &pPage->buf, nTerm - nPrefix, &pTerm[nPrefix]);
-
-  /* Update the Fts5PageWriter.term field. */
-  fts5BufferSet(&p->rc, &pPage->term, nTerm, pTerm);
-  pWriter->bFirstTermInPage = 0;
-
-  pWriter->bFirstRowidInPage = 0;
-  pWriter->bFirstRowidInDoclist = 1;
-
-  assert( p->rc || (pWriter->nDlidx>0 && pWriter->aDlidx[0].buf.n==0) );
-  pWriter->aDlidx[0].pgno = pPage->pgno;
-}
-
-/*
-** Append a rowid and position-list size field to the writers output.
-*/
-static void fts5WriteAppendRowid(
-  Fts5Index *p,
-  Fts5SegWriter *pWriter,
-  i64 iRowid
-){
-  if( p->rc==SQLITE_OK ){
-    Fts5PageWriter *pPage = &pWriter->writer;
-
-    if( (pPage->buf.n + pPage->pgidx.n)>=p->pConfig->pgsz ){
-      fts5WriteFlushLeaf(p, pWriter);
-    }
-
-    /* If this is to be the first rowid written to the page, set the
-    ** rowid-pointer in the page-header. Also append a value to the dlidx
-    ** buffer, in case a doclist-index is required.  */
-    if( pWriter->bFirstRowidInPage ){
-      fts5PutU16(pPage->buf.p, (u16)pPage->buf.n);
-      fts5WriteDlidxAppend(p, pWriter, iRowid);
-    }
-
-    /* Write the rowid. */
-    if( pWriter->bFirstRowidInDoclist || pWriter->bFirstRowidInPage ){
-      fts5BufferAppendVarint(&p->rc, &pPage->buf, iRowid);
-    }else{
-      assert_nc( p->rc || iRowid>pWriter->iPrevRowid );
-      fts5BufferAppendVarint(&p->rc, &pPage->buf,
-          (u64)iRowid - (u64)pWriter->iPrevRowid
-      );
-    }
-    pWriter->iPrevRowid = iRowid;
-    pWriter->bFirstRowidInDoclist = 0;
-    pWriter->bFirstRowidInPage = 0;
-  }
-}
-
-static void fts5WriteAppendPoslistData(
-  Fts5Index *p,
-  Fts5SegWriter *pWriter,
-  const u8 *aData,
-  int nData
-){
-  Fts5PageWriter *pPage = &pWriter->writer;
-  const u8 *a = aData;
-  int n = nData;
-
-  assert( p->pConfig->pgsz>0 || p->rc!=SQLITE_OK );
-  while( p->rc==SQLITE_OK
-     && (pPage->buf.n + pPage->pgidx.n + n)>=p->pConfig->pgsz
-  ){
-    int nReq = p->pConfig->pgsz - pPage->buf.n - pPage->pgidx.n;
-    int nCopy = 0;
-    while( nCopy<nReq ){
-      i64 dummy;
-      nCopy += fts5GetVarint(&a[nCopy], (u64*)&dummy);
-    }
-    fts5BufferAppendBlob(&p->rc, &pPage->buf, nCopy, a);
-    a += nCopy;
-    n -= nCopy;
-    fts5WriteFlushLeaf(p, pWriter);
-  }
-  if( n>0 ){
-    fts5BufferAppendBlob(&p->rc, &pPage->buf, n, a);
-  }
-}
-
-/*
-** Flush any data cached by the writer object to the database. Free any
-** allocations associated with the writer.
-*/
-static void fts5WriteFinish(
-  Fts5Index *p,
-  Fts5SegWriter *pWriter,         /* Writer object */
-  int *pnLeaf                     /* OUT: Number of leaf pages in b-tree */
-){
-  int i;
-  Fts5PageWriter *pLeaf = &pWriter->writer;
-  if( p->rc==SQLITE_OK ){
-    assert( pLeaf->pgno>=1 );
-    if( pLeaf->buf.n>4 ){
-      fts5WriteFlushLeaf(p, pWriter);
-    }
-    *pnLeaf = pLeaf->pgno-1;
-    if( pLeaf->pgno>1 ){
-      fts5WriteFlushBtree(p, pWriter);
-    }
-  }
-  fts5BufferFree(&pLeaf->term);
-  fts5BufferFree(&pLeaf->buf);
-  fts5BufferFree(&pLeaf->pgidx);
-  fts5BufferFree(&pWriter->btterm);
-
-  for(i=0; i<pWriter->nDlidx; i++){
-    sqlite3Fts5BufferFree(&pWriter->aDlidx[i].buf);
-  }
-  sqlite3_free(pWriter->aDlidx);
-}
-
-static void fts5WriteInit(
-  Fts5Index *p,
-  Fts5SegWriter *pWriter,
-  int iSegid
-){
-  const int nBuffer = p->pConfig->pgsz + FTS5_DATA_PADDING;
-
-  memset(pWriter, 0, sizeof(Fts5SegWriter));
-  pWriter->iSegid = iSegid;
-
-  fts5WriteDlidxGrow(p, pWriter, 1);
-  pWriter->writer.pgno = 1;
-  pWriter->bFirstTermInPage = 1;
-  pWriter->iBtPage = 1;
-
-  assert( pWriter->writer.buf.n==0 );
-  assert( pWriter->writer.pgidx.n==0 );
-
-  /* Grow the two buffers to pgsz + padding bytes in size. */
-  sqlite3Fts5BufferSize(&p->rc, &pWriter->writer.pgidx, nBuffer);
-  sqlite3Fts5BufferSize(&p->rc, &pWriter->writer.buf, nBuffer);
-
-  if( p->pIdxWriter==0 ){
-    Fts5Config *pConfig = p->pConfig;
-    fts5IndexPrepareStmt(p, &p->pIdxWriter, sqlite3_mprintf(
-          "INSERT INTO '%q'.'%q_idx'(segid,term,pgno) VALUES(?,?,?)",
-          pConfig->zDb, pConfig->zName
-    ));
-  }
-
-  if( p->rc==SQLITE_OK ){
-    /* Initialize the 4-byte leaf-page header to 0x00. */
-    memset(pWriter->writer.buf.p, 0, 4);
-    pWriter->writer.buf.n = 4;
-
-    /* Bind the current output segment id to the index-writer. This is an
-    ** optimization over binding the same value over and over as rows are
-    ** inserted into %_idx by the current writer.  */
-    sqlite3_bind_int(p->pIdxWriter, 1, pWriter->iSegid);
-  }
-}
-
-/*
-** Iterator pIter was used to iterate through the input segments of on an
-** incremental merge operation. This function is called if the incremental
-** merge step has finished but the input has not been completely exhausted.
-*/
-static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
-  int i;
-  Fts5Buffer buf;
-  memset(&buf, 0, sizeof(Fts5Buffer));
-  for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
-    Fts5SegIter *pSeg = &pIter->aSeg[i];
-    if( pSeg->pSeg==0 ){
-      /* no-op */
-    }else if( pSeg->pLeaf==0 ){
-      /* All keys from this input segment have been transfered to the output.
-      ** Set both the first and last page-numbers to 0 to indicate that the
-      ** segment is now empty. */
-      pSeg->pSeg->pgnoLast = 0;
-      pSeg->pSeg->pgnoFirst = 0;
-    }else{
-      int iOff = pSeg->iTermLeafOffset;     /* Offset on new first leaf page */
-      i64 iLeafRowid;
-      Fts5Data *pData;
-      int iId = pSeg->pSeg->iSegid;
-      u8 aHdr[4] = {0x00, 0x00, 0x00, 0x00};
-
-      iLeafRowid = FTS5_SEGMENT_ROWID(iId, pSeg->iTermLeafPgno);
-      pData = fts5LeafRead(p, iLeafRowid);
-      if( pData ){
-        if( iOff>pData->szLeaf ){
-          /* This can occur if the pages that the segments occupy overlap - if
-          ** a single page has been assigned to more than one segment. In
-          ** this case a prior iteration of this loop may have corrupted the
-          ** segment currently being trimmed.  */
-          FTS5_CORRUPT_ROWID(p, iLeafRowid);
-        }else{
-          fts5BufferZero(&buf);
-          fts5BufferGrow(&p->rc, &buf, pData->nn);
-          fts5BufferAppendBlob(&p->rc, &buf, sizeof(aHdr), aHdr);
-          fts5BufferAppendVarint(&p->rc, &buf, pSeg->term.n);
-          fts5BufferAppendBlob(&p->rc, &buf, pSeg->term.n, pSeg->term.p);
-          fts5BufferAppendBlob(&p->rc, &buf,pData->szLeaf-iOff,&pData->p[iOff]);
-          if( p->rc==SQLITE_OK ){
-            /* Set the szLeaf field */
-            fts5PutU16(&buf.p[2], (u16)buf.n);
-          }
-
-          /* Set up the new page-index array */
-          fts5BufferAppendVarint(&p->rc, &buf, 4);
-          if( pSeg->iLeafPgno==pSeg->iTermLeafPgno
-           && pSeg->iEndofDoclist<pData->szLeaf
-           && pSeg->iPgidxOff<=pData->nn
-          ){
-            int nDiff = pData->szLeaf - pSeg->iEndofDoclist;
-            fts5BufferAppendVarint(&p->rc, &buf, buf.n - 1 - nDiff - 4);
-            fts5BufferAppendBlob(&p->rc, &buf,
-                pData->nn - pSeg->iPgidxOff, &pData->p[pSeg->iPgidxOff]
-            );
-          }
-
-          pSeg->pSeg->pgnoFirst = pSeg->iTermLeafPgno;
-          fts5DataDelete(p, FTS5_SEGMENT_ROWID(iId, 1), iLeafRowid);
-          fts5DataWrite(p, iLeafRowid, buf.p, buf.n);
-        }
-        fts5DataRelease(pData);
-      }
-    }
-  }
-  fts5BufferFree(&buf);
-}
-
-static void fts5MergeChunkCallback(
-  Fts5Index *p,
-  void *pCtx,
-  const u8 *pChunk, int nChunk
-){
-  Fts5SegWriter *pWriter = (Fts5SegWriter*)pCtx;
-  fts5WriteAppendPoslistData(p, pWriter, pChunk, nChunk);
-}
-
-/*
-**
-*/
-static void fts5IndexMergeLevel(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5Structure **ppStruct,       /* IN/OUT: Stucture of index */
-  int iLvl,                       /* Level to read input from */
-  int *pnRem                      /* Write up to this many output leaves */
-){
-  Fts5Structure *pStruct = *ppStruct;
-  Fts5StructureLevel *pLvl = &pStruct->aLevel[iLvl];
-  Fts5StructureLevel *pLvlOut;
-  Fts5Iter *pIter = 0;       /* Iterator to read input data */
-  int nRem = pnRem ? *pnRem : 0;  /* Output leaf pages left to write */
-  int nInput;                     /* Number of input segments */
-  Fts5SegWriter writer;           /* Writer object */
-  Fts5StructureSegment *pSeg;     /* Output segment */
-  Fts5Buffer term;
-  int bOldest;                    /* True if the output segment is the oldest */
-  int eDetail = p->pConfig->eDetail;
-  const int flags = FTS5INDEX_QUERY_NOOUTPUT;
-  int bTermWritten = 0;           /* True if current term already output */
-
-  assert( iLvl<pStruct->nLevel );
-  assert( pLvl->nMerge<=pLvl->nSeg );
-
-  memset(&writer, 0, sizeof(Fts5SegWriter));
-  memset(&term, 0, sizeof(Fts5Buffer));
-  if( pLvl->nMerge ){
-    pLvlOut = &pStruct->aLevel[iLvl+1];
-    assert( pLvlOut->nSeg>0 );
-    nInput = pLvl->nMerge;
-    pSeg = &pLvlOut->aSeg[pLvlOut->nSeg-1];
-
-    fts5WriteInit(p, &writer, pSeg->iSegid);
-    writer.writer.pgno = pSeg->pgnoLast+1;
-    writer.iBtPage = 0;
-  }else{
-    int iSegid = fts5AllocateSegid(p, pStruct);
-
-    /* Extend the Fts5Structure object as required to ensure the output
-    ** segment exists. */
-    if( iLvl==pStruct->nLevel-1 ){
-      fts5StructureAddLevel(&p->rc, ppStruct);
-      pStruct = *ppStruct;
-    }
-    fts5StructureExtendLevel(&p->rc, pStruct, iLvl+1, 1, 0);
-    if( p->rc ) return;
-    pLvl = &pStruct->aLevel[iLvl];
-    pLvlOut = &pStruct->aLevel[iLvl+1];
-
-    fts5WriteInit(p, &writer, iSegid);
-
-    /* Add the new segment to the output level */
-    pSeg = &pLvlOut->aSeg[pLvlOut->nSeg];
-    pLvlOut->nSeg++;
-    pSeg->pgnoFirst = 1;
-    pSeg->iSegid = iSegid;
-    pStruct->nSegment++;
-
-    /* Read input from all segments in the input level */
-    nInput = pLvl->nSeg;
-
-    /* Set the range of origins that will go into the output segment. */
-    if( pStruct->nOriginCntr>0 ){
-      pSeg->iOrigin1 = pLvl->aSeg[0].iOrigin1;
-      pSeg->iOrigin2 = pLvl->aSeg[pLvl->nSeg-1].iOrigin2;
-    }
-  }
-  bOldest = (pLvlOut->nSeg==1 && pStruct->nLevel==iLvl+2);
-
-  assert( iLvl>=0 );
-  for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, iLvl, nInput, &pIter);
-      fts5MultiIterEof(p, pIter)==0;
-      fts5MultiIterNext(p, pIter, 0, 0)
-  ){
-    Fts5SegIter *pSegIter = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
-    int nPos;                     /* position-list size field value */
-    int nTerm;
-    const u8 *pTerm;
-
-    pTerm = fts5MultiIterTerm(pIter, &nTerm);
-    if( nTerm!=term.n || fts5Memcmp(pTerm, term.p, nTerm) ){
-      if( pnRem && writer.nLeafWritten>nRem ){
-        break;
-      }
-      fts5BufferSet(&p->rc, &term, nTerm, pTerm);
-      bTermWritten =0;
-    }
-
-    /* Check for key annihilation. */
-    if( pSegIter->nPos==0 && (bOldest || pSegIter->bDel==0) ) continue;
-
-    if( p->rc==SQLITE_OK && bTermWritten==0 ){
-      /* This is a new term. Append a term to the output segment. */
-      fts5WriteAppendTerm(p, &writer, nTerm, pTerm);
-      bTermWritten = 1;
-    }
-
-    /* Append the rowid to the output */
-    /* WRITEPOSLISTSIZE */
-    fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter));
-
-    if( eDetail==FTS5_DETAIL_NONE ){
-      if( pSegIter->bDel ){
-        fts5BufferAppendVarint(&p->rc, &writer.writer.buf, 0);
-        if( pSegIter->nPos>0 ){
-          fts5BufferAppendVarint(&p->rc, &writer.writer.buf, 0);
-        }
-      }
-    }else{
-      /* Append the position-list data to the output */
-      nPos = pSegIter->nPos*2 + pSegIter->bDel;
-      fts5BufferAppendVarint(&p->rc, &writer.writer.buf, nPos);
-      fts5ChunkIterate(p, pSegIter, (void*)&writer, fts5MergeChunkCallback);
-    }
-  }
-
-  /* Flush the last leaf page to disk. Set the output segment b-tree height
-  ** and last leaf page number at the same time.  */
-  fts5WriteFinish(p, &writer, &pSeg->pgnoLast);
-
-  assert( pIter!=0 || p->rc!=SQLITE_OK );
-  if( fts5MultiIterEof(p, pIter) ){
-    int i;
-
-    /* Remove the redundant segments from the %_data table */
-    assert( pSeg->nEntry==0 );
-    for(i=0; i<nInput; i++){
-      Fts5StructureSegment *pOld = &pLvl->aSeg[i];
-      pSeg->nEntry += (pOld->nEntry - pOld->nEntryTombstone);
-      fts5DataRemoveSegment(p, pOld);
-    }
-
-    /* Remove the redundant segments from the input level */
-    if( pLvl->nSeg!=nInput ){
-      int nMove = (pLvl->nSeg - nInput) * sizeof(Fts5StructureSegment);
-      memmove(pLvl->aSeg, &pLvl->aSeg[nInput], nMove);
-    }
-    pStruct->nSegment -= nInput;
-    pLvl->nSeg -= nInput;
-    pLvl->nMerge = 0;
-    if( pSeg->pgnoLast==0 ){
-      pLvlOut->nSeg--;
-      pStruct->nSegment--;
-    }
-  }else{
-    assert( pSeg->pgnoLast>0 );
-    fts5TrimSegments(p, pIter);
-    pLvl->nMerge = nInput;
-  }
-
-  fts5MultiIterFree(pIter);
-  fts5BufferFree(&term);
-  if( pnRem ) *pnRem -= writer.nLeafWritten;
-}
-
-/*
-** If this is not a contentless_delete=1 table, or if the 'deletemerge'
-** configuration option is set to 0, then this function always returns -1.
-** Otherwise, it searches the structure object passed as the second argument
-** for a level suitable for merging due to having a large number of
-** tombstones in the tombstone hash. If one is found, its index is returned.
-** Otherwise, if there is no suitable level, -1.
-*/
-static int fts5IndexFindDeleteMerge(Fts5Index *p, Fts5Structure *pStruct){
-  Fts5Config *pConfig = p->pConfig;
-  int iRet = -1;
-  if( pConfig->bContentlessDelete && pConfig->nDeleteMerge>0 ){
-    int ii;
-    int nBest = 0;
-
-    for(ii=0; ii<pStruct->nLevel; ii++){
-      Fts5StructureLevel *pLvl = &pStruct->aLevel[ii];
-      i64 nEntry = 0;
-      i64 nTomb = 0;
-      int iSeg;
-      for(iSeg=0; iSeg<pLvl->nSeg; iSeg++){
-        nEntry += pLvl->aSeg[iSeg].nEntry;
-        nTomb += pLvl->aSeg[iSeg].nEntryTombstone;
-      }
-      assert_nc( nEntry>0 || pLvl->nSeg==0 );
-      if( nEntry>0 ){
-        int nPercent = (nTomb * 100) / nEntry;
-        if( nPercent>=pConfig->nDeleteMerge && nPercent>nBest ){
-          iRet = ii;
-          nBest = nPercent;
-        }
-      }
-
-      /* If pLvl is already the input level to an ongoing merge, look no
-      ** further for a merge candidate. The caller should be allowed to
-      ** continue merging from pLvl first.  */
-      if( pLvl->nMerge ) break;
-    }
-  }
-  return iRet;
-}
-
-/*
-** Do up to nPg pages of automerge work on the index.
-**
-** Return true if any changes were actually made, or false otherwise.
-*/
-static int fts5IndexMerge(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5Structure **ppStruct,       /* IN/OUT: Current structure of index */
-  int nPg,                        /* Pages of work to do */
-  int nMin                        /* Minimum number of segments to merge */
-){
-  int nRem = nPg;
-  int bRet = 0;
-  Fts5Structure *pStruct = *ppStruct;
-  while( nRem>0 && p->rc==SQLITE_OK ){
-    int iLvl;                   /* To iterate through levels */
-    int iBestLvl = 0;           /* Level offering the most input segments */
-    int nBest = 0;              /* Number of input segments on best level */
-
-    /* Set iBestLvl to the level to read input segments from. Or to -1 if
-    ** there is no level suitable to merge segments from.  */
-    assert( pStruct->nLevel>0 );
-    for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
-      Fts5StructureLevel *pLvl = &pStruct->aLevel[iLvl];
-      if( pLvl->nMerge ){
-        if( pLvl->nMerge>nBest ){
-          iBestLvl = iLvl;
-          nBest = nMin;
-        }
-        break;
-      }
-      if( pLvl->nSeg>nBest ){
-        nBest = pLvl->nSeg;
-        iBestLvl = iLvl;
-      }
-    }
-    if( nBest<nMin ){
-      iBestLvl = fts5IndexFindDeleteMerge(p, pStruct);
-    }
-
-    if( iBestLvl<0 ) break;
-    bRet = 1;
-    fts5IndexMergeLevel(p, &pStruct, iBestLvl, &nRem);
-    if( p->rc==SQLITE_OK && pStruct->aLevel[iBestLvl].nMerge==0 ){
-      fts5StructurePromote(p, iBestLvl+1, pStruct);
-    }
-
-    if( nMin==1 ) nMin = 2;
-  }
-  *ppStruct = pStruct;
-  return bRet;
-}
-
-/*
-** A total of nLeaf leaf pages of data has just been flushed to a level-0
-** segment. This function updates the write-counter accordingly and, if
-** necessary, performs incremental merge work.
-**
-** If an error occurs, set the Fts5Index.rc error code. If an error has
-** already occurred, this function is a no-op.
-*/
-static void fts5IndexAutomerge(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5Structure **ppStruct,       /* IN/OUT: Current structure of index */
-  int nLeaf                       /* Number of output leaves just written */
-){
-  if( p->rc==SQLITE_OK && p->pConfig->nAutomerge>0 && ALWAYS((*ppStruct)!=0) ){
-    Fts5Structure *pStruct = *ppStruct;
-    u64 nWrite;                   /* Initial value of write-counter */
-    int nWork;                    /* Number of work-quanta to perform */
-    int nRem;                     /* Number of leaf pages left to write */
-
-    /* Update the write-counter. While doing so, set nWork. */
-    nWrite = pStruct->nWriteCounter;
-    nWork = (int)(((nWrite + nLeaf) / p->nWorkUnit) - (nWrite / p->nWorkUnit));
-    pStruct->nWriteCounter += nLeaf;
-    nRem = (int)(p->nWorkUnit * nWork * pStruct->nLevel);
-
-    fts5IndexMerge(p, ppStruct, nRem, p->pConfig->nAutomerge);
-  }
-}
-
-static void fts5IndexCrisismerge(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5Structure **ppStruct        /* IN/OUT: Current structure of index */
-){
-  const int nCrisis = p->pConfig->nCrisisMerge;
-  Fts5Structure *pStruct = *ppStruct;
-  if( pStruct && pStruct->nLevel>0 ){
-    int iLvl = 0;
-    while( p->rc==SQLITE_OK && pStruct->aLevel[iLvl].nSeg>=nCrisis ){
-      fts5IndexMergeLevel(p, &pStruct, iLvl, 0);
-      assert( p->rc!=SQLITE_OK || pStruct->nLevel>(iLvl+1) );
-      fts5StructurePromote(p, iLvl+1, pStruct);
-      iLvl++;
-    }
-    *ppStruct = pStruct;
-  }
-}
-
-static int fts5IndexReturn(Fts5Index *p){
-  int rc = p->rc;
-  p->rc = SQLITE_OK;
-  return rc;
-}
-
-/*
-** Close the read-only blob handle, if it is open.
-*/
-static void sqlite3Fts5IndexCloseReader(Fts5Index *p){
-  fts5IndexCloseReader(p);
-  fts5IndexReturn(p);
-}
-
-typedef struct Fts5FlushCtx Fts5FlushCtx;
-struct Fts5FlushCtx {
-  Fts5Index *pIdx;
-  Fts5SegWriter writer;
-};
-
-/*
-** Buffer aBuf[] contains a list of varints, all small enough to fit
-** in a 32-bit integer. Return the size of the largest prefix of this
-** list nMax bytes or less in size.
-*/
-static int fts5PoslistPrefix(const u8 *aBuf, int nMax){
-  int ret;
-  u32 dummy;
-  ret = fts5GetVarint32(aBuf, dummy);
-  if( ret<nMax ){
-    while( 1 ){
-      int i = fts5GetVarint32(&aBuf[ret], dummy);
-      if( (ret + i) > nMax ) break;
-      ret += i;
-    }
-  }
-  return ret;
-}
-
-/*
-** Execute the SQL statement:
-**
-**    DELETE FROM %_idx WHERE (segid, (pgno/2)) = ($iSegid, $iPgno);
-**
-** This is used when a secure-delete operation removes the last term
-** from a segment leaf page. In that case the %_idx entry is removed
-** too. This is done to ensure that if all instances of a token are
-** removed from an fts5 database in secure-delete mode, no trace of
-** the token itself remains in the database.
-*/
-static void fts5SecureDeleteIdxEntry(
-  Fts5Index *p,                   /* FTS5 backend object */
-  int iSegid,                     /* Id of segment to delete entry for */
-  int iPgno                       /* Page number within segment */
-){
-  if( iPgno!=1 ){
-    assert( p->pConfig->iVersion==FTS5_CURRENT_VERSION_SECUREDELETE );
-    if( p->pDeleteFromIdx==0 ){
-      fts5IndexPrepareStmt(p, &p->pDeleteFromIdx, sqlite3_mprintf(
-          "DELETE FROM '%q'.'%q_idx' WHERE (segid, (pgno/2)) = (?1, ?2)",
-          p->pConfig->zDb, p->pConfig->zName
-      ));
-    }
-    if( p->rc==SQLITE_OK ){
-      sqlite3_bind_int(p->pDeleteFromIdx, 1, iSegid);
-      sqlite3_bind_int(p->pDeleteFromIdx, 2, iPgno);
-      sqlite3_step(p->pDeleteFromIdx);
-      p->rc = sqlite3_reset(p->pDeleteFromIdx);
-    }
-  }
-}
-
-/*
-** This is called when a secure-delete operation removes a position-list
-** that overflows onto segment page iPgno of segment pSeg. This function
-** rewrites node iPgno, and possibly one or more of its right-hand peers,
-** to remove this portion of the position list.
-**
-** Output variable (*pbLastInDoclist) is set to true if the position-list
-** removed is followed by a new term or the end-of-segment, or false if
-** it is followed by another rowid/position list.
-*/
-static void fts5SecureDeleteOverflow(
-  Fts5Index *p,
-  Fts5StructureSegment *pSeg,
-  int iPgno,
-  int *pbLastInDoclist
-){
-  const int bDetailNone = (p->pConfig->eDetail==FTS5_DETAIL_NONE);
-  int pgno;
-  Fts5Data *pLeaf = 0;
-  assert( iPgno!=1 );
-
-  *pbLastInDoclist = 1;
-  for(pgno=iPgno; p->rc==SQLITE_OK && pgno<=pSeg->pgnoLast; pgno++){
-    i64 iRowid = FTS5_SEGMENT_ROWID(pSeg->iSegid, pgno);
-    int iNext = 0;
-    u8 *aPg = 0;
-
-    pLeaf = fts5DataRead(p, iRowid);
-    if( pLeaf==0 ) break;
-    aPg = pLeaf->p;
-
-    iNext = fts5GetU16(&aPg[0]);
-    if( iNext!=0 ){
-      *pbLastInDoclist = 0;
-    }
-    if( iNext==0 && pLeaf->szLeaf!=pLeaf->nn ){
-      fts5GetVarint32(&aPg[pLeaf->szLeaf], iNext);
-    }
-
-    if( iNext==0 ){
-      /* The page contains no terms or rowids. Replace it with an empty
-      ** page and move on to the right-hand peer.  */
-      const u8 aEmpty[] = {0x00, 0x00, 0x00, 0x04};
-      assert_nc( bDetailNone==0 || pLeaf->nn==4 );
-      if( bDetailNone==0 ) fts5DataWrite(p, iRowid, aEmpty, sizeof(aEmpty));
-      fts5DataRelease(pLeaf);
-      pLeaf = 0;
-    }else if( bDetailNone ){
-      break;
-    }else if( iNext>=pLeaf->szLeaf || pLeaf->nn<pLeaf->szLeaf || iNext<4 ){
-      FTS5_CORRUPT_ROWID(p, iRowid);
-      break;
-    }else{
-      int nShift = iNext - 4;
-      int nPg;
-
-      int nIdx = 0;
-      u8 *aIdx = 0;
-
-      /* Unless the current page footer is 0 bytes in size (in which case
-      ** the new page footer will be as well), allocate and populate a
-      ** buffer containing the new page footer. Set stack variables aIdx
-      ** and nIdx accordingly.  */
-      if( pLeaf->nn>pLeaf->szLeaf ){
-        int iFirst = 0;
-        int i1 = pLeaf->szLeaf;
-        int i2 = 0;
-
-        i1 += fts5GetVarint32(&aPg[i1], iFirst);
-        if( iFirst<iNext ){
-          FTS5_CORRUPT_ROWID(p, iRowid);
-          break;
-        }
-        aIdx = sqlite3Fts5MallocZero(&p->rc, (pLeaf->nn-pLeaf->szLeaf)+2);
-        if( aIdx==0 ) break;
-        i2 = sqlite3Fts5PutVarint(aIdx, iFirst-nShift);
-        if( i1<pLeaf->nn ){
-          memcpy(&aIdx[i2], &aPg[i1], pLeaf->nn-i1);
-          i2 += (pLeaf->nn-i1);
-        }
-        nIdx = i2;
-      }
-
-      /* Modify the contents of buffer aPg[]. Set nPg to the new size
-      ** in bytes. The new page is always smaller than the old.  */
-      nPg = pLeaf->szLeaf - nShift;
-      memmove(&aPg[4], &aPg[4+nShift], nPg-4);
-      fts5PutU16(&aPg[2], nPg);
-      if( fts5GetU16(&aPg[0]) ) fts5PutU16(&aPg[0], 4);
-      if( nIdx>0 ){
-        memcpy(&aPg[nPg], aIdx, nIdx);
-        nPg += nIdx;
-      }
-      sqlite3_free(aIdx);
-
-      /* Write the new page to disk and exit the loop */
-      assert( nPg>4 || fts5GetU16(aPg)==0 );
-      fts5DataWrite(p, iRowid, aPg, nPg);
-      break;
-    }
-  }
-  fts5DataRelease(pLeaf);
-}
-
-/*
-** Completely remove the entry that pSeg currently points to from
-** the database.
-*/
-static void fts5DoSecureDelete(
-  Fts5Index *p,
-  Fts5SegIter *pSeg
-){
-  const int bDetailNone = (p->pConfig->eDetail==FTS5_DETAIL_NONE);
-  int iSegid = pSeg->pSeg->iSegid;
-  u8 *aPg = pSeg->pLeaf->p;
-  int nPg = pSeg->pLeaf->nn;
-  int iPgIdx = pSeg->pLeaf->szLeaf;         /* Offset of page footer */
-
-  u64 iDelta = 0;
-  int iNextOff = 0;
-  int iOff = 0;
-  int nIdx = 0;
-  u8 *aIdx = 0;
-  int bLastInDoclist = 0;
-  int iIdx = 0;
-  int iStart = 0;
-  int iDelKeyOff = 0;       /* Offset of deleted key, if any */
-
-  nIdx = nPg-iPgIdx;
-  aIdx = sqlite3Fts5MallocZero(&p->rc, ((i64)nIdx)+16);
-  if( p->rc ) return;
-  memcpy(aIdx, &aPg[iPgIdx], nIdx);
-
-  /* At this point segment iterator pSeg points to the entry
-  ** this function should remove from the b-tree segment.
-  **
-  ** In detail=full or detail=column mode, pSeg->iLeafOffset is the
-  ** offset of the first byte in the position-list for the entry to
-  ** remove. Immediately before this comes two varints that will also
-  ** need to be removed:
-  **
-  **     + the rowid or delta rowid value for the entry, and
-  **     + the size of the position list in bytes.
-  **
-  ** Or, in detail=none mode, there is a single varint prior to
-  ** pSeg->iLeafOffset - the rowid or delta rowid value.
-  **
-  ** This block sets the following variables:
-  **
-  **   iStart:
-  **     The offset of the first byte of the rowid or delta-rowid
-  **     value for the doclist entry being removed.
-  **
-  **   iDelta:
-  **     The value of the rowid or delta-rowid value for the doclist
-  **     entry being removed.
-  **
-  **   iNextOff:
-  **     The offset of the next entry following the position list
-  **     for the one being removed. If the position list for this
-  **     entry overflows onto the next leaf page, this value will be
-  **     greater than pLeaf->szLeaf.
-  */
-  {
-    int iSOP;                     /* Start-Of-Position-list */
-    if( pSeg->iLeafPgno==pSeg->iTermLeafPgno ){
-      iStart = pSeg->iTermLeafOffset;
-    }else{
-      iStart = fts5GetU16(&aPg[0]);
-    }
-
-    iSOP = iStart + fts5GetVarint(&aPg[iStart], &iDelta);
-    assert_nc( iSOP<=pSeg->iLeafOffset );
-
-    if( bDetailNone ){
-      while( iSOP<pSeg->iLeafOffset ){
-        if( aPg[iSOP]==0x00 ) iSOP++;
-        if( aPg[iSOP]==0x00 ) iSOP++;
-        iStart = iSOP;
-        iSOP = iStart + fts5GetVarint(&aPg[iStart], &iDelta);
-      }
-
-      iNextOff = iSOP;
-      if( iNextOff<pSeg->iEndofDoclist && aPg[iNextOff]==0x00 ) iNextOff++;
-      if( iNextOff<pSeg->iEndofDoclist && aPg[iNextOff]==0x00 ) iNextOff++;
-
-    }else{
-      int nPos = 0;
-      iSOP += fts5GetVarint32(&aPg[iSOP], nPos);
-      while( iSOP<pSeg->iLeafOffset ){
-        iStart = iSOP + (nPos/2);
-        iSOP = iStart + fts5GetVarint(&aPg[iStart], &iDelta);
-        iSOP += fts5GetVarint32(&aPg[iSOP], nPos);
-      }
-      assert_nc( iSOP==pSeg->iLeafOffset );
-      iNextOff = iSOP + pSeg->nPos;
-    }
-  }
-
-  iOff = iStart;
-
-  /* If the position-list for the entry being removed flows over past
-  ** the end of this page, delete the portion of the position-list on the
-  ** next page and beyond.
-  **
-  ** Set variable bLastInDoclist to true if this entry happens
-  ** to be the last rowid in the doclist for its term.  */
-  if( iNextOff>=iPgIdx ){
-    int pgno = pSeg->iLeafPgno+1;
-    fts5SecureDeleteOverflow(p, pSeg->pSeg, pgno, &bLastInDoclist);
-    iNextOff = iPgIdx;
-  }
-
-  if( pSeg->bDel==0 ){
-    if( iNextOff!=iPgIdx ){
-      /* Loop through the page-footer. If iNextOff (offset of the
-      ** entry following the one we are removing) is equal to the
-      ** offset of a key on this page, then the entry is the last
-      ** in its doclist. */
-      int iKeyOff = 0;
-      for(iIdx=0; iIdx<nIdx; /* no-op */){
-        u32 iVal = 0;
-        iIdx += fts5GetVarint32(&aIdx[iIdx], iVal);
-        iKeyOff += iVal;
-        if( iKeyOff==iNextOff ){
-          bLastInDoclist = 1;
-        }
-      }
-    }
-
-    /* If this is (a) the first rowid on a page and (b) is not followed by
-    ** another position list on the same page, set the "first-rowid" field
-    ** of the header to 0.  */
-    if( fts5GetU16(&aPg[0])==iStart && (bLastInDoclist || iNextOff==iPgIdx) ){
-      fts5PutU16(&aPg[0], 0);
-    }
-  }
-
-  if( pSeg->bDel ){
-    iOff += sqlite3Fts5PutVarint(&aPg[iOff], iDelta);
-    aPg[iOff++] = 0x01;
-  }else if( bLastInDoclist==0 ){
-    if( iNextOff!=iPgIdx ){
-      u64 iNextDelta = 0;
-      iNextOff += fts5GetVarint(&aPg[iNextOff], &iNextDelta);
-      iOff += sqlite3Fts5PutVarint(&aPg[iOff], iDelta + iNextDelta);
-    }
-  }else if(
-      pSeg->iLeafPgno==pSeg->iTermLeafPgno
-   && iStart==pSeg->iTermLeafOffset
-  ){
-    /* The entry being removed was the only position list in its
-    ** doclist. Therefore the term needs to be removed as well. */
-    int iKey = 0;
-    int iKeyOff = 0;
-
-    /* Set iKeyOff to the offset of the term that will be removed - the
-    ** last offset in the footer that is not greater than iStart. */
-    for(iIdx=0; iIdx<nIdx; iKey++){
-      u32 iVal = 0;
-      iIdx += fts5GetVarint32(&aIdx[iIdx], iVal);
-      if( (iKeyOff+iVal)>(u32)iStart ) break;
-      iKeyOff += iVal;
-    }
-    assert_nc( iKey>=1 );
-
-    /* Set iDelKeyOff to the value of the footer entry to remove from
-    ** the page. */
-    iDelKeyOff = iOff = iKeyOff;
-
-    if( iNextOff!=iPgIdx ){
-      /* This is the only position-list associated with the term, and there
-      ** is another term following it on this page. So the subsequent term
-      ** needs to be moved to replace the term associated with the entry
-      ** being removed. */
-      u64 nPrefix = 0;
-      u64 nSuffix = 0;
-      u64 nPrefix2 = 0;
-      u64 nSuffix2 = 0;
-
-      iDelKeyOff = iNextOff;
-      iNextOff += fts5GetVarint(&aPg[iNextOff], &nPrefix2);
-      iNextOff += fts5GetVarint(&aPg[iNextOff], &nSuffix2);
-
-      if( iKey!=1 ){
-        iKeyOff += fts5GetVarint(&aPg[iKeyOff], &nPrefix);
-      }
-      iKeyOff += fts5GetVarint(&aPg[iKeyOff], &nSuffix);
-
-      nPrefix = MIN(nPrefix, nPrefix2);
-      nSuffix = (nPrefix2 + nSuffix2) - nPrefix;
-
-      if( (iKeyOff+nSuffix)>(u64)iPgIdx || (iNextOff+nSuffix2)>(u64)iPgIdx ){
-        FTS5_CORRUPT_IDX(p);
-      }else{
-        if( iKey!=1 ){
-          iOff += sqlite3Fts5PutVarint(&aPg[iOff], nPrefix);
-        }
-        iOff += sqlite3Fts5PutVarint(&aPg[iOff], nSuffix);
-        if( nPrefix2>(u64)pSeg->term.n ){
-          FTS5_CORRUPT_IDX(p);
-        }else if( nPrefix2>nPrefix ){
-          memcpy(&aPg[iOff], &pSeg->term.p[nPrefix], nPrefix2-nPrefix);
-          iOff += (nPrefix2-nPrefix);
-        }
-        memmove(&aPg[iOff], &aPg[iNextOff], nSuffix2);
-        iOff += nSuffix2;
-        iNextOff += nSuffix2;
-      }
-    }
-  }else if( iStart==4 ){
-    int iPgno;
-
-    assert_nc( pSeg->iLeafPgno>pSeg->iTermLeafPgno );
-    /* The entry being removed may be the only position list in
-    ** its doclist. */
-    for(iPgno=pSeg->iLeafPgno-1; iPgno>pSeg->iTermLeafPgno; iPgno-- ){
-      Fts5Data *pPg = fts5DataRead(p, FTS5_SEGMENT_ROWID(iSegid, iPgno));
-      int bEmpty = (pPg && pPg->nn==4);
-      fts5DataRelease(pPg);
-      if( bEmpty==0 ) break;
-    }
-
-    if( iPgno==pSeg->iTermLeafPgno ){
-      i64 iId = FTS5_SEGMENT_ROWID(iSegid, pSeg->iTermLeafPgno);
-      Fts5Data *pTerm = fts5DataRead(p, iId);
-      if( pTerm && pTerm->szLeaf==pSeg->iTermLeafOffset ){
-        u8 *aTermIdx = &pTerm->p[pTerm->szLeaf];
-        int nTermIdx = pTerm->nn - pTerm->szLeaf;
-        int iTermIdx = 0;
-        i64 iTermOff = 0;
-
-        while( 1 ){
-          u32 iVal = 0;
-          int nByte = fts5GetVarint32(&aTermIdx[iTermIdx], iVal);
-          iTermOff += iVal;
-          if( (iTermIdx+nByte)>=nTermIdx ) break;
-          iTermIdx += nByte;
-        }
-        nTermIdx = iTermIdx;
-
-        if( iTermOff>pTerm->szLeaf ){
-          FTS5_CORRUPT_IDX(p);
-        }else{
-          memmove(&pTerm->p[iTermOff], &pTerm->p[pTerm->szLeaf], nTermIdx);
-          fts5PutU16(&pTerm->p[2], iTermOff);
-          fts5DataWrite(p, iId, pTerm->p, iTermOff+nTermIdx);
-          if( nTermIdx==0 ){
-            fts5SecureDeleteIdxEntry(p, iSegid, pSeg->iTermLeafPgno);
-          }
-        }
-      }
-      fts5DataRelease(pTerm);
-    }
-  }
-
-  /* Assuming no error has occurred, this block does final edits to the
-  ** leaf page before writing it back to disk. Input variables are:
-  **
-  **   nPg: Total initial size of leaf page.
-  **   iPgIdx: Initial offset of page footer.
-  **
-  **   iOff: Offset to move data to
-  **   iNextOff: Offset to move data from
-  */
-  if( p->rc==SQLITE_OK ){
-    const int nMove = nPg - iNextOff;     /* Number of bytes to move */
-    int nShift = iNextOff - iOff;         /* Distance to move them */
-
-    int iPrevKeyOut = 0;
-    int iKeyIn = 0;
-
-    if( nMove>0 ){
-      memmove(&aPg[iOff], &aPg[iNextOff], nMove);
-    }
-    iPgIdx -= nShift;
-    nPg = iPgIdx;
-    fts5PutU16(&aPg[2], iPgIdx);
-
-    for(iIdx=0; iIdx<nIdx; /* no-op */){
-      u32 iVal = 0;
-      iIdx += fts5GetVarint32(&aIdx[iIdx], iVal);
-      iKeyIn += iVal;
-      if( iKeyIn!=iDelKeyOff ){
-        int iKeyOut = (iKeyIn - (iKeyIn>iOff ? nShift : 0));
-        nPg += sqlite3Fts5PutVarint(&aPg[nPg], iKeyOut - iPrevKeyOut);
-        iPrevKeyOut = iKeyOut;
-      }
-    }
-
-    if( iPgIdx==nPg && nIdx>0 && pSeg->iLeafPgno!=1 ){
-      fts5SecureDeleteIdxEntry(p, iSegid, pSeg->iLeafPgno);
-    }
-
-    assert_nc( nPg>4 || fts5GetU16(aPg)==0 );
-    fts5DataWrite(p, FTS5_SEGMENT_ROWID(iSegid,pSeg->iLeafPgno), aPg, nPg);
-  }
-  sqlite3_free(aIdx);
-}
-
-/*
-** This is called as part of flushing a delete to disk in 'secure-delete'
-** mode. It edits the segments within the database described by argument
-** pStruct to remove the entries for term zTerm, rowid iRowid.
-**
-** Return SQLITE_OK if successful, or an SQLite error code if an error
-** has occurred. Any error code is also stored in the Fts5Index handle.
-*/
-static int fts5FlushSecureDelete(
-  Fts5Index *p,
-  Fts5Structure *pStruct,
-  const char *zTerm,
-  int nTerm,
-  i64 iRowid
-){
-  const int f = FTS5INDEX_QUERY_SKIPHASH;
-  Fts5Iter *pIter = 0;            /* Used to find term instance */
-
-  /* If the version number has not been set to SECUREDELETE, do so now. */
-  if( p->pConfig->iVersion!=FTS5_CURRENT_VERSION_SECUREDELETE ){
-    Fts5Config *pConfig = p->pConfig;
-    sqlite3_stmt *pStmt = 0;
-    fts5IndexPrepareStmt(p, &pStmt, sqlite3_mprintf(
-          "REPLACE INTO %Q.'%q_config' VALUES ('version', %d)",
-          pConfig->zDb, pConfig->zName, FTS5_CURRENT_VERSION_SECUREDELETE
-    ));
-    if( p->rc==SQLITE_OK ){
-      int rc;
-      sqlite3_step(pStmt);
-      rc = sqlite3_finalize(pStmt);
-      if( p->rc==SQLITE_OK ) p->rc = rc;
-      pConfig->iCookie++;
-      pConfig->iVersion = FTS5_CURRENT_VERSION_SECUREDELETE;
-    }
-  }
-
-  fts5MultiIterNew(p, pStruct, f, 0, (const u8*)zTerm, nTerm, -1, 0, &pIter);
-  if( fts5MultiIterEof(p, pIter)==0 ){
-    i64 iThis = fts5MultiIterRowid(pIter);
-    if( iThis<iRowid ){
-      fts5MultiIterNextFrom(p, pIter, iRowid);
-    }
-
-    if( p->rc==SQLITE_OK
-     && fts5MultiIterEof(p, pIter)==0
-     && iRowid==fts5MultiIterRowid(pIter)
-    ){
-      Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
-      fts5DoSecureDelete(p, pSeg);
-    }
-  }
-
-  fts5MultiIterFree(pIter);
-  return p->rc;
-}
-
-
-/*
-** Flush the contents of in-memory hash table iHash to a new level-0
-** segment on disk. Also update the corresponding structure record.
-**
-** If an error occurs, set the Fts5Index.rc error code. If an error has
-** already occurred, this function is a no-op.
-*/
-static void fts5FlushOneHash(Fts5Index *p){
-  Fts5Hash *pHash = p->pHash;
-  Fts5Structure *pStruct;
-  int iSegid;
-  int pgnoLast = 0;                 /* Last leaf page number in segment */
-
-  /* Obtain a reference to the index structure and allocate a new segment-id
-  ** for the new level-0 segment.  */
-  pStruct = fts5StructureRead(p);
-  fts5StructureInvalidate(p);
-
-  if( sqlite3Fts5HashIsEmpty(pHash)==0 ){
-    iSegid = fts5AllocateSegid(p, pStruct);
-    if( iSegid ){
-      const int pgsz = p->pConfig->pgsz;
-      int eDetail = p->pConfig->eDetail;
-      int bSecureDelete = p->pConfig->bSecureDelete;
-      Fts5StructureSegment *pSeg; /* New segment within pStruct */
-      Fts5Buffer *pBuf;           /* Buffer in which to assemble leaf page */
-      Fts5Buffer *pPgidx;         /* Buffer in which to assemble pgidx */
-
-      Fts5SegWriter writer;
-      fts5WriteInit(p, &writer, iSegid);
-
-      pBuf = &writer.writer.buf;
-      pPgidx = &writer.writer.pgidx;
-
-      /* fts5WriteInit() should have initialized the buffers to (most likely)
-      ** the maximum space required. */
-      assert( p->rc || pBuf->nSpace>=(pgsz + FTS5_DATA_PADDING) );
-      assert( p->rc || pPgidx->nSpace>=(pgsz + FTS5_DATA_PADDING) );
-
-      /* Begin scanning through hash table entries. This loop runs once for each
-      ** term/doclist currently stored within the hash table. */
-      if( p->rc==SQLITE_OK ){
-        p->rc = sqlite3Fts5HashScanInit(pHash, 0, 0);
-      }
-      while( p->rc==SQLITE_OK && 0==sqlite3Fts5HashScanEof(pHash) ){
-        const char *zTerm;        /* Buffer containing term */
-        int nTerm;                /* Size of zTerm in bytes */
-        const u8 *pDoclist;       /* Pointer to doclist for this term */
-        int nDoclist;             /* Size of doclist in bytes */
-
-        /* Get the term and doclist for this entry. */
-        sqlite3Fts5HashScanEntry(pHash, &zTerm, &nTerm, &pDoclist, &nDoclist);
-        if( bSecureDelete==0 ){
-          fts5WriteAppendTerm(p, &writer, nTerm, (const u8*)zTerm);
-          if( p->rc!=SQLITE_OK ) break;
-          assert( writer.bFirstRowidInPage==0 );
-        }
-
-        if( !bSecureDelete && pgsz>=(pBuf->n + pPgidx->n + nDoclist + 1) ){
-          /* The entire doclist will fit on the current leaf. */
-          fts5BufferSafeAppendBlob(pBuf, pDoclist, nDoclist);
-        }else{
-          int bTermWritten = !bSecureDelete;
-          i64 iRowid = 0;
-          i64 iPrev = 0;
-          int iOff = 0;
-
-          /* The entire doclist will not fit on this leaf. The following
-          ** loop iterates through the poslists that make up the current
-          ** doclist.  */
-          while( p->rc==SQLITE_OK && iOff<nDoclist ){
-            u64 iDelta = 0;
-            iOff += fts5GetVarint(&pDoclist[iOff], &iDelta);
-            iRowid += iDelta;
-
-            /* If in secure delete mode, and if this entry in the poslist is
-            ** in fact a delete, then edit the existing segments directly
-            ** using fts5FlushSecureDelete().  */
-            if( bSecureDelete ){
-              if( eDetail==FTS5_DETAIL_NONE ){
-                if( iOff<nDoclist && pDoclist[iOff]==0x00
-                 && !fts5FlushSecureDelete(p, pStruct, zTerm, nTerm, iRowid)
-                ){
-                  iOff++;
-                  if( iOff<nDoclist && pDoclist[iOff]==0x00 ){
-                    iOff++;
-                    nDoclist = 0;
-                  }else{
-                    continue;
-                  }
-                }
-              }else if( (pDoclist[iOff] & 0x01)
-                && !fts5FlushSecureDelete(p, pStruct, zTerm, nTerm, iRowid)
-              ){
-                if( p->rc!=SQLITE_OK || pDoclist[iOff]==0x01 ){
-                  iOff++;
-                  continue;
-                }
-              }
-            }
-
-            if( p->rc==SQLITE_OK && bTermWritten==0 ){
-              fts5WriteAppendTerm(p, &writer, nTerm, (const u8*)zTerm);
-              bTermWritten = 1;
-              assert( p->rc!=SQLITE_OK || writer.bFirstRowidInPage==0 );
-            }
-
-            if( writer.bFirstRowidInPage ){
-              fts5PutU16(&pBuf->p[0], (u16)pBuf->n);   /* first rowid on page */
-              pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], iRowid);
-              writer.bFirstRowidInPage = 0;
-              fts5WriteDlidxAppend(p, &writer, iRowid);
-            }else{
-              u64 iRowidDelta = (u64)iRowid - (u64)iPrev;
-              pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], iRowidDelta);
-            }
-            if( p->rc!=SQLITE_OK ) break;
-            assert( pBuf->n<=pBuf->nSpace );
-            iPrev = iRowid;
-
-            if( eDetail==FTS5_DETAIL_NONE ){
-              if( iOff<nDoclist && pDoclist[iOff]==0 ){
-                pBuf->p[pBuf->n++] = 0;
-                iOff++;
-                if( iOff<nDoclist && pDoclist[iOff]==0 ){
-                  pBuf->p[pBuf->n++] = 0;
-                  iOff++;
-                }
-              }
-              if( (pBuf->n + pPgidx->n)>=pgsz ){
-                fts5WriteFlushLeaf(p, &writer);
-              }
-            }else{
-              int bDel = 0;
-              int nPos = 0;
-              int nCopy = fts5GetPoslistSize(&pDoclist[iOff], &nPos, &bDel);
-              if( bDel && bSecureDelete ){
-                fts5BufferAppendVarint(&p->rc, pBuf, nPos*2);
-                iOff += nCopy;
-                nCopy = nPos;
-              }else{
-                nCopy += nPos;
-              }
-              if( (pBuf->n + pPgidx->n + nCopy) <= pgsz ){
-                /* The entire poslist will fit on the current leaf. So copy
-                ** it in one go. */
-                fts5BufferSafeAppendBlob(pBuf, &pDoclist[iOff], nCopy);
-              }else{
-                /* The entire poslist will not fit on this leaf. So it needs
-                ** to be broken into sections. The only qualification being
-                ** that each varint must be stored contiguously.  */
-                const u8 *pPoslist = &pDoclist[iOff];
-                int iPos = 0;
-                while( p->rc==SQLITE_OK ){
-                  int nSpace = pgsz - pBuf->n - pPgidx->n;
-                  int n = 0;
-                  if( (nCopy - iPos)<=nSpace ){
-                    n = nCopy - iPos;
-                  }else{
-                    n = fts5PoslistPrefix(&pPoslist[iPos], nSpace);
-                  }
-                  assert( n>0 );
-                  fts5BufferSafeAppendBlob(pBuf, &pPoslist[iPos], n);
-                  iPos += n;
-                  if( (pBuf->n + pPgidx->n)>=pgsz ){
-                    fts5WriteFlushLeaf(p, &writer);
-                  }
-                  if( iPos>=nCopy ) break;
-                }
-              }
-              iOff += nCopy;
-            }
-          }
-        }
-
-        /* TODO2: Doclist terminator written here. */
-        /* pBuf->p[pBuf->n++] = '\0'; */
-        assert( pBuf->n<=pBuf->nSpace );
-        if( p->rc==SQLITE_OK ) sqlite3Fts5HashScanNext(pHash);
-      }
-      fts5WriteFinish(p, &writer, &pgnoLast);
-
-      assert( p->rc!=SQLITE_OK || bSecureDelete || pgnoLast>0 );
-      if( pgnoLast>0 ){
-        /* Update the Fts5Structure. It is written back to the database by the
-        ** fts5StructureRelease() call below.  */
-        if( pStruct->nLevel==0 ){
-          fts5StructureAddLevel(&p->rc, &pStruct);
-        }
-        fts5StructureExtendLevel(&p->rc, pStruct, 0, 1, 0);
-        if( p->rc==SQLITE_OK ){
-          pSeg = &pStruct->aLevel[0].aSeg[ pStruct->aLevel[0].nSeg++ ];
-          pSeg->iSegid = iSegid;
-          pSeg->pgnoFirst = 1;
-          pSeg->pgnoLast = pgnoLast;
-          if( pStruct->nOriginCntr>0 ){
-            pSeg->iOrigin1 = pStruct->nOriginCntr;
-            pSeg->iOrigin2 = pStruct->nOriginCntr;
-            pSeg->nEntry = p->nPendingRow;
-            pStruct->nOriginCntr++;
-          }
-          pStruct->nSegment++;
-        }
-        fts5StructurePromote(p, 0, pStruct);
-      }
-    }
-  }
-
-  fts5IndexAutomerge(p, &pStruct, pgnoLast + p->nContentlessDelete);
-  fts5IndexCrisismerge(p, &pStruct);
-  fts5StructureWrite(p, pStruct);
-  fts5StructureRelease(pStruct);
-}
-
-/*
-** Flush any data stored in the in-memory hash tables to the database.
-*/
-static void fts5IndexFlush(Fts5Index *p){
-  /* Unless it is empty, flush the hash table to disk */
-  if( p->flushRc ){
-    p->rc = p->flushRc;
-    return;
-  }
-  if( p->nPendingData || p->nContentlessDelete ){
-    assert( p->pHash );
-    fts5FlushOneHash(p);
-    if( p->rc==SQLITE_OK ){
-      sqlite3Fts5HashClear(p->pHash);
-      p->nPendingData = 0;
-      p->nPendingRow = 0;
-      p->nContentlessDelete = 0;
-    }else if( p->nPendingData || p->nContentlessDelete ){
-      p->flushRc = p->rc;
-    }
-  }
-}
-
-static Fts5Structure *fts5IndexOptimizeStruct(
-  Fts5Index *p,
-  Fts5Structure *pStruct
-){
-  Fts5Structure *pNew = 0;
-  sqlite3_int64 nByte = SZ_FTS5STRUCTURE(1);
-  int nSeg = pStruct->nSegment;
-  int i;
-
-  /* Figure out if this structure requires optimization. A structure does
-  ** not require optimization if either:
-  **
-  **  1. it consists of fewer than two segments, or
-  **  2. all segments are on the same level, or
-  **  3. all segments except one are currently inputs to a merge operation.
-  **
-  ** In the first case, if there are no tombstone hash pages, return NULL. In
-  ** the second, increment the ref-count on *pStruct and return a copy of the
-  ** pointer to it.
-  */
-  if( nSeg==0 ) return 0;
-  for(i=0; i<pStruct->nLevel; i++){
-    int nThis = pStruct->aLevel[i].nSeg;
-    int nMerge = pStruct->aLevel[i].nMerge;
-    if( nThis>0 && (nThis==nSeg || (nThis==nSeg-1 && nMerge==nThis)) ){
-      if( nSeg==1 && nThis==1 && pStruct->aLevel[i].aSeg[0].nPgTombstone==0 ){
-        return 0;
-      }
-      fts5StructureRef(pStruct);
-      return pStruct;
-    }
-    assert( pStruct->aLevel[i].nMerge<=nThis );
-  }
-
-  nByte += (((i64)pStruct->nLevel)+1) * sizeof(Fts5StructureLevel);
-  assert( nByte==(i64)SZ_FTS5STRUCTURE(pStruct->nLevel+2) );
-  pNew = (Fts5Structure*)sqlite3Fts5MallocZero(&p->rc, nByte);
-
-  if( pNew ){
-    Fts5StructureLevel *pLvl;
-    nByte = nSeg * sizeof(Fts5StructureSegment);
-    pNew->nLevel = MIN(pStruct->nLevel+1, FTS5_MAX_LEVEL);
-    pNew->nRef = 1;
-    pNew->nWriteCounter = pStruct->nWriteCounter;
-    pNew->nOriginCntr = pStruct->nOriginCntr;
-    pLvl = &pNew->aLevel[pNew->nLevel-1];
-    pLvl->aSeg = (Fts5StructureSegment*)sqlite3Fts5MallocZero(&p->rc, nByte);
-    if( pLvl->aSeg ){
-      int iLvl, iSeg;
-      int iSegOut = 0;
-      /* Iterate through all segments, from oldest to newest. Add them to
-      ** the new Fts5Level object so that pLvl->aSeg[0] is the oldest
-      ** segment in the data structure.  */
-      for(iLvl=pStruct->nLevel-1; iLvl>=0; iLvl--){
-        for(iSeg=0; iSeg<pStruct->aLevel[iLvl].nSeg; iSeg++){
-          pLvl->aSeg[iSegOut] = pStruct->aLevel[iLvl].aSeg[iSeg];
-          iSegOut++;
-        }
-      }
-      pNew->nSegment = pLvl->nSeg = nSeg;
-    }else{
-      sqlite3_free(pNew);
-      pNew = 0;
-    }
-  }
-
-  return pNew;
-}
-
-static int sqlite3Fts5IndexOptimize(Fts5Index *p){
-  Fts5Structure *pStruct;
-  Fts5Structure *pNew = 0;
-
-  assert( p->rc==SQLITE_OK );
-  fts5IndexFlush(p);
-  assert( p->rc!=SQLITE_OK || p->nContentlessDelete==0 );
-  pStruct = fts5StructureRead(p);
-  assert( p->rc!=SQLITE_OK || pStruct!=0 );
-  fts5StructureInvalidate(p);
-
-  if( pStruct ){
-    pNew = fts5IndexOptimizeStruct(p, pStruct);
-  }
-  fts5StructureRelease(pStruct);
-
-  assert( pNew==0 || pNew->nSegment>0 );
-  if( pNew ){
-    int iLvl;
-    for(iLvl=0; pNew->aLevel[iLvl].nSeg==0; iLvl++){}
-    while( p->rc==SQLITE_OK && pNew->aLevel[iLvl].nSeg>0 ){
-      int nRem = FTS5_OPT_WORK_UNIT;
-      fts5IndexMergeLevel(p, &pNew, iLvl, &nRem);
-    }
-
-    fts5StructureWrite(p, pNew);
-    fts5StructureRelease(pNew);
-  }
-
-  return fts5IndexReturn(p);
-}
-
-/*
-** This is called to implement the special "VALUES('merge', $nMerge)"
-** INSERT command.
-*/
-static int sqlite3Fts5IndexMerge(Fts5Index *p, int nMerge){
-  Fts5Structure *pStruct = 0;
-
-  fts5IndexFlush(p);
-  pStruct = fts5StructureRead(p);
-  if( pStruct ){
-    int nMin = p->pConfig->nUsermerge;
-    fts5StructureInvalidate(p);
-    if( nMerge<0 ){
-      Fts5Structure *pNew = fts5IndexOptimizeStruct(p, pStruct);
-      fts5StructureRelease(pStruct);
-      pStruct = pNew;
-      nMin = 1;
-      nMerge = (nMerge==SMALLEST_INT32 ? LARGEST_INT32 : (nMerge*-1));
-    }
-    if( pStruct && pStruct->nLevel ){
-      if( fts5IndexMerge(p, &pStruct, nMerge, nMin) ){
-        fts5StructureWrite(p, pStruct);
-      }
-    }
-    fts5StructureRelease(pStruct);
-  }
-  return fts5IndexReturn(p);
-}
-
-static void fts5AppendRowid(
-  Fts5Index *p,
-  u64 iDelta,
-  Fts5Iter *pUnused,
-  Fts5Buffer *pBuf
-){
-  UNUSED_PARAM(pUnused);
-  fts5BufferAppendVarint(&p->rc, pBuf, iDelta);
-}
-
-static void fts5AppendPoslist(
-  Fts5Index *p,
-  u64 iDelta,
-  Fts5Iter *pMulti,
-  Fts5Buffer *pBuf
-){
-  int nData = pMulti->base.nData;
-  int nByte = nData + 9 + 9 + FTS5_DATA_ZERO_PADDING;
-  assert( nData>0 );
-  if( p->rc==SQLITE_OK && 0==fts5BufferGrow(&p->rc, pBuf, nByte) ){
-    fts5BufferSafeAppendVarint(pBuf, iDelta);
-    fts5BufferSafeAppendVarint(pBuf, nData*2);
-    fts5BufferSafeAppendBlob(pBuf, pMulti->base.pData, nData);
-    memset(&pBuf->p[pBuf->n], 0, FTS5_DATA_ZERO_PADDING);
-  }
-}
-
-
-static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
-  u8 *p = pIter->aPoslist + pIter->nSize + pIter->nPoslist;
-
-  assert( pIter->aPoslist || (p==0 && pIter->aPoslist==0) );
-  if( p>=pIter->aEof ){
-    pIter->aPoslist = 0;
-  }else{
-    i64 iDelta;
-
-    p += fts5GetVarint(p, (u64*)&iDelta);
-    pIter->iRowid += iDelta;
-
-    /* Read position list size */
-    if( p[0] & 0x80 ){
-      int nPos;
-      pIter->nSize = fts5GetVarint32(p, nPos);
-      pIter->nPoslist = (nPos>>1);
-    }else{
-      pIter->nPoslist = ((int)(p[0])) >> 1;
-      pIter->nSize = 1;
-    }
-
-    pIter->aPoslist = p;
-    if( &pIter->aPoslist[pIter->nPoslist]>pIter->aEof ){
-      pIter->aPoslist = 0;
-    }
-  }
-}
-
-static void fts5DoclistIterInit(
-  Fts5Buffer *pBuf,
-  Fts5DoclistIter *pIter
-){
-  memset(pIter, 0, sizeof(*pIter));
-  if( pBuf->n>0 ){
-    pIter->aPoslist = pBuf->p;
-    pIter->aEof = &pBuf->p[pBuf->n];
-    fts5DoclistIterNext(pIter);
-  }
-}
-
-#if 0
-/*
-** Append a doclist to buffer pBuf.
-**
-** This function assumes that space within the buffer has already been
-** allocated.
-*/
-static void fts5MergeAppendDocid(
-  Fts5Buffer *pBuf,               /* Buffer to write to */
-  i64 *piLastRowid,               /* IN/OUT: Previous rowid written (if any) */
-  i64 iRowid                      /* Rowid to append */
-){
-  assert( pBuf->n!=0 || (*piLastRowid)==0 );
-  fts5BufferSafeAppendVarint(pBuf, iRowid - *piLastRowid);
-  *piLastRowid = iRowid;
-}
-#endif
-
-#define fts5MergeAppendDocid(pBuf, iLastRowid, iRowid) {                 \
-  assert( (pBuf)->n!=0 || (iLastRowid)==0 );                             \
-  fts5BufferSafeAppendVarint((pBuf), (u64)(iRowid) - (u64)(iLastRowid)); \
-  (iLastRowid) = (iRowid);                                               \
-}
-
-/*
-** Swap the contents of buffer *p1 with that of *p2.
-*/
-static void fts5BufferSwap(Fts5Buffer *p1, Fts5Buffer *p2){
-  Fts5Buffer tmp = *p1;
-  *p1 = *p2;
-  *p2 = tmp;
-}
-
-static void fts5NextRowid(Fts5Buffer *pBuf, int *piOff, i64 *piRowid){
-  int i = *piOff;
-  if( i>=pBuf->n ){
-    *piOff = -1;
-  }else{
-    u64 iVal;
-    *piOff = i + sqlite3Fts5GetVarint(&pBuf->p[i], &iVal);
-    *piRowid += iVal;
-  }
-}
-
-/*
-** This is the equivalent of fts5MergePrefixLists() for detail=none mode.
-** In this case the buffers consist of a delta-encoded list of rowids only.
-*/
-static void fts5MergeRowidLists(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5Buffer *p1,                 /* First list to merge */
-  int nBuf,                       /* Number of entries in apBuf[] */
-  Fts5Buffer *aBuf                /* Array of other lists to merge into p1 */
-){
-  int i1 = 0;
-  int i2 = 0;
-  i64 iRowid1 = 0;
-  i64 iRowid2 = 0;
-  i64 iOut = 0;
-  Fts5Buffer *p2 = &aBuf[0];
-  Fts5Buffer out;
-
-  (void)nBuf;
-  memset(&out, 0, sizeof(out));
-  assert( nBuf==1 );
-  sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n);
-  if( p->rc ) return;
-
-  fts5NextRowid(p1, &i1, &iRowid1);
-  fts5NextRowid(p2, &i2, &iRowid2);
-  while( i1>=0 || i2>=0 ){
-    if( i1>=0 && (i2<0 || iRowid1<iRowid2) ){
-      assert( iOut==0 || iRowid1>iOut );
-      fts5BufferSafeAppendVarint(&out, iRowid1 - iOut);
-      iOut = iRowid1;
-      fts5NextRowid(p1, &i1, &iRowid1);
-    }else{
-      assert( iOut==0 || iRowid2>iOut );
-      fts5BufferSafeAppendVarint(&out, iRowid2 - iOut);
-      iOut = iRowid2;
-      if( i1>=0 && iRowid1==iRowid2 ){
-        fts5NextRowid(p1, &i1, &iRowid1);
-      }
-      fts5NextRowid(p2, &i2, &iRowid2);
-    }
-  }
-
-  fts5BufferSwap(&out, p1);
-  fts5BufferFree(&out);
-}
-
-typedef struct PrefixMerger PrefixMerger;
-struct PrefixMerger {
-  Fts5DoclistIter iter;           /* Doclist iterator */
-  i64 iPos;                       /* For iterating through a position list */
-  int iOff;
-  u8 *aPos;
-  PrefixMerger *pNext;            /* Next in docid/poslist order */
-};
-
-static void fts5PrefixMergerInsertByRowid(
-  PrefixMerger **ppHead,
-  PrefixMerger *p
-){
-  if( p->iter.aPoslist ){
-    PrefixMerger **pp = ppHead;
-    while( *pp && p->iter.iRowid>(*pp)->iter.iRowid ){
-      pp = &(*pp)->pNext;
-    }
-    p->pNext = *pp;
-    *pp = p;
-  }
-}
-
-static void fts5PrefixMergerInsertByPosition(
-  PrefixMerger **ppHead,
-  PrefixMerger *p
-){
-  if( p->iPos>=0 ){
-    PrefixMerger **pp = ppHead;
-    while( *pp && p->iPos>(*pp)->iPos ){
-      pp = &(*pp)->pNext;
-    }
-    p->pNext = *pp;
-    *pp = p;
-  }
-}
-
-
-/*
-** Array aBuf[] contains nBuf doclists. These are all merged in with the
-** doclist in buffer p1.
-*/
-static void fts5MergePrefixLists(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5Buffer *p1,                 /* First list to merge */
-  int nBuf,                       /* Number of buffers in array aBuf[] */
-  Fts5Buffer *aBuf                /* Other lists to merge in */
-){
-#define fts5PrefixMergerNextPosition(p) \
-  sqlite3Fts5PoslistNext64((p)->aPos,(p)->iter.nPoslist,&(p)->iOff,&(p)->iPos)
-#define FTS5_MERGE_NLIST 16
-  PrefixMerger aMerger[FTS5_MERGE_NLIST];
-  PrefixMerger *pHead = 0;
-  int i;
-  int nOut = 0;
-  Fts5Buffer out = {0, 0, 0};
-  Fts5Buffer tmp = {0, 0, 0};
-  i64 iLastRowid = 0;
-
-  /* Initialize a doclist-iterator for each input buffer. Arrange them in
-  ** a linked-list starting at pHead in ascending order of rowid. Avoid
-  ** linking any iterators already at EOF into the linked list at all. */
-  assert( nBuf+1<=(int)(sizeof(aMerger)/sizeof(aMerger[0])) );
-  memset(aMerger, 0, sizeof(PrefixMerger)*(nBuf+1));
-  pHead = &aMerger[nBuf];
-  fts5DoclistIterInit(p1, &pHead->iter);
-  for(i=0; i<nBuf; i++){
-    fts5DoclistIterInit(&aBuf[i], &aMerger[i].iter);
-    fts5PrefixMergerInsertByRowid(&pHead, &aMerger[i]);
-    nOut += aBuf[i].n;
-  }
-  if( nOut==0 ) return;
-  nOut += p1->n + 9 + 10*nBuf;
-
-  /* The maximum size of the output is equal to the sum of the
-  ** input sizes + 1 varint (9 bytes). The extra varint is because if the
-  ** first rowid in one input is a large negative number, and the first in
-  ** the other a non-negative number, the delta for the non-negative
-  ** number will be larger on disk than the literal integer value
-  ** was.
-  **
-  ** Or, if the input position-lists are corrupt, then the output might
-  ** include up to (nBuf+1) extra 10-byte positions created by interpreting -1
-  ** (the value PoslistNext64() uses for EOF) as a position and appending
-  ** it to the output. This can happen at most once for each input
-  ** position-list, hence (nBuf+1) 10 byte paddings.  */
-  if( sqlite3Fts5BufferSize(&p->rc, &out, nOut) ) return;
-
-  while( pHead ){
-    fts5MergeAppendDocid(&out, iLastRowid, pHead->iter.iRowid);
-
-    if( pHead->pNext && iLastRowid==pHead->pNext->iter.iRowid ){
-      /* Merge data from two or more poslists */
-      i64 iPrev = 0;
-      int nTmp = FTS5_DATA_ZERO_PADDING;
-      int nMerge = 0;
-      PrefixMerger *pSave = pHead;
-      PrefixMerger *pThis = 0;
-      int nTail = 0;
-
-      pHead = 0;
-      while( pSave && pSave->iter.iRowid==iLastRowid ){
-        PrefixMerger *pNext = pSave->pNext;
-        pSave->iOff = 0;
-        pSave->iPos = 0;
-        pSave->aPos = &pSave->iter.aPoslist[pSave->iter.nSize];
-        fts5PrefixMergerNextPosition(pSave);
-        nTmp += pSave->iter.nPoslist + 10;
-        nMerge++;
-        fts5PrefixMergerInsertByPosition(&pHead, pSave);
-        pSave = pNext;
-      }
-
-      if( pHead==0 || pHead->pNext==0 ){
-        FTS5_CORRUPT_IDX(p);
-        break;
-      }
-
-      /* See the earlier comment in this function for an explanation of why
-      ** corrupt input position lists might cause the output to consume
-      ** at most nMerge*10 bytes of unexpected space. */
-      if( sqlite3Fts5BufferSize(&p->rc, &tmp, nTmp+nMerge*10) ){
-        break;
-      }
-      fts5BufferZero(&tmp);
-
-      pThis = pHead;
-      pHead = pThis->pNext;
-      sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, pThis->iPos);
-      fts5PrefixMergerNextPosition(pThis);
-      fts5PrefixMergerInsertByPosition(&pHead, pThis);
-
-      while( pHead->pNext ){
-        pThis = pHead;
-        if( pThis->iPos!=iPrev ){
-          sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, pThis->iPos);
-        }
-        fts5PrefixMergerNextPosition(pThis);
-        pHead = pThis->pNext;
-        fts5PrefixMergerInsertByPosition(&pHead, pThis);
-      }
-
-      if( pHead->iPos!=iPrev ){
-        sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, pHead->iPos);
-      }
-      nTail = pHead->iter.nPoslist - pHead->iOff;
-
-      /* WRITEPOSLISTSIZE */
-      assert_nc( tmp.n+nTail<=nTmp );
-      assert( tmp.n+nTail<=nTmp+nMerge*10 );
-      if( tmp.n+nTail>nTmp-FTS5_DATA_ZERO_PADDING ){
-        if( p->rc==SQLITE_OK ) FTS5_CORRUPT_IDX(p);
-        break;
-      }
-      fts5BufferSafeAppendVarint(&out, (tmp.n+nTail) * 2);
-      fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n);
-      if( nTail>0 ){
-        fts5BufferSafeAppendBlob(&out, &pHead->aPos[pHead->iOff], nTail);
-      }
-
-      pHead = pSave;
-      for(i=0; i<nBuf+1; i++){
-        PrefixMerger *pX = &aMerger[i];
-        if( pX->iter.aPoslist && pX->iter.iRowid==iLastRowid ){
-          fts5DoclistIterNext(&pX->iter);
-          fts5PrefixMergerInsertByRowid(&pHead, pX);
-        }
-      }
-
-    }else{
-      /* Copy poslist from pHead to output */
-      PrefixMerger *pThis = pHead;
-      Fts5DoclistIter *pI = &pThis->iter;
-      fts5BufferSafeAppendBlob(&out, pI->aPoslist, pI->nPoslist+pI->nSize);
-      fts5DoclistIterNext(pI);
-      pHead = pThis->pNext;
-      fts5PrefixMergerInsertByRowid(&pHead, pThis);
-    }
-  }
-
-  fts5BufferFree(p1);
-  fts5BufferFree(&tmp);
-  memset(&out.p[out.n], 0, FTS5_DATA_ZERO_PADDING);
-  *p1 = out;
-}
-
-
-/*
-** Iterate through a range of entries in the FTS index, invoking the xVisit
-** callback for each of them.
-**
-** Parameter pToken points to an nToken buffer containing an FTS index term
-** (i.e. a document term with the preceding 1 byte index identifier -
-** FTS5_MAIN_PREFIX or similar). If bPrefix is true, then the call visits
-** all entries for terms that have pToken/nToken as a prefix. If bPrefix
-** is false, then only entries with pToken/nToken as the entire key are
-** visited.
-**
-** If the current table is a tokendata=1 table, then if bPrefix is true then
-** each index term is treated separately. However, if bPrefix is false, then
-** all index terms corresponding to pToken/nToken are collapsed into a single
-** term before the callback is invoked.
-**
-** The callback invoked for each entry visited is specified by paramter xVisit.
-** Each time it is invoked, it is passed a pointer to the Fts5Index object,
-** a copy of the 7th paramter to this function (pCtx) and a pointer to the
-** iterator that indicates the current entry. If the current entry is the
-** first with a new term (i.e. different from that of the previous entry,
-** including the very first term), then the final two parameters are passed
-** a pointer to the term and its size in bytes, respectively. If the current
-** entry is not the first associated with its term, these two parameters
-** are passed 0.
-**
-** If parameter pColset is not NULL, then it is used to filter entries before
-** the callback is invoked.
-*/
-static int fts5VisitEntries(
-  Fts5Index *p,                   /* Fts5 index object */
-  Fts5Colset *pColset,            /* Columns filter to apply, or NULL */
-  u8 *pToken,                     /* Buffer containing token */
-  int nToken,                     /* Size of buffer pToken in bytes */
-  int bPrefix,                    /* True for a prefix scan */
-  void (*xVisit)(Fts5Index*, void *pCtx, Fts5Iter *pIter, const u8*, int),
-  void *pCtx                      /* Passed as second argument to xVisit() */
-){
-  const int flags = (bPrefix ? FTS5INDEX_QUERY_SCAN : 0)
-                  | FTS5INDEX_QUERY_SKIPEMPTY
-                  | FTS5INDEX_QUERY_NOOUTPUT;
-  Fts5Iter *p1 = 0;     /* Iterator used to gather data from index */
-  int bNewTerm = 1;
-  Fts5Structure *pStruct = fts5StructureRead(p);
-
-  fts5MultiIterNew(p, pStruct, flags, pColset, pToken, nToken, -1, 0, &p1);
-  fts5IterSetOutputCb(&p->rc, p1);
-  for( /* no-op */ ;
-      fts5MultiIterEof(p, p1)==0;
-      fts5MultiIterNext2(p, p1, &bNewTerm)
-  ){
-    Fts5SegIter *pSeg = &p1->aSeg[ p1->aFirst[1].iFirst ];
-    int nNew = 0;
-    const u8 *pNew = 0;
-
-    p1->xSetOutputs(p1, pSeg);
-    if( p->rc ) break;
-
-    if( bNewTerm ){
-      nNew = pSeg->term.n;
-      pNew = pSeg->term.p;
-      if( nNew<nToken || memcmp(pToken, pNew, nToken) ) break;
-    }
-
-    xVisit(p, pCtx, p1, pNew, nNew);
-  }
-  fts5MultiIterFree(p1);
-
-  fts5StructureRelease(pStruct);
-  return p->rc;
-}
-
-
-/*
-** Usually, a tokendata=1 iterator (struct Fts5TokenDataIter) accumulates an
-** array of these for each row it visits (so all iRowid fields are the same).
-** Or, for an iterator used by an "ORDER BY rank" query, it accumulates an
-** array of these for the entire query (in which case iRowid fields may take
-** a variety of values).
-**
-** Each instance in the array indicates the iterator (and therefore term)
-** associated with position iPos of rowid iRowid. This is used by the
-** xInstToken() API.
-**
-** iRowid:
-**   Rowid for the current entry.
-**
-** iPos:
-**   Position of current entry within row. In the usual ((iCol<<32)+iOff)
-**   format (e.g. see macros FTS5_POS2COLUMN() and FTS5_POS2OFFSET()).
-**
-** iIter:
-**   If the Fts5TokenDataIter iterator that the entry is part of is
-**   actually an iterator (i.e. with nIter>0, not just a container for
-**   Fts5TokenDataMap structures), then this variable is an index into
-**   the apIter[] array. The corresponding term is that which the iterator
-**   at apIter[iIter] currently points to.
-**
-**   Or, if the Fts5TokenDataIter iterator is just a container object
-**   (nIter==0), then iIter is an index into the term.p[] buffer where
-**   the term is stored.
-**
-** nByte:
-**   In the case where iIter is an index into term.p[], this variable
-**   is the size of the term in bytes. If iIter is an index into apIter[],
-**   this variable is unused.
-*/
-struct Fts5TokenDataMap {
-  i64 iRowid;                     /* Row this token is located in */
-  i64 iPos;                       /* Position of token */
-  int iIter;                      /* Iterator token was read from */
-  int nByte;                      /* Length of token in bytes (or 0) */
-};
-
-/*
-** An object used to supplement Fts5Iter for tokendata=1 iterators.
-**
-** This object serves two purposes. The first is as a container for an array
-** of Fts5TokenDataMap structures, which are used to find the token required
-** when the xInstToken() API is used. This is done by the nMapAlloc, nMap and
-** aMap[] variables.
-*/
-struct Fts5TokenDataIter {
-  i64 nMapAlloc;                  /* Allocated size of aMap[] in entries */
-  i64 nMap;                       /* Number of valid entries in aMap[] */
-  Fts5TokenDataMap *aMap;         /* Array of (rowid+pos -> token) mappings */
-
-  /* The following are used for prefix-queries only. */
-  Fts5Buffer terms;
-
-  /* The following are used for other full-token tokendata queries only. */
-  i64 nIter;
-  i64 nIterAlloc;
-  Fts5PoslistReader *aPoslistReader;
-  int *aPoslistToIter;
-  Fts5Iter *apIter[FLEXARRAY];
-};
-
-/* Size in bytes of an Fts5TokenDataIter object holding up to N iterators */
-#define SZ_FTS5TOKENDATAITER(N) \
-    (offsetof(Fts5TokenDataIter,apIter) + (N)*sizeof(Fts5Iter))
-
-/*
-** The two input arrays - a1[] and a2[] - are in sorted order. This function
-** merges the two arrays together and writes the result to output array
-** aOut[]. aOut[] is guaranteed to be large enough to hold the result.
-**
-** Duplicate entries are copied into the output. So the size of the output
-** array is always (n1+n2) entries.
-*/
-static void fts5TokendataMerge(
-  Fts5TokenDataMap *a1, int n1,   /* Input array 1 */
-  Fts5TokenDataMap *a2, int n2,   /* Input array 2 */
-  Fts5TokenDataMap *aOut          /* Output array */
-){
-  int i1 = 0;
-  int i2 = 0;
-
-  assert( n1>=0 && n2>=0 );
-  while( i1<n1 || i2<n2 ){
-    Fts5TokenDataMap *pOut = &aOut[i1+i2];
-    if( i2>=n2 || (i1<n1 && (
-        a1[i1].iRowid<a2[i2].iRowid
-     || (a1[i1].iRowid==a2[i2].iRowid && a1[i1].iPos<=a2[i2].iPos)
-    ))){
-      memcpy(pOut, &a1[i1], sizeof(Fts5TokenDataMap));
-      i1++;
-    }else{
-      memcpy(pOut, &a2[i2], sizeof(Fts5TokenDataMap));
-      i2++;
-    }
-  }
-}
-
-
-/*
-** Append a mapping to the token-map belonging to object pT.
-*/
-static void fts5TokendataIterAppendMap(
-  Fts5Index *p,
-  Fts5TokenDataIter *pT,
-  int iIter,
-  int nByte,
-  i64 iRowid,
-  i64 iPos
-){
-  if( p->rc==SQLITE_OK ){
-    if( pT->nMap==pT->nMapAlloc ){
-      i64 nNew = pT->nMapAlloc ? pT->nMapAlloc*2 : 64;
-      i64 nAlloc = nNew * sizeof(Fts5TokenDataMap);
-      Fts5TokenDataMap *aNew;
-
-      aNew = (Fts5TokenDataMap*)sqlite3_realloc64(pT->aMap, nAlloc);
-      if( aNew==0 ){
-        p->rc = SQLITE_NOMEM;
-        return;
-      }
-
-      pT->aMap = aNew;
-      pT->nMapAlloc = nNew;
-    }
-
-    pT->aMap[pT->nMap].iRowid = iRowid;
-    pT->aMap[pT->nMap].iPos = iPos;
-    pT->aMap[pT->nMap].iIter = iIter;
-    pT->aMap[pT->nMap].nByte = nByte;
-    pT->nMap++;
-  }
-}
-
-/*
-** Sort the contents of the pT->aMap[] array.
-**
-** The sorting algorithm requires a malloc(). If this fails, an error code
-** is left in Fts5Index.rc before returning.
-*/
-static void fts5TokendataIterSortMap(Fts5Index *p, Fts5TokenDataIter *pT){
-  Fts5TokenDataMap *aTmp = 0;
-  i64 nByte = pT->nMap * sizeof(Fts5TokenDataMap);
-
-  aTmp = (Fts5TokenDataMap*)sqlite3Fts5MallocZero(&p->rc, nByte);
-  if( aTmp ){
-    Fts5TokenDataMap *a1 = pT->aMap;
-    Fts5TokenDataMap *a2 = aTmp;
-    i64 nHalf;
-
-    for(nHalf=1; nHalf<pT->nMap; nHalf=nHalf*2){
-      int i1;
-      for(i1=0; i1<pT->nMap; i1+=(nHalf*2)){
-        int n1 = MIN(nHalf, pT->nMap-i1);
-        int n2 = MIN(nHalf, pT->nMap-i1-n1);
-        fts5TokendataMerge(&a1[i1], n1, &a1[i1+n1], n2, &a2[i1]);
-      }
-      SWAPVAL(Fts5TokenDataMap*, a1, a2);
-    }
-
-    if( a1!=pT->aMap ){
-      memcpy(pT->aMap, a1, pT->nMap*sizeof(Fts5TokenDataMap));
-    }
-    sqlite3_free(aTmp);
-
-#ifdef SQLITE_DEBUG
-    {
-      int ii;
-      for(ii=1; ii<pT->nMap; ii++){
-        Fts5TokenDataMap *p1 = &pT->aMap[ii-1];
-        Fts5TokenDataMap *p2 = &pT->aMap[ii];
-        assert( p1->iRowid<p2->iRowid
-             || (p1->iRowid==p2->iRowid && p1->iPos<=p2->iPos)
-        );
-      }
-    }
-#endif
-  }
-}
-
-/*
-** Delete an Fts5TokenDataIter structure and its contents.
-*/
-static void fts5TokendataIterDelete(Fts5TokenDataIter *pSet){
-  if( pSet ){
-    int ii;
-    for(ii=0; ii<pSet->nIter; ii++){
-      fts5MultiIterFree(pSet->apIter[ii]);
-    }
-    fts5BufferFree(&pSet->terms);
-    sqlite3_free(pSet->aPoslistReader);
-    sqlite3_free(pSet->aMap);
-    sqlite3_free(pSet);
-  }
-}
-
-
-/*
-** fts5VisitEntries() context object used by fts5SetupPrefixIterTokendata()
-** to pass data to prefixIterSetupTokendataCb().
-*/
-typedef struct TokendataSetupCtx TokendataSetupCtx;
-struct TokendataSetupCtx {
-  Fts5TokenDataIter *pT;          /* Object being populated with mappings */
-  int iTermOff;                   /* Offset of current term in terms.p[] */
-  int nTermByte;                  /* Size of current term in bytes */
-};
-
-/*
-** fts5VisitEntries() callback used by fts5SetupPrefixIterTokendata(). This
-** callback adds an entry to the Fts5TokenDataIter.aMap[] array for each
-** position in the current position-list. It doesn't matter that some of
-** these may be out of order - they will be sorted later.
-*/
-static void prefixIterSetupTokendataCb(
-  Fts5Index *p,
-  void *pCtx,
-  Fts5Iter *p1,
-  const u8 *pNew,
-  int nNew
-){
-  TokendataSetupCtx *pSetup = (TokendataSetupCtx*)pCtx;
-  int iPosOff = 0;
-  i64 iPos = 0;
-
-  if( pNew ){
-    pSetup->nTermByte = nNew-1;
-    pSetup->iTermOff = pSetup->pT->terms.n;
-    fts5BufferAppendBlob(&p->rc, &pSetup->pT->terms, nNew-1, pNew+1);
-  }
-
-  while( 0==sqlite3Fts5PoslistNext64(
-     p1->base.pData, p1->base.nData, &iPosOff, &iPos
-  ) ){
-    fts5TokendataIterAppendMap(p,
-        pSetup->pT, pSetup->iTermOff, pSetup->nTermByte, p1->base.iRowid, iPos
-    );
-  }
-}
-
-
-/*
-** Context object passed by fts5SetupPrefixIter() to fts5VisitEntries().
-*/
-typedef struct PrefixSetupCtx PrefixSetupCtx;
-struct PrefixSetupCtx {
-  void (*xMerge)(Fts5Index*, Fts5Buffer*, int, Fts5Buffer*);
-  void (*xAppend)(Fts5Index*, u64, Fts5Iter*, Fts5Buffer*);
-  i64 iLastRowid;
-  int nMerge;
-  Fts5Buffer *aBuf;
-  int nBuf;
-  Fts5Buffer doclist;
-  TokendataSetupCtx *pTokendata;
-};
-
-/*
-** fts5VisitEntries() callback used by fts5SetupPrefixIter()
-*/
-static void prefixIterSetupCb(
-  Fts5Index *p,
-  void *pCtx,
-  Fts5Iter *p1,
-  const u8 *pNew,
-  int nNew
-){
-  PrefixSetupCtx *pSetup = (PrefixSetupCtx*)pCtx;
-  const int nMerge = pSetup->nMerge;
-
-  if( p1->base.nData>0 ){
-    if( p1->base.iRowid<=pSetup->iLastRowid && pSetup->doclist.n>0 ){
-      int i;
-      for(i=0; p->rc==SQLITE_OK && pSetup->doclist.n; i++){
-        int i1 = i*nMerge;
-        int iStore;
-        assert( i1+nMerge<=pSetup->nBuf );
-        for(iStore=i1; iStore<i1+nMerge; iStore++){
-          if( pSetup->aBuf[iStore].n==0 ){
-            fts5BufferSwap(&pSetup->doclist, &pSetup->aBuf[iStore]);
-            fts5BufferZero(&pSetup->doclist);
-            break;
-          }
-        }
-        if( iStore==i1+nMerge ){
-          pSetup->xMerge(p, &pSetup->doclist, nMerge, &pSetup->aBuf[i1]);
-          for(iStore=i1; iStore<i1+nMerge; iStore++){
-            fts5BufferZero(&pSetup->aBuf[iStore]);
-          }
-        }
-      }
-      pSetup->iLastRowid = 0;
-    }
-
-    pSetup->xAppend(
-        p, (u64)p1->base.iRowid-(u64)pSetup->iLastRowid, p1, &pSetup->doclist
-    );
-    pSetup->iLastRowid = p1->base.iRowid;
-  }
-
-  if( pSetup->pTokendata ){
-    prefixIterSetupTokendataCb(p, (void*)pSetup->pTokendata, p1, pNew, nNew);
-  }
-}
-
-static void fts5SetupPrefixIter(
-  Fts5Index *p,                   /* Index to read from */
-  int bDesc,                      /* True for "ORDER BY rowid DESC" */
-  int iIdx,                       /* Index to scan for data */
-  u8 *pToken,                     /* Buffer containing prefix to match */
-  int nToken,                     /* Size of buffer pToken in bytes */
-  Fts5Colset *pColset,            /* Restrict matches to these columns */
-  Fts5Iter **ppIter               /* OUT: New iterator */
-){
-  Fts5Structure *pStruct;
-  PrefixSetupCtx s;
-  TokendataSetupCtx s2;
-
-  memset(&s, 0, sizeof(s));
-  memset(&s2, 0, sizeof(s2));
-
-  s.nMerge = 1;
-  s.iLastRowid = 0;
-  s.nBuf = 32;
-  if( iIdx==0
-   && p->pConfig->eDetail==FTS5_DETAIL_FULL
-   && p->pConfig->bPrefixInsttoken
-  ){
-    s.pTokendata = &s2;
-    s2.pT = (Fts5TokenDataIter*)fts5IdxMalloc(p, SZ_FTS5TOKENDATAITER(1));
-  }
-
-  if( p->pConfig->eDetail==FTS5_DETAIL_NONE ){
-    s.xMerge = fts5MergeRowidLists;
-    s.xAppend = fts5AppendRowid;
-  }else{
-    s.nMerge = FTS5_MERGE_NLIST-1;
-    s.nBuf = s.nMerge*8;   /* Sufficient to merge (16^8)==(2^32) lists */
-    s.xMerge = fts5MergePrefixLists;
-    s.xAppend = fts5AppendPoslist;
-  }
-
-  s.aBuf = (Fts5Buffer*)fts5IdxMalloc(p, sizeof(Fts5Buffer)*s.nBuf);
-  pStruct = fts5StructureRead(p);
-  assert( p->rc!=SQLITE_OK || (s.aBuf && pStruct) );
-
-  if( p->rc==SQLITE_OK ){
-    void *pCtx = (void*)&s;
-    int i;
-    Fts5Data *pData;
-
-    /* If iIdx is non-zero, then it is the number of a prefix-index for
-    ** prefixes 1 character longer than the prefix being queried for. That
-    ** index contains all the doclists required, except for the one
-    ** corresponding to the prefix itself. That one is extracted from the
-    ** main term index here.  */
-    if( iIdx!=0 ){
-      pToken[0] = FTS5_MAIN_PREFIX;
-      fts5VisitEntries(p, pColset, pToken, nToken, 0, prefixIterSetupCb, pCtx);
-    }
-
-    pToken[0] = FTS5_MAIN_PREFIX + iIdx;
-    fts5VisitEntries(p, pColset, pToken, nToken, 1, prefixIterSetupCb, pCtx);
-
-    assert( (s.nBuf%s.nMerge)==0 );
-    for(i=0; i<s.nBuf; i+=s.nMerge){
-      int iFree;
-      if( p->rc==SQLITE_OK ){
-        s.xMerge(p, &s.doclist, s.nMerge, &s.aBuf[i]);
-      }
-      for(iFree=i; iFree<i+s.nMerge; iFree++){
-        fts5BufferFree(&s.aBuf[iFree]);
-      }
-    }
-
-    pData = fts5IdxMalloc(p, sizeof(*pData)
-                             + ((i64)s.doclist.n)+FTS5_DATA_ZERO_PADDING);
-    assert( pData!=0 || p->rc!=SQLITE_OK );
-    if( pData ){
-      pData->p = (u8*)&pData[1];
-      pData->nn = pData->szLeaf = s.doclist.n;
-      if( s.doclist.n ) memcpy(pData->p, s.doclist.p, s.doclist.n);
-      fts5MultiIterNew2(p, pData, bDesc, ppIter);
-    }
-
-    assert( (*ppIter)!=0 || p->rc!=SQLITE_OK );
-    if( p->rc==SQLITE_OK && s.pTokendata ){
-      fts5TokendataIterSortMap(p, s2.pT);
-      (*ppIter)->pTokenDataIter = s2.pT;
-      s2.pT = 0;
-    }
-  }
-
-  fts5TokendataIterDelete(s2.pT);
-  fts5BufferFree(&s.doclist);
-  fts5StructureRelease(pStruct);
-  sqlite3_free(s.aBuf);
-}
-
-
-/*
-** Indicate that all subsequent calls to sqlite3Fts5IndexWrite() pertain
-** to the document with rowid iRowid.
-*/
-static int sqlite3Fts5IndexBeginWrite(Fts5Index *p, int bDelete, i64 iRowid){
-  assert( p->rc==SQLITE_OK );
-
-  /* Allocate the hash table if it has not already been allocated */
-  if( p->pHash==0 ){
-    p->rc = sqlite3Fts5HashNew(p->pConfig, &p->pHash, &p->nPendingData);
-  }
-
-  /* Flush the hash table to disk if required */
-  if( iRowid<p->iWriteRowid
-   || (iRowid==p->iWriteRowid && p->bDelete==0)
-   || (p->nPendingData > p->pConfig->nHashSize)
-  ){
-    fts5IndexFlush(p);
-  }
-
-  p->iWriteRowid = iRowid;
-  p->bDelete = bDelete;
-  if( bDelete==0 ){
-    p->nPendingRow++;
-  }
-  return fts5IndexReturn(p);
-}
-
-/*
-** Commit data to disk.
-*/
-static int sqlite3Fts5IndexSync(Fts5Index *p){
-  assert( p->rc==SQLITE_OK );
-  fts5IndexFlush(p);
-  fts5IndexCloseReader(p);
-  return fts5IndexReturn(p);
-}
-
-/*
-** Discard any data stored in the in-memory hash tables. Do not write it
-** to the database. Additionally, assume that the contents of the %_data
-** table may have changed on disk. So any in-memory caches of %_data
-** records must be invalidated.
-*/
-static int sqlite3Fts5IndexRollback(Fts5Index *p){
-  fts5IndexCloseReader(p);
-  fts5IndexDiscardData(p);
-  fts5StructureInvalidate(p);
-  return fts5IndexReturn(p);
-}
-
-/*
-** The %_data table is completely empty when this function is called. This
-** function populates it with the initial structure objects for each index,
-** and the initial version of the "averages" record (a zero-byte blob).
-*/
-static int sqlite3Fts5IndexReinit(Fts5Index *p){
-  Fts5Structure *pTmp;
-  union {
-    Fts5Structure sFts;
-    u8 tmpSpace[SZ_FTS5STRUCTURE(1)];
-  } uFts;
-  fts5StructureInvalidate(p);
-  fts5IndexDiscardData(p);
-  pTmp = &uFts.sFts;
-  memset(uFts.tmpSpace, 0, sizeof(uFts.tmpSpace));
-  if( p->pConfig->bContentlessDelete ){
-    pTmp->nOriginCntr = 1;
-  }
-  fts5DataWrite(p, FTS5_AVERAGES_ROWID, (const u8*)"", 0);
-  fts5StructureWrite(p, pTmp);
-  return fts5IndexReturn(p);
-}
-
-/*
-** Open a new Fts5Index handle. If the bCreate argument is true, create
-** and initialize the underlying %_data table.
-**
-** If successful, set *pp to point to the new object and return SQLITE_OK.
-** Otherwise, set *pp to NULL and return an SQLite error code.
-*/
-static int sqlite3Fts5IndexOpen(
-  Fts5Config *pConfig,
-  int bCreate,
-  Fts5Index **pp,
-  char **pzErr
-){
-  int rc = SQLITE_OK;
-  Fts5Index *p;                   /* New object */
-
-  *pp = p = (Fts5Index*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5Index));
-  if( rc==SQLITE_OK ){
-    p->pConfig = pConfig;
-    p->nWorkUnit = FTS5_WORK_UNIT;
-    p->zDataTbl = sqlite3Fts5Mprintf(&rc, "%s_data", pConfig->zName);
-    if( p->zDataTbl && bCreate ){
-      rc = sqlite3Fts5CreateTable(
-          pConfig, "data", "id INTEGER PRIMARY KEY, block BLOB", 0, pzErr
-      );
-      if( rc==SQLITE_OK ){
-        rc = sqlite3Fts5CreateTable(pConfig, "idx",
-            "segid, term, pgno, PRIMARY KEY(segid, term)",
-            1, pzErr
-        );
-      }
-      if( rc==SQLITE_OK ){
-        rc = sqlite3Fts5IndexReinit(p);
-      }
-    }
-  }
-
-  assert( rc!=SQLITE_OK || p->rc==SQLITE_OK );
-  if( rc ){
-    sqlite3Fts5IndexClose(p);
-    *pp = 0;
-  }
-  return rc;
-}
-
-/*
-** Close a handle opened by an earlier call to sqlite3Fts5IndexOpen().
-*/
-static int sqlite3Fts5IndexClose(Fts5Index *p){
-  int rc = SQLITE_OK;
-  if( p ){
-    assert( p->pReader==0 );
-    fts5StructureInvalidate(p);
-    sqlite3_finalize(p->pWriter);
-    sqlite3_finalize(p->pDeleter);
-    sqlite3_finalize(p->pIdxWriter);
-    sqlite3_finalize(p->pIdxDeleter);
-    sqlite3_finalize(p->pIdxSelect);
-    sqlite3_finalize(p->pIdxNextSelect);
-    sqlite3_finalize(p->pDataVersion);
-    sqlite3_finalize(p->pDeleteFromIdx);
-    sqlite3Fts5HashFree(p->pHash);
-    sqlite3_free(p->zDataTbl);
-    sqlite3_free(p);
-  }
-  return rc;
-}
-
-/*
-** Argument p points to a buffer containing utf-8 text that is n bytes in
-** size. Return the number of bytes in the nChar character prefix of the
-** buffer, or 0 if there are less than nChar characters in total.
-*/
-static int sqlite3Fts5IndexCharlenToBytelen(
-  const char *p,
-  int nByte,
-  int nChar
-){
-  int n = 0;
-  int i;
-  for(i=0; i<nChar; i++){
-    if( n>=nByte ) return 0;      /* Input contains fewer than nChar chars */
-    if( (unsigned char)p[n++]>=0xc0 ){
-      if( n>=nByte ) return 0;
-      while( (p[n] & 0xc0)==0x80 ){
-        n++;
-        if( n>=nByte ){
-          if( i+1==nChar ) break;
-          return 0;
-        }
-      }
-    }
-  }
-  return n;
-}
-
-/*
-** pIn is a UTF-8 encoded string, nIn bytes in size. Return the number of
-** unicode characters in the string.
-*/
-static int fts5IndexCharlen(const char *pIn, int nIn){
-  int nChar = 0;
-  int i = 0;
-  while( i<nIn ){
-    if( (unsigned char)pIn[i++]>=0xc0 ){
-      while( i<nIn && (pIn[i] & 0xc0)==0x80 ) i++;
-    }
-    nChar++;
-  }
-  return nChar;
-}
-
-/*
-** Insert or remove data to or from the index. Each time a document is
-** added to or removed from the index, this function is called one or more
-** times.
-**
-** For an insert, it must be called once for each token in the new document.
-** If the operation is a delete, it must be called (at least) once for each
-** unique token in the document with an iCol value less than zero. The iPos
-** argument is ignored for a delete.
-*/
-static int sqlite3Fts5IndexWrite(
-  Fts5Index *p,                   /* Index to write to */
-  int iCol,                       /* Column token appears in (-ve -> delete) */
-  int iPos,                       /* Position of token within column */
-  const char *pToken, int nToken  /* Token to add or remove to or from index */
-){
-  int i;                          /* Used to iterate through indexes */
-  int rc = SQLITE_OK;             /* Return code */
-  Fts5Config *pConfig = p->pConfig;
-
-  assert( p->rc==SQLITE_OK );
-  assert( (iCol<0)==p->bDelete );
-
-  /* Add the entry to the main terms index. */
-  rc = sqlite3Fts5HashWrite(
-      p->pHash, p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX, pToken, nToken
-  );
-
-  for(i=0; i<pConfig->nPrefix && rc==SQLITE_OK; i++){
-    const int nChar = pConfig->aPrefix[i];
-    int nByte = sqlite3Fts5IndexCharlenToBytelen(pToken, nToken, nChar);
-    if( nByte ){
-      rc = sqlite3Fts5HashWrite(p->pHash,
-          p->iWriteRowid, iCol, iPos, (char)(FTS5_MAIN_PREFIX+i+1), pToken,
-          nByte
-      );
-    }
-  }
-
-  return rc;
-}
-
-/*
-** pToken points to a buffer of size nToken bytes containing a search
-** term, including the index number at the start, used on a tokendata=1
-** table. This function returns true if the term in buffer pBuf matches
-** token pToken/nToken.
-*/
-static int fts5IsTokendataPrefix(
-  Fts5Buffer *pBuf,
-  const u8 *pToken,
-  int nToken
-){
-  return (
-      pBuf->n>=nToken
-   && 0==memcmp(pBuf->p, pToken, nToken)
-   && (pBuf->n==nToken || pBuf->p[nToken]==0x00)
-  );
-}
-
-/*
-** Ensure the segment-iterator passed as the only argument points to EOF.
-*/
-static void fts5SegIterSetEOF(Fts5SegIter *pSeg){
-  fts5DataRelease(pSeg->pLeaf);
-  pSeg->pLeaf = 0;
-}
-
-static void fts5IterClose(Fts5IndexIter *pIndexIter){
-  if( pIndexIter ){
-    Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
-    Fts5Index *pIndex = pIter->pIndex;
-    fts5TokendataIterDelete(pIter->pTokenDataIter);
-    fts5MultiIterFree(pIter);
-    fts5IndexCloseReader(pIndex);
-  }
-}
-
-/*
-** This function appends iterator pAppend to Fts5TokenDataIter pIn and
-** returns the result.
-*/
-static Fts5TokenDataIter *fts5AppendTokendataIter(
-  Fts5Index *p,                   /* Index object (for error code) */
-  Fts5TokenDataIter *pIn,         /* Current Fts5TokenDataIter struct */
-  Fts5Iter *pAppend               /* Append this iterator */
-){
-  Fts5TokenDataIter *pRet = pIn;
-
-  if( p->rc==SQLITE_OK ){
-    if( pIn==0 || pIn->nIter==pIn->nIterAlloc ){
-      i64 nAlloc = pIn ? pIn->nIterAlloc*2 : 16;
-      i64 nByte = SZ_FTS5TOKENDATAITER(nAlloc+1);
-      Fts5TokenDataIter *pNew;
-      pNew = (Fts5TokenDataIter*)sqlite3_realloc64(pIn, nByte);
-
-      if( pNew==0 ){
-        p->rc = SQLITE_NOMEM;
-      }else{
-        if( pIn==0 ) memset(pNew, 0, nByte);
-        pRet = pNew;
-        pNew->nIterAlloc = nAlloc;
-      }
-    }
-  }
-  if( p->rc ){
-    fts5IterClose((Fts5IndexIter*)pAppend);
-  }else{
-    pRet->apIter[pRet->nIter++] = pAppend;
-  }
-  assert( pRet==0 || pRet->nIter<=pRet->nIterAlloc );
-
-  return pRet;
-}
-
-/*
-** The iterator passed as the only argument must be a tokendata=1 iterator
-** (pIter->pTokenDataIter!=0). This function sets the iterator output
-** variables (pIter->base.*) according to the contents of the current
-** row.
-*/
-static void fts5IterSetOutputsTokendata(Fts5Iter *pIter){
-  int ii;
-  int nHit = 0;
-  i64 iRowid = SMALLEST_INT64;
-  int iMin = 0;
-
-  Fts5TokenDataIter *pT = pIter->pTokenDataIter;
-
-  pIter->base.nData = 0;
-  pIter->base.pData = 0;
-
-  for(ii=0; ii<pT->nIter; ii++){
-    Fts5Iter *p = pT->apIter[ii];
-    if( p->base.bEof==0 ){
-      if( nHit==0 || p->base.iRowid<iRowid ){
-        iRowid = p->base.iRowid;
-        nHit = 1;
-        pIter->base.pData = p->base.pData;
-        pIter->base.nData = p->base.nData;
-        iMin = ii;
-      }else if( p->base.iRowid==iRowid ){
-        nHit++;
-      }
-    }
-  }
-
-  if( nHit==0 ){
-    pIter->base.bEof = 1;
-  }else{
-    int eDetail = pIter->pIndex->pConfig->eDetail;
-    pIter->base.bEof = 0;
-    pIter->base.iRowid = iRowid;
-
-    if( nHit==1 && eDetail==FTS5_DETAIL_FULL ){
-      fts5TokendataIterAppendMap(pIter->pIndex, pT, iMin, 0, iRowid, -1);
-    }else
-    if( nHit>1 && eDetail!=FTS5_DETAIL_NONE ){
-      int nReader = 0;
-      int nByte = 0;
-      i64 iPrev = 0;
-
-      /* Allocate array of iterators if they are not already allocated. */
-      if( pT->aPoslistReader==0 ){
-        pT->aPoslistReader = (Fts5PoslistReader*)sqlite3Fts5MallocZero(
-            &pIter->pIndex->rc,
-            pT->nIter * (sizeof(Fts5PoslistReader) + sizeof(int))
-        );
-        if( pT->aPoslistReader==0 ) return;
-        pT->aPoslistToIter = (int*)&pT->aPoslistReader[pT->nIter];
-      }
-
-      /* Populate an iterator for each poslist that will be merged */
-      for(ii=0; ii<pT->nIter; ii++){
-        Fts5Iter *p = pT->apIter[ii];
-        if( iRowid==p->base.iRowid ){
-          pT->aPoslistToIter[nReader] = ii;
-          sqlite3Fts5PoslistReaderInit(
-              p->base.pData, p->base.nData, &pT->aPoslistReader[nReader++]
-          );
-          nByte += p->base.nData;
-        }
-      }
-
-      /* Ensure the output buffer is large enough */
-      if( fts5BufferGrow(&pIter->pIndex->rc, &pIter->poslist, nByte+nHit*10) ){
-        return;
-      }
-
-      /* Ensure the token-mapping is large enough */
-      if( eDetail==FTS5_DETAIL_FULL && pT->nMapAlloc<(pT->nMap + nByte) ){
-        i64 nNew = (pT->nMapAlloc + nByte) * 2;
-        Fts5TokenDataMap *aNew = (Fts5TokenDataMap*)sqlite3_realloc64(
-            pT->aMap, nNew*sizeof(Fts5TokenDataMap)
-        );
-        if( aNew==0 ){
-          pIter->pIndex->rc = SQLITE_NOMEM;
-          return;
-        }
-        pT->aMap = aNew;
-        pT->nMapAlloc = nNew;
-      }
-
-      pIter->poslist.n = 0;
-
-      while( 1 ){
-        i64 iMinPos = LARGEST_INT64;
-
-        /* Find smallest position */
-        iMin = 0;
-        for(ii=0; ii<nReader; ii++){
-          Fts5PoslistReader *pReader = &pT->aPoslistReader[ii];
-          if( pReader->bEof==0 ){
-            if( pReader->iPos<iMinPos ){
-              iMinPos = pReader->iPos;
-              iMin = ii;
-            }
-          }
-        }
-
-        /* If all readers were at EOF, break out of the loop. */
-        if( iMinPos==LARGEST_INT64 ) break;
-
-        sqlite3Fts5PoslistSafeAppend(&pIter->poslist, &iPrev, iMinPos);
-        sqlite3Fts5PoslistReaderNext(&pT->aPoslistReader[iMin]);
-
-        if( eDetail==FTS5_DETAIL_FULL ){
-          pT->aMap[pT->nMap].iPos = iMinPos;
-          pT->aMap[pT->nMap].iIter = pT->aPoslistToIter[iMin];
-          pT->aMap[pT->nMap].iRowid = iRowid;
-          pT->nMap++;
-        }
-      }
-
-      pIter->base.pData = pIter->poslist.p;
-      pIter->base.nData = pIter->poslist.n;
-    }
-  }
-}
-
-/*
-** The iterator passed as the only argument must be a tokendata=1 iterator
-** (pIter->pTokenDataIter!=0). This function advances the iterator. If
-** argument bFrom is false, then the iterator is advanced to the next
-** entry. Or, if bFrom is true, it is advanced to the first entry with
-** a rowid of iFrom or greater.
-*/
-static void fts5TokendataIterNext(Fts5Iter *pIter, int bFrom, i64 iFrom){
-  int ii;
-  Fts5TokenDataIter *pT = pIter->pTokenDataIter;
-  Fts5Index *pIndex = pIter->pIndex;
-
-  for(ii=0; ii<pT->nIter; ii++){
-    Fts5Iter *p = pT->apIter[ii];
-    if( p->base.bEof==0
-     && (p->base.iRowid==pIter->base.iRowid || (bFrom && p->base.iRowid<iFrom))
-    ){
-      fts5MultiIterNext(pIndex, p, bFrom, iFrom);
-      while( bFrom && p->base.bEof==0
-          && p->base.iRowid<iFrom
-          && pIndex->rc==SQLITE_OK
-      ){
-        fts5MultiIterNext(pIndex, p, 0, 0);
-      }
-    }
-  }
-
-  if( pIndex->rc==SQLITE_OK ){
-    fts5IterSetOutputsTokendata(pIter);
-  }
-}
-
-/*
-** If the segment-iterator passed as the first argument is at EOF, then
-** set pIter->term to a copy of buffer pTerm.
-*/
-static void fts5TokendataSetTermIfEof(Fts5Iter *pIter, Fts5Buffer *pTerm){
-  if( pIter && pIter->aSeg[0].pLeaf==0 ){
-    fts5BufferSet(&pIter->pIndex->rc, &pIter->aSeg[0].term, pTerm->n, pTerm->p);
-  }
-}
-
-/*
-** This function sets up an iterator to use for a non-prefix query on a
-** tokendata=1 table.
-*/
-static Fts5Iter *fts5SetupTokendataIter(
-  Fts5Index *p,                   /* FTS index to query */
-  const u8 *pToken,               /* Buffer containing query term */
-  int nToken,                     /* Size of buffer pToken in bytes */
-  Fts5Colset *pColset             /* Colset to filter on */
-){
-  Fts5Iter *pRet = 0;
-  Fts5TokenDataIter *pSet = 0;
-  Fts5Structure *pStruct = 0;
-  const int flags = FTS5INDEX_QUERY_SCANONETERM | FTS5INDEX_QUERY_SCAN;
-
-  Fts5Buffer bSeek = {0, 0, 0};
-  Fts5Buffer *pSmall = 0;
-
-  fts5IndexFlush(p);
-  pStruct = fts5StructureRead(p);
-
-  while( p->rc==SQLITE_OK ){
-    Fts5Iter *pPrev = pSet ? pSet->apIter[pSet->nIter-1] : 0;
-    Fts5Iter *pNew = 0;
-    Fts5SegIter *pNewIter = 0;
-    Fts5SegIter *pPrevIter = 0;
-
-    int iLvl, iSeg, ii;
-
-    pNew = fts5MultiIterAlloc(p, pStruct->nSegment);
-    if( pSmall ){
-      fts5BufferSet(&p->rc, &bSeek, pSmall->n, pSmall->p);
-      fts5BufferAppendBlob(&p->rc, &bSeek, 1, (const u8*)"\0");
-    }else{
-      fts5BufferSet(&p->rc, &bSeek, nToken, pToken);
-    }
-    if( p->rc ){
-      fts5IterClose((Fts5IndexIter*)pNew);
-      break;
-    }
-
-    pNewIter = &pNew->aSeg[0];
-    pPrevIter = (pPrev ? &pPrev->aSeg[0] : 0);
-    for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
-      for(iSeg=pStruct->aLevel[iLvl].nSeg-1; iSeg>=0; iSeg--){
-        Fts5StructureSegment *pSeg = &pStruct->aLevel[iLvl].aSeg[iSeg];
-        int bDone = 0;
-
-        if( pPrevIter ){
-          if( fts5BufferCompare(pSmall, &pPrevIter->term) ){
-            memcpy(pNewIter, pPrevIter, sizeof(Fts5SegIter));
-            memset(pPrevIter, 0, sizeof(Fts5SegIter));
-            bDone = 1;
-          }else if( pPrevIter->iEndofDoclist>pPrevIter->pLeaf->szLeaf ){
-            fts5SegIterNextInit(p,(const char*)bSeek.p,bSeek.n-1,pSeg,pNewIter);
-            bDone = 1;
-          }
-        }
-
-        if( bDone==0 ){
-          fts5SegIterSeekInit(p, bSeek.p, bSeek.n, flags, pSeg, pNewIter);
-        }
-
-        if( pPrevIter ){
-          if( pPrevIter->pTombArray ){
-            pNewIter->pTombArray = pPrevIter->pTombArray;
-            pNewIter->pTombArray->nRef++;
-          }
-        }else{
-          fts5SegIterAllocTombstone(p, pNewIter);
-        }
-
-        pNewIter++;
-        if( pPrevIter ) pPrevIter++;
-        if( p->rc ) break;
-      }
-    }
-    fts5TokendataSetTermIfEof(pPrev, pSmall);
-
-    pNew->bSkipEmpty = 1;
-    pNew->pColset = pColset;
-    fts5IterSetOutputCb(&p->rc, pNew);
-
-    /* Loop through all segments in the new iterator. Find the smallest
-    ** term that any segment-iterator points to. Iterator pNew will be
-    ** used for this term. Also, set any iterator that points to a term that
-    ** does not match pToken/nToken to point to EOF */
-    pSmall = 0;
-    for(ii=0; ii<pNew->nSeg; ii++){
-      Fts5SegIter *pII = &pNew->aSeg[ii];
-      if( 0==fts5IsTokendataPrefix(&pII->term, pToken, nToken) ){
-        fts5SegIterSetEOF(pII);
-      }
-      if( pII->pLeaf && (!pSmall || fts5BufferCompare(pSmall, &pII->term)>0) ){
-        pSmall = &pII->term;
-      }
-    }
-
-    /* If pSmall is still NULL at this point, then the new iterator does
-    ** not point to any terms that match the query. So delete it and break
-    ** out of the loop - all required iterators have been collected.  */
-    if( pSmall==0 ){
-      fts5IterClose((Fts5IndexIter*)pNew);
-      break;
-    }
-
-    /* Append this iterator to the set and continue. */
-    pSet = fts5AppendTokendataIter(p, pSet, pNew);
-  }
-
-  if( p->rc==SQLITE_OK && pSet ){
-    int ii;
-    for(ii=0; ii<pSet->nIter; ii++){
-      Fts5Iter *pIter = pSet->apIter[ii];
-      int iSeg;
-      for(iSeg=0; iSeg<pIter->nSeg; iSeg++){
-        pIter->aSeg[iSeg].flags |= FTS5_SEGITER_ONETERM;
-      }
-      fts5MultiIterFinishSetup(p, pIter);
-    }
-  }
-
-  if( p->rc==SQLITE_OK ){
-    pRet = fts5MultiIterAlloc(p, 0);
-  }
-  if( pRet ){
-    pRet->nSeg = 0;
-    pRet->pTokenDataIter = pSet;
-    if( pSet ){
-      fts5IterSetOutputsTokendata(pRet);
-    }else{
-      pRet->base.bEof = 1;
-    }
-  }else{
-    fts5TokendataIterDelete(pSet);
-  }
-
-  fts5StructureRelease(pStruct);
-  fts5BufferFree(&bSeek);
-  return pRet;
-}
-
-/*
-** Open a new iterator to iterate though all rowid that match the
-** specified token or token prefix.
-*/
-static int sqlite3Fts5IndexQuery(
-  Fts5Index *p,                   /* FTS index to query */
-  const char *pToken, int nToken, /* Token (or prefix) to query for */
-  int flags,                      /* Mask of FTS5INDEX_QUERY_X flags */
-  Fts5Colset *pColset,            /* Match these columns only */
-  Fts5IndexIter **ppIter          /* OUT: New iterator object */
-){
-  Fts5Config *pConfig = p->pConfig;
-  Fts5Iter *pRet = 0;
-  Fts5Buffer buf = {0, 0, 0};
-
-  /* If the QUERY_SCAN flag is set, all other flags must be clear. */
-  assert( (flags & FTS5INDEX_QUERY_SCAN)==0 || flags==FTS5INDEX_QUERY_SCAN );
-
-  if( sqlite3Fts5BufferSize(&p->rc, &buf, nToken+1)==0 ){
-    int iIdx = 0;                 /* Index to search */
-    int iPrefixIdx = 0;           /* +1 prefix index */
-    int bTokendata = pConfig->bTokendata;
-    assert( buf.p!=0 );
-    if( nToken>0 ) memcpy(&buf.p[1], pToken, nToken);
-
-    /* The NOTOKENDATA flag is set when each token in a tokendata=1 table
-    ** should be treated individually, instead of merging all those with
-    ** a common prefix into a single entry. This is used, for example, by
-    ** queries performed as part of an integrity-check, or by the fts5vocab
-    ** module.  */
-    if( flags & (FTS5INDEX_QUERY_NOTOKENDATA|FTS5INDEX_QUERY_SCAN) ){
-      bTokendata = 0;
-    }
-
-    /* Figure out which index to search and set iIdx accordingly. If this
-    ** is a prefix query for which there is no prefix index, set iIdx to
-    ** greater than pConfig->nPrefix to indicate that the query will be
-    ** satisfied by scanning multiple terms in the main index.
-    **
-    ** If the QUERY_TEST_NOIDX flag was specified, then this must be a
-    ** prefix-query. Instead of using a prefix-index (if one exists),
-    ** evaluate the prefix query using the main FTS index. This is used
-    ** for internal sanity checking by the integrity-check in debug
-    ** mode only.  */
-#ifdef SQLITE_DEBUG
-    if( pConfig->bPrefixIndex==0 || (flags & FTS5INDEX_QUERY_TEST_NOIDX) ){
-      assert( flags & FTS5INDEX_QUERY_PREFIX );
-      iIdx = 1+pConfig->nPrefix;
-    }else
-#endif
-    if( flags & FTS5INDEX_QUERY_PREFIX ){
-      int nChar = fts5IndexCharlen(pToken, nToken);
-      for(iIdx=1; iIdx<=pConfig->nPrefix; iIdx++){
-        int nIdxChar = pConfig->aPrefix[iIdx-1];
-        if( nIdxChar==nChar ) break;
-        if( nIdxChar==nChar+1 ) iPrefixIdx = iIdx;
-      }
-    }
-
-    if( bTokendata && iIdx==0 ){
-      buf.p[0] = FTS5_MAIN_PREFIX;
-      pRet = fts5SetupTokendataIter(p, buf.p, nToken+1, pColset);
-    }else if( iIdx<=pConfig->nPrefix ){
-      /* Straight index lookup */
-      Fts5Structure *pStruct = fts5StructureRead(p);
-      buf.p[0] = (u8)(FTS5_MAIN_PREFIX + iIdx);
-      if( pStruct ){
-        fts5MultiIterNew(p, pStruct, flags | FTS5INDEX_QUERY_SKIPEMPTY,
-            pColset, buf.p, nToken+1, -1, 0, &pRet
-        );
-        fts5StructureRelease(pStruct);
-      }
-    }else{
-      /* Scan multiple terms in the main index for a prefix query. */
-      int bDesc = (flags & FTS5INDEX_QUERY_DESC)!=0;
-      fts5SetupPrefixIter(p, bDesc, iPrefixIdx, buf.p, nToken+1, pColset,&pRet);
-      if( pRet==0 ){
-        assert( p->rc!=SQLITE_OK );
-      }else{
-        assert( pRet->pColset==0 );
-        fts5IterSetOutputCb(&p->rc, pRet);
-        if( p->rc==SQLITE_OK ){
-          Fts5SegIter *pSeg = &pRet->aSeg[pRet->aFirst[1].iFirst];
-          if( pSeg->pLeaf ) pRet->xSetOutputs(pRet, pSeg);
-        }
-      }
-    }
-
-    if( p->rc ){
-      fts5IterClose((Fts5IndexIter*)pRet);
-      pRet = 0;
-      fts5IndexCloseReader(p);
-    }
-
-    *ppIter = (Fts5IndexIter*)pRet;
-    sqlite3Fts5BufferFree(&buf);
-  }
-  return fts5IndexReturn(p);
-}
-
-/*
-** Return true if the iterator passed as the only argument is at EOF.
-*/
-/*
-** Move to the next matching rowid.
-*/
-static int sqlite3Fts5IterNext(Fts5IndexIter *pIndexIter){
-  Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
-  assert( pIter->pIndex->rc==SQLITE_OK );
-  if( pIter->nSeg==0 ){
-    assert( pIter->pTokenDataIter );
-    fts5TokendataIterNext(pIter, 0, 0);
-  }else{
-    fts5MultiIterNext(pIter->pIndex, pIter, 0, 0);
-  }
-  return fts5IndexReturn(pIter->pIndex);
-}
-
-/*
-** Move to the next matching term/rowid. Used by the fts5vocab module.
-*/
-static int sqlite3Fts5IterNextScan(Fts5IndexIter *pIndexIter){
-  Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
-  Fts5Index *p = pIter->pIndex;
-
-  assert( pIter->pIndex->rc==SQLITE_OK );
-
-  fts5MultiIterNext(p, pIter, 0, 0);
-  if( p->rc==SQLITE_OK ){
-    Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
-    if( pSeg->pLeaf && pSeg->term.p[0]!=FTS5_MAIN_PREFIX ){
-      fts5DataRelease(pSeg->pLeaf);
-      pSeg->pLeaf = 0;
-      pIter->base.bEof = 1;
-    }
-  }
-
-  return fts5IndexReturn(pIter->pIndex);
-}
-
-/*
-** Move to the next matching rowid that occurs at or after iMatch. The
-** definition of "at or after" depends on whether this iterator iterates
-** in ascending or descending rowid order.
-*/
-static int sqlite3Fts5IterNextFrom(Fts5IndexIter *pIndexIter, i64 iMatch){
-  Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
-  if( pIter->nSeg==0 ){
-    assert( pIter->pTokenDataIter );
-    fts5TokendataIterNext(pIter, 1, iMatch);
-  }else{
-    fts5MultiIterNextFrom(pIter->pIndex, pIter, iMatch);
-  }
-  return fts5IndexReturn(pIter->pIndex);
-}
-
-/*
-** Return the current term.
-*/
-static const char *sqlite3Fts5IterTerm(Fts5IndexIter *pIndexIter, int *pn){
-  int n;
-  const char *z = (const char*)fts5MultiIterTerm((Fts5Iter*)pIndexIter, &n);
-  assert_nc( z || n<=1 );
-  *pn = n-1;
-  return (z ? &z[1] : 0);
-}
-
-/*
-** pIter is a prefix query. This function populates pIter->pTokenDataIter
-** with an Fts5TokenDataIter object containing mappings for all rows
-** matched by the query.
-*/
-static int fts5SetupPrefixIterTokendata(
-  Fts5Iter *pIter,
-  const char *pToken,             /* Token prefix to search for */
-  int nToken                      /* Size of pToken in bytes */
-){
-  Fts5Index *p = pIter->pIndex;
-  Fts5Buffer token = {0, 0, 0};
-  TokendataSetupCtx ctx;
-
-  memset(&ctx, 0, sizeof(ctx));
-
-  fts5BufferGrow(&p->rc, &token, nToken+1);
-  assert( token.p!=0 || p->rc!=SQLITE_OK );
-  ctx.pT = (Fts5TokenDataIter*)sqlite3Fts5MallocZero(&p->rc,
-                                                   SZ_FTS5TOKENDATAITER(1));
-
-  if( p->rc==SQLITE_OK ){
-
-    /* Fill in the token prefix to search for */
-    token.p[0] = FTS5_MAIN_PREFIX;
-    memcpy(&token.p[1], pToken, nToken);
-    token.n = nToken+1;
-
-    fts5VisitEntries(
-        p, 0, token.p, token.n, 1, prefixIterSetupTokendataCb, (void*)&ctx
-    );
-
-    fts5TokendataIterSortMap(p, ctx.pT);
-  }
-
-  if( p->rc==SQLITE_OK ){
-    pIter->pTokenDataIter = ctx.pT;
-  }else{
-    fts5TokendataIterDelete(ctx.pT);
-  }
-  fts5BufferFree(&token);
-
-  return fts5IndexReturn(p);
-}
-
-/*
-** This is used by xInstToken() to access the token at offset iOff, column
-** iCol of row iRowid. The token is returned via output variables *ppOut
-** and *pnOut. The iterator passed as the first argument must be a tokendata=1
-** iterator (pIter->pTokenDataIter!=0).
-**
-** pToken/nToken:
-*/
-static int sqlite3Fts5IterToken(
-  Fts5IndexIter *pIndexIter,
-  const char *pToken, int nToken,
-  i64 iRowid,
-  int iCol,
-  int iOff,
-  const char **ppOut, int *pnOut
-){
-  Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
-  Fts5TokenDataIter *pT = pIter->pTokenDataIter;
-  i64 iPos = (((i64)iCol)<<32) + iOff;
-  Fts5TokenDataMap *aMap = 0;
-  int i1 = 0;
-  int i2 = 0;
-  int iTest = 0;
-
-  assert( pT || (pToken && pIter->nSeg>0) );
-  if( pT==0 ){
-    int rc = fts5SetupPrefixIterTokendata(pIter, pToken, nToken);
-    if( rc!=SQLITE_OK ) return rc;
-    pT = pIter->pTokenDataIter;
-  }
-
-  i2 = pT->nMap;
-  aMap = pT->aMap;
-
-  while( i2>i1 ){
-    iTest = (i1 + i2) / 2;
-
-    if( aMap[iTest].iRowid<iRowid ){
-      i1 = iTest+1;
-    }else if( aMap[iTest].iRowid>iRowid ){
-      i2 = iTest;
-    }else{
-      if( aMap[iTest].iPos<iPos ){
-        if( aMap[iTest].iPos<0 ){
-          break;
-        }
-        i1 = iTest+1;
-      }else if( aMap[iTest].iPos>iPos ){
-        i2 = iTest;
-      }else{
-        break;
-      }
-    }
-  }
-
-  if( i2>i1 ){
-    if( pIter->nSeg==0 ){
-      Fts5Iter *pMap = pT->apIter[aMap[iTest].iIter];
-      *ppOut = (const char*)pMap->aSeg[0].term.p+1;
-      *pnOut = pMap->aSeg[0].term.n-1;
-    }else{
-      Fts5TokenDataMap *p = &aMap[iTest];
-      *ppOut = (const char*)&pT->terms.p[p->iIter];
-      *pnOut = aMap[iTest].nByte;
-    }
-  }
-
-  return SQLITE_OK;
-}
-
-/*
-** Clear any existing entries from the token-map associated with the
-** iterator passed as the only argument.
-*/
-static void sqlite3Fts5IndexIterClearTokendata(Fts5IndexIter *pIndexIter){
-  Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
-  if( pIter && pIter->pTokenDataIter
-   && (pIter->nSeg==0 || pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_FULL)
-  ){
-    pIter->pTokenDataIter->nMap = 0;
-  }
-}
-
-/*
-** Set a token-mapping for the iterator passed as the first argument. This
-** is used in detail=column or detail=none mode when a token is requested
-** using the xInstToken() API. In this case the caller tokenizers the
-** current row and configures the token-mapping via multiple calls to this
-** function.
-*/
-static int sqlite3Fts5IndexIterWriteTokendata(
-  Fts5IndexIter *pIndexIter,
-  const char *pToken, int nToken,
-  i64 iRowid, int iCol, int iOff
-){
-  Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
-  Fts5TokenDataIter *pT = pIter->pTokenDataIter;
-  Fts5Index *p = pIter->pIndex;
-  i64 iPos = (((i64)iCol)<<32) + iOff;
-
-  assert( p->pConfig->eDetail!=FTS5_DETAIL_FULL );
-  assert( pIter->pTokenDataIter || pIter->nSeg>0 );
-  if( pIter->nSeg>0 ){
-    /* This is a prefix term iterator. */
-    if( pT==0 ){
-      pT = (Fts5TokenDataIter*)sqlite3Fts5MallocZero(&p->rc,
-                                           SZ_FTS5TOKENDATAITER(1));
-      pIter->pTokenDataIter = pT;
-    }
-    if( pT ){
-      fts5TokendataIterAppendMap(p, pT, pT->terms.n, nToken, iRowid, iPos);
-      fts5BufferAppendBlob(&p->rc, &pT->terms, nToken, (const u8*)pToken);
-    }
-  }else{
-    int ii;
-    for(ii=0; ii<pT->nIter; ii++){
-      Fts5Buffer *pTerm = &pT->apIter[ii]->aSeg[0].term;
-      if( nToken==pTerm->n-1 && memcmp(pToken, pTerm->p+1, nToken)==0 ) break;
-    }
-    if( ii<pT->nIter ){
-      fts5TokendataIterAppendMap(p, pT, ii, 0, iRowid, iPos);
-    }
-  }
-  return fts5IndexReturn(p);
-}
-
-/*
-** Close an iterator opened by an earlier call to sqlite3Fts5IndexQuery().
-*/
-static void sqlite3Fts5IterClose(Fts5IndexIter *pIndexIter){
-  if( pIndexIter ){
-    Fts5Index *pIndex = ((Fts5Iter*)pIndexIter)->pIndex;
-    fts5IterClose(pIndexIter);
-    fts5IndexReturn(pIndex);
-  }
-}
-
-/*
-** Read and decode the "averages" record from the database.
-**
-** Parameter anSize must point to an array of size nCol, where nCol is
-** the number of user defined columns in the FTS table.
-*/
-static int sqlite3Fts5IndexGetAverages(Fts5Index *p, i64 *pnRow, i64 *anSize){
-  int nCol = p->pConfig->nCol;
-  Fts5Data *pData;
-
-  *pnRow = 0;
-  memset(anSize, 0, sizeof(i64) * nCol);
-  pData = fts5DataRead(p, FTS5_AVERAGES_ROWID);
-  if( p->rc==SQLITE_OK && pData->nn ){
-    int i = 0;
-    int iCol;
-    i += fts5GetVarint(&pData->p[i], (u64*)pnRow);
-    for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
-      i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
-    }
-  }
-
-  fts5DataRelease(pData);
-  return fts5IndexReturn(p);
-}
-
-/*
-** Replace the current "averages" record with the contents of the buffer
-** supplied as the second argument.
-*/
-static int sqlite3Fts5IndexSetAverages(Fts5Index *p, const u8 *pData, int nData){
-  assert( p->rc==SQLITE_OK );
-  fts5DataWrite(p, FTS5_AVERAGES_ROWID, pData, nData);
-  return fts5IndexReturn(p);
-}
-
-/*
-** Return the total number of blocks this module has read from the %_data
-** table since it was created.
-*/
-static int sqlite3Fts5IndexReads(Fts5Index *p){
-  return p->nRead;
-}
-
-/*
-** Set the 32-bit cookie value stored at the start of all structure
-** records to the value passed as the second argument.
-**
-** Return SQLITE_OK if successful, or an SQLite error code if an error
-** occurs.
-*/
-static int sqlite3Fts5IndexSetCookie(Fts5Index *p, int iNew){
-  int rc;                              /* Return code */
-  Fts5Config *pConfig = p->pConfig;    /* Configuration object */
-  u8 aCookie[4];                       /* Binary representation of iNew */
-  sqlite3_blob *pBlob = 0;
-
-  assert( p->rc==SQLITE_OK );
-  sqlite3Fts5Put32(aCookie, iNew);
-
-  rc = sqlite3_blob_open(pConfig->db, pConfig->zDb, p->zDataTbl,
-      "block", FTS5_STRUCTURE_ROWID, 1, &pBlob
-  );
-  if( rc==SQLITE_OK ){
-    sqlite3_blob_write(pBlob, aCookie, 4, 0);
-    rc = sqlite3_blob_close(pBlob);
-  }
-
-  return rc;
-}
-
-static int sqlite3Fts5IndexLoadConfig(Fts5Index *p){
-  Fts5Structure *pStruct;
-  pStruct = fts5StructureRead(p);
-  fts5StructureRelease(pStruct);
-  return fts5IndexReturn(p);
-}
-
-/*
-** Retrieve the origin value that will be used for the segment currently
-** being accumulated in the in-memory hash table when it is flushed to
-** disk. If successful, SQLITE_OK is returned and (*piOrigin) set to
-** the queried value. Or, if an error occurs, an error code is returned
-** and the final value of (*piOrigin) is undefined.
-*/
-static int sqlite3Fts5IndexGetOrigin(Fts5Index *p, i64 *piOrigin){
-  Fts5Structure *pStruct;
-  pStruct = fts5StructureRead(p);
-  if( pStruct ){
-    *piOrigin = pStruct->nOriginCntr;
-    fts5StructureRelease(pStruct);
-  }
-  return fts5IndexReturn(p);
-}
-
-/*
-** Buffer pPg contains a page of a tombstone hash table - one of nPg pages
-** associated with the same segment. This function adds rowid iRowid to
-** the hash table. The caller is required to guarantee that there is at
-** least one free slot on the page.
-**
-** If parameter bForce is false and the hash table is deemed to be full
-** (more than half of the slots are occupied), then non-zero is returned
-** and iRowid not inserted. Or, if bForce is true or if the hash table page
-** is not full, iRowid is inserted and zero returned.
-*/
-static int fts5IndexTombstoneAddToPage(
-  Fts5Data *pPg,
-  int bForce,
-  int nPg,
-  u64 iRowid
-){
-  const int szKey = TOMBSTONE_KEYSIZE(pPg);
-  const int nSlot = TOMBSTONE_NSLOT(pPg);
-  const int nElem = fts5GetU32(&pPg->p[4]);
-  int iSlot = (iRowid / nPg) % nSlot;
-  int nCollide = nSlot;
-
-  if( szKey==4 && iRowid>0xFFFFFFFF ) return 2;
-  if( iRowid==0 ){
-    pPg->p[1] = 0x01;
-    return 0;
-  }
-
-  if( bForce==0 && nElem>=(nSlot/2) ){
-    return 1;
-  }
-
-  fts5PutU32(&pPg->p[4], nElem+1);
-  if( szKey==4 ){
-    u32 *aSlot = (u32*)&pPg->p[8];
-    while( aSlot[iSlot] ){
-      iSlot = (iSlot + 1) % nSlot;
-      if( nCollide--==0 ) return 0;
-    }
-    fts5PutU32((u8*)&aSlot[iSlot], (u32)iRowid);
-  }else{
-    u64 *aSlot = (u64*)&pPg->p[8];
-    while( aSlot[iSlot] ){
-      iSlot = (iSlot + 1) % nSlot;
-      if( nCollide--==0 ) return 0;
-    }
-    fts5PutU64((u8*)&aSlot[iSlot], iRowid);
-  }
-
-  return 0;
-}
-
-/*
-** This function attempts to build a new hash containing all the keys
-** currently in the tombstone hash table for segment pSeg. The new
-** hash will be stored in the nOut buffers passed in array apOut[].
-** All pages of the new hash use key-size szKey (4 or 8).
-**
-** Return 0 if the hash is successfully rebuilt into the nOut pages.
-** Or non-zero if it is not (because one page became overfull). In this
-** case the caller should retry with a larger nOut parameter.
-**
-** Parameter pData1 is page iPg1 of the hash table being rebuilt.
-*/
-static int fts5IndexTombstoneRehash(
-  Fts5Index *p,
-  Fts5StructureSegment *pSeg,     /* Segment to rebuild hash of */
-  Fts5Data *pData1,               /* One page of current hash - or NULL */
-  int iPg1,                       /* Which page of the current hash is pData1 */
-  int szKey,                      /* 4 or 8, the keysize */
-  int nOut,                       /* Number of output pages */
-  Fts5Data **apOut                /* Array of output hash pages */
-){
-  int ii;
-  int res = 0;
-
-  /* Initialize the headers of all the output pages */
-  for(ii=0; ii<nOut; ii++){
-    apOut[ii]->p[0] = szKey;
-    fts5PutU32(&apOut[ii]->p[4], 0);
-  }
-
-  /* Loop through the current pages of the hash table. */
-  for(ii=0; res==0 && ii<pSeg->nPgTombstone; ii++){
-    Fts5Data *pData = 0;          /* Page ii of the current hash table */
-    Fts5Data *pFree = 0;          /* Free this at the end of the loop */
-
-    if( iPg1==ii ){
-      pData = pData1;
-    }else{
-      pFree = pData = fts5DataRead(p, FTS5_TOMBSTONE_ROWID(pSeg->iSegid, ii));
-    }
-
-    if( pData ){
-      int szKeyIn = TOMBSTONE_KEYSIZE(pData);
-      int nSlotIn = (pData->nn - 8) / szKeyIn;
-      int iIn;
-      for(iIn=0; iIn<nSlotIn; iIn++){
-        u64 iVal = 0;
-
-        /* Read the value from slot iIn of the input page into iVal. */
-        if( szKeyIn==4 ){
-          u32 *aSlot = (u32*)&pData->p[8];
-          if( aSlot[iIn] ) iVal = fts5GetU32((u8*)&aSlot[iIn]);
-        }else{
-          u64 *aSlot = (u64*)&pData->p[8];
-          if( aSlot[iIn] ) iVal = fts5GetU64((u8*)&aSlot[iIn]);
-        }
-
-        /* If iVal is not 0 at this point, insert it into the new hash table */
-        if( iVal ){
-          Fts5Data *pPg = apOut[(iVal % nOut)];
-          res = fts5IndexTombstoneAddToPage(pPg, 0, nOut, iVal);
-          if( res ) break;
-        }
-      }
-
-      /* If this is page 0 of the old hash, copy the rowid-0-flag from the
-      ** old hash to the new.  */
-      if( ii==0 ){
-        apOut[0]->p[1] = pData->p[1];
-      }
-    }
-    fts5DataRelease(pFree);
-  }
-
-  return res;
-}
-
-/*
-** This is called to rebuild the hash table belonging to segment pSeg.
-** If parameter pData1 is not NULL, then one page of the existing hash table
-** has already been loaded - pData1, which is page iPg1. The key-size for
-** the new hash table is szKey (4 or 8).
-**
-** If successful, the new hash table is not written to disk. Instead,
-** output parameter (*pnOut) is set to the number of pages in the new
-** hash table, and (*papOut) to point to an array of buffers containing
-** the new page data.
-**
-** If an error occurs, an error code is left in the Fts5Index object and
-** both output parameters set to 0 before returning.
-*/
-static void fts5IndexTombstoneRebuild(
-  Fts5Index *p,
-  Fts5StructureSegment *pSeg,     /* Segment to rebuild hash of */
-  Fts5Data *pData1,               /* One page of current hash - or NULL */
-  int iPg1,                       /* Which page of the current hash is pData1 */
-  int szKey,                      /* 4 or 8, the keysize */
-  int *pnOut,                     /* OUT: Number of output pages */
-  Fts5Data ***papOut              /* OUT: Output hash pages */
-){
-  const int MINSLOT = 32;
-  int nSlotPerPage = MAX(MINSLOT, (p->pConfig->pgsz - 8) / szKey);
-  int nSlot = 0;                  /* Number of slots in each output page */
-  int nOut = 0;
-
-  /* Figure out how many output pages (nOut) and how many slots per
-  ** page (nSlot).  There are three possibilities:
-  **
-  **   1. The hash table does not yet exist. In this case the new hash
-  **      table will consist of a single page with MINSLOT slots.
-  **
-  **   2. The hash table exists but is currently a single page. In this
-  **      case an attempt is made to grow the page to accommodate the new
-  **      entry. The page is allowed to grow up to nSlotPerPage (see above)
-  **      slots.
-  **
-  **   3. The hash table already consists of more than one page, or of
-  **      a single page already so large that it cannot be grown. In this
-  **      case the new hash consists of (nPg*2+1) pages of nSlotPerPage
-  **      slots each, where nPg is the current number of pages in the
-  **      hash table.
-  */
-  if( pSeg->nPgTombstone==0 ){
-    /* Case 1. */
-    nOut = 1;
-    nSlot = MINSLOT;
-  }else if( pSeg->nPgTombstone==1 ){
-    /* Case 2. */
-    int nElem = (int)fts5GetU32(&pData1->p[4]);
-    assert( pData1 && iPg1==0 );
-    nOut = 1;
-    nSlot = MAX(nElem*4, MINSLOT);
-    if( nSlot>nSlotPerPage ) nOut = 0;
-  }
-  if( nOut==0 ){
-    /* Case 3. */
-    nOut = (pSeg->nPgTombstone * 2 + 1);
-    nSlot = nSlotPerPage;
-  }
-
-  /* Allocate the required array and output pages */
-  while( 1 ){
-    int res = 0;
-    int ii = 0;
-    int szPage = 0;
-    Fts5Data **apOut = 0;
-
-    /* Allocate space for the new hash table */
-    assert( nSlot>=MINSLOT );
-    apOut = (Fts5Data**)sqlite3Fts5MallocZero(&p->rc, sizeof(Fts5Data*) * nOut);
-    szPage = 8 + nSlot*szKey;
-    for(ii=0; ii<nOut; ii++){
-      Fts5Data *pNew = (Fts5Data*)sqlite3Fts5MallocZero(&p->rc,
-          sizeof(Fts5Data)+szPage
-      );
-      if( pNew ){
-        pNew->nn = szPage;
-        pNew->p = (u8*)&pNew[1];
-        apOut[ii] = pNew;
-      }
-    }
-
-    /* Rebuild the hash table. */
-    if( p->rc==SQLITE_OK ){
-      res = fts5IndexTombstoneRehash(p, pSeg, pData1, iPg1, szKey, nOut, apOut);
-    }
-    if( res==0 ){
-      if( p->rc ){
-        fts5IndexFreeArray(apOut, nOut);
-        apOut = 0;
-        nOut = 0;
-      }
-      *pnOut = nOut;
-      *papOut = apOut;
-      break;
-    }
-
-    /* If control flows to here, it was not possible to rebuild the hash
-    ** table. Free all buffers and then try again with more pages. */
-    assert( p->rc==SQLITE_OK );
-    fts5IndexFreeArray(apOut, nOut);
-    nSlot = nSlotPerPage;
-    nOut = nOut*2 + 1;
-  }
-}
-
-
-/*
-** Add a tombstone for rowid iRowid to segment pSeg.
-*/
-static void fts5IndexTombstoneAdd(
-  Fts5Index *p,
-  Fts5StructureSegment *pSeg,
-  u64 iRowid
-){
-  Fts5Data *pPg = 0;
-  int iPg = -1;
-  int szKey = 0;
-  int nHash = 0;
-  Fts5Data **apHash = 0;
-
-  p->nContentlessDelete++;
-
-  if( pSeg->nPgTombstone>0 ){
-    iPg = iRowid % pSeg->nPgTombstone;
-    pPg = fts5DataRead(p, FTS5_TOMBSTONE_ROWID(pSeg->iSegid,iPg));
-    if( pPg==0 ){
-      assert( p->rc!=SQLITE_OK );
-      return;
-    }
-
-    if( 0==fts5IndexTombstoneAddToPage(pPg, 0, pSeg->nPgTombstone, iRowid) ){
-      fts5DataWrite(p, FTS5_TOMBSTONE_ROWID(pSeg->iSegid,iPg), pPg->p, pPg->nn);
-      fts5DataRelease(pPg);
-      return;
-    }
-  }
-
-  /* Have to rebuild the hash table. First figure out the key-size (4 or 8). */
-  szKey = pPg ? TOMBSTONE_KEYSIZE(pPg) : 4;
-  if( iRowid>0xFFFFFFFF ) szKey = 8;
-
-  /* Rebuild the hash table */
-  fts5IndexTombstoneRebuild(p, pSeg, pPg, iPg, szKey, &nHash, &apHash);
-  assert( p->rc==SQLITE_OK || (nHash==0 && apHash==0) );
-
-  /* If all has succeeded, write the new rowid into one of the new hash
-  ** table pages, then write them all out to disk. */
-  if( nHash ){
-    int ii = 0;
-    fts5IndexTombstoneAddToPage(apHash[iRowid % nHash], 1, nHash, iRowid);
-    for(ii=0; ii<nHash; ii++){
-      i64 iTombstoneRowid = FTS5_TOMBSTONE_ROWID(pSeg->iSegid, ii);
-      fts5DataWrite(p, iTombstoneRowid, apHash[ii]->p, apHash[ii]->nn);
-    }
-    pSeg->nPgTombstone = nHash;
-    fts5StructureWrite(p, p->pStruct);
-  }
-
-  fts5DataRelease(pPg);
-  fts5IndexFreeArray(apHash, nHash);
-}
-
-/*
-** Add iRowid to the tombstone list of the segment or segments that contain
-** rows from origin iOrigin. Return SQLITE_OK if successful, or an SQLite
-** error code otherwise.
-*/
-static int sqlite3Fts5IndexContentlessDelete(Fts5Index *p, i64 iOrigin, i64 iRowid){
-  Fts5Structure *pStruct;
-  pStruct = fts5StructureRead(p);
-  if( pStruct ){
-    int bFound = 0;               /* True after pSeg->nEntryTombstone incr. */
-    int iLvl;
-    for(iLvl=pStruct->nLevel-1; iLvl>=0; iLvl--){
-      int iSeg;
-      for(iSeg=pStruct->aLevel[iLvl].nSeg-1; iSeg>=0; iSeg--){
-        Fts5StructureSegment *pSeg = &pStruct->aLevel[iLvl].aSeg[iSeg];
-        if( pSeg->iOrigin1<=(u64)iOrigin && pSeg->iOrigin2>=(u64)iOrigin ){
-          if( bFound==0 ){
-            pSeg->nEntryTombstone++;
-            bFound = 1;
-          }
-          fts5IndexTombstoneAdd(p, pSeg, iRowid);
-        }
-      }
-    }
-    fts5StructureRelease(pStruct);
-  }
-  return fts5IndexReturn(p);
-}
-
-/*************************************************************************
-**************************************************************************
-** Below this point is the implementation of the integrity-check
-** functionality.
-*/
-
-/*
-** Return a simple checksum value based on the arguments.
-*/
-static u64 sqlite3Fts5IndexEntryCksum(
-  i64 iRowid,
-  int iCol,
-  int iPos,
-  int iIdx,
-  const char *pTerm,
-  int nTerm
-){
-  int i;
-  u64 ret = iRowid;
-  ret += (ret<<3) + iCol;
-  ret += (ret<<3) + iPos;
-  if( iIdx>=0 ) ret += (ret<<3) + (FTS5_MAIN_PREFIX + iIdx);
-  for(i=0; i<nTerm; i++) ret += (ret<<3) + pTerm[i];
-  return ret;
-}
-
-#ifdef SQLITE_DEBUG
-/*
-** This function is purely an internal test. It does not contribute to
-** FTS functionality, or even the integrity-check, in any way.
-**
-** Instead, it tests that the same set of pgno/rowid combinations are
-** visited regardless of whether the doclist-index identified by parameters
-** iSegid/iLeaf is iterated in forwards or reverse order.
-*/
-static void fts5TestDlidxReverse(
-  Fts5Index *p,
-  int iSegid,                     /* Segment id to load from */
-  int iLeaf                       /* Load doclist-index for this leaf */
-){
-  Fts5DlidxIter *pDlidx = 0;
-  u64 cksum1 = 13;
-  u64 cksum2 = 13;
-
-  for(pDlidx=fts5DlidxIterInit(p, 0, iSegid, iLeaf);
-      fts5DlidxIterEof(p, pDlidx)==0;
-      fts5DlidxIterNext(p, pDlidx)
-  ){
-    i64 iRowid = fts5DlidxIterRowid(pDlidx);
-    int pgno = fts5DlidxIterPgno(pDlidx);
-    assert( pgno>iLeaf );
-    cksum1 += iRowid + ((i64)pgno<<32);
-  }
-  fts5DlidxIterFree(pDlidx);
-  pDlidx = 0;
-
-  for(pDlidx=fts5DlidxIterInit(p, 1, iSegid, iLeaf);
-      fts5DlidxIterEof(p, pDlidx)==0;
-      fts5DlidxIterPrev(p, pDlidx)
-  ){
-    i64 iRowid = fts5DlidxIterRowid(pDlidx);
-    int pgno = fts5DlidxIterPgno(pDlidx);
-    assert( fts5DlidxIterPgno(pDlidx)>iLeaf );
-    cksum2 += iRowid + ((i64)pgno<<32);
-  }
-  fts5DlidxIterFree(pDlidx);
-  pDlidx = 0;
-
-  if( p->rc==SQLITE_OK && cksum1!=cksum2 ) p->rc = FTS5_CORRUPT;
-}
-
-static int fts5QueryCksum(
-  Fts5Index *p,                   /* Fts5 index object */
-  int iIdx,
-  const char *z,                  /* Index key to query for */
-  int n,                          /* Size of index key in bytes */
-  int flags,                      /* Flags for Fts5IndexQuery */
-  u64 *pCksum                     /* IN/OUT: Checksum value */
-){
-  int eDetail = p->pConfig->eDetail;
-  u64 cksum = *pCksum;
-  Fts5IndexIter *pIter = 0;
-  int rc = sqlite3Fts5IndexQuery(
-      p, z, n, (flags | FTS5INDEX_QUERY_NOTOKENDATA), 0, &pIter
-  );
-
-  while( rc==SQLITE_OK && ALWAYS(pIter!=0) && 0==sqlite3Fts5IterEof(pIter) ){
-    i64 rowid = pIter->iRowid;
-
-    if( eDetail==FTS5_DETAIL_NONE ){
-      cksum ^= sqlite3Fts5IndexEntryCksum(rowid, 0, 0, iIdx, z, n);
-    }else{
-      Fts5PoslistReader sReader;
-      for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
-          sReader.bEof==0;
-          sqlite3Fts5PoslistReaderNext(&sReader)
-      ){
-        int iCol = FTS5_POS2COLUMN(sReader.iPos);
-        int iOff = FTS5_POS2OFFSET(sReader.iPos);
-        cksum ^= sqlite3Fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
-      }
-    }
-    if( rc==SQLITE_OK ){
-      rc = sqlite3Fts5IterNext(pIter);
-    }
-  }
-  fts5IterClose(pIter);
-
-  *pCksum = cksum;
-  return rc;
-}
-
-/*
-** Check if buffer z[], size n bytes, contains as series of valid utf-8
-** encoded codepoints. If so, return 0. Otherwise, if the buffer does not
-** contain valid utf-8, return non-zero.
-*/
-static int fts5TestUtf8(const char *z, int n){
-  int i = 0;
-  assert_nc( n>0 );
-  while( i<n ){
-    if( (z[i] & 0x80)==0x00 ){
-      i++;
-    }else
-    if( (z[i] & 0xE0)==0xC0 ){
-      if( i+1>=n || (z[i+1] & 0xC0)!=0x80 ) return 1;
-      i += 2;
-    }else
-    if( (z[i] & 0xF0)==0xE0 ){
-      if( i+2>=n || (z[i+1] & 0xC0)!=0x80 || (z[i+2] & 0xC0)!=0x80 ) return 1;
-      i += 3;
-    }else
-    if( (z[i] & 0xF8)==0xF0 ){
-      if( i+3>=n || (z[i+1] & 0xC0)!=0x80 || (z[i+2] & 0xC0)!=0x80 ) return 1;
-      if( (z[i+2] & 0xC0)!=0x80 ) return 1;
-      i += 3;
-    }else{
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-/*
-** This function is also purely an internal test. It does not contribute to
-** FTS functionality, or even the integrity-check, in any way.
-**
-** This function sets output variable (*pbFail) to true if the test fails. Or
-** leaves it unchanged if the test succeeds.
-*/
-static void fts5TestTerm(
-  Fts5Index *p,
-  Fts5Buffer *pPrev,              /* Previous term */
-  const char *z, int n,           /* Possibly new term to test */
-  u64 expected,
-  u64 *pCksum,
-  int *pbFail
-){
-  int rc = p->rc;
-  if( pPrev->n==0 ){
-    fts5BufferSet(&rc, pPrev, n, (const u8*)z);
-  }else
-  if( *pbFail==0
-   && rc==SQLITE_OK
-   && (pPrev->n!=n || memcmp(pPrev->p, z, n))
-   && (p->pHash==0 || p->pHash->nEntry==0)
-  ){
-    u64 cksum3 = *pCksum;
-    const char *zTerm = (const char*)&pPrev->p[1];  /* term sans prefix-byte */
-    int nTerm = pPrev->n-1;            /* Size of zTerm in bytes */
-    int iIdx = (pPrev->p[0] - FTS5_MAIN_PREFIX);
-    int flags = (iIdx==0 ? 0 : FTS5INDEX_QUERY_PREFIX);
-    u64 ck1 = 0;
-    u64 ck2 = 0;
-
-    /* Check that the results returned for ASC and DESC queries are
-    ** the same. If not, call this corruption.  */
-    rc = fts5QueryCksum(p, iIdx, zTerm, nTerm, flags, &ck1);
-    if( rc==SQLITE_OK ){
-      int f = flags|FTS5INDEX_QUERY_DESC;
-      rc = fts5QueryCksum(p, iIdx, zTerm, nTerm, f, &ck2);
-    }
-    if( rc==SQLITE_OK && ck1!=ck2 ) rc = FTS5_CORRUPT;
-
-    /* If this is a prefix query, check that the results returned if the
-    ** the index is disabled are the same. In both ASC and DESC order.
-    **
-    ** This check may only be performed if the hash table is empty. This
-    ** is because the hash table only supports a single scan query at
-    ** a time, and the multi-iter loop from which this function is called
-    ** is already performing such a scan.
-    **
-    ** Also only do this if buffer zTerm contains nTerm bytes of valid
-    ** utf-8. Otherwise, the last part of the buffer contents might contain
-    ** a non-utf-8 sequence that happens to be a prefix of a valid utf-8
-    ** character stored in the main fts index, which will cause the
-    ** test to fail.  */
-    if( p->nPendingData==0 && 0==fts5TestUtf8(zTerm, nTerm) ){
-      if( iIdx>0 && rc==SQLITE_OK ){
-        int f = flags|FTS5INDEX_QUERY_TEST_NOIDX;
-        ck2 = 0;
-        rc = fts5QueryCksum(p, iIdx, zTerm, nTerm, f, &ck2);
-        if( rc==SQLITE_OK && ck1!=ck2 ) rc = FTS5_CORRUPT;
-      }
-      if( iIdx>0 && rc==SQLITE_OK ){
-        int f = flags|FTS5INDEX_QUERY_TEST_NOIDX|FTS5INDEX_QUERY_DESC;
-        ck2 = 0;
-        rc = fts5QueryCksum(p, iIdx, zTerm, nTerm, f, &ck2);
-        if( rc==SQLITE_OK && ck1!=ck2 ) rc = FTS5_CORRUPT;
-      }
-    }
-
-    cksum3 ^= ck1;
-    fts5BufferSet(&rc, pPrev, n, (const u8*)z);
-
-    if( rc==SQLITE_OK && cksum3!=expected ){
-      *pbFail = 1;
-    }
-    *pCksum = cksum3;
-  }
-  p->rc = rc;
-}
-
-#else
-# define fts5TestDlidxReverse(x,y,z)
-# define fts5TestTerm(t,u,v,w,x,y,z)
-#endif
-
-/*
-** Check that:
-**
-**   1) All leaves of pSeg between iFirst and iLast (inclusive) exist and
-**      contain zero terms.
-**   2) All leaves of pSeg between iNoRowid and iLast (inclusive) exist and
-**      contain zero rowids.
-*/
-static void fts5IndexIntegrityCheckEmpty(
-  Fts5Index *p,
-  Fts5StructureSegment *pSeg,     /* Segment to check internal consistency */
-  int iFirst,
-  int iNoRowid,
-  int iLast
-){
-  int i;
-
-  /* Now check that the iter.nEmpty leaves following the current leaf
-  ** (a) exist and (b) contain no terms. */
-  for(i=iFirst; p->rc==SQLITE_OK && i<=iLast; i++){
-    Fts5Data *pLeaf = fts5DataRead(p, FTS5_SEGMENT_ROWID(pSeg->iSegid, i));
-    if( pLeaf ){
-      if( !fts5LeafIsTermless(pLeaf)
-       || (i>=iNoRowid && 0!=fts5LeafFirstRowidOff(pLeaf))
-      ){
-        FTS5_CORRUPT_ROWID(p, FTS5_SEGMENT_ROWID(pSeg->iSegid, i));
-      }
-    }
-    fts5DataRelease(pLeaf);
-  }
-}
-
-static void fts5IntegrityCheckPgidx(Fts5Index *p, i64 iRowid, Fts5Data *pLeaf){
-  i64 iTermOff = 0;
-  int ii;
-
-  Fts5Buffer buf1 = {0,0,0};
-  Fts5Buffer buf2 = {0,0,0};
-
-  ii = pLeaf->szLeaf;
-  while( ii<pLeaf->nn && p->rc==SQLITE_OK ){
-    int res;
-    i64 iOff;
-    int nIncr;
-
-    ii += fts5GetVarint32(&pLeaf->p[ii], nIncr);
-    iTermOff += nIncr;
-    iOff = iTermOff;
-
-    if( iOff>=pLeaf->szLeaf ){
-      FTS5_CORRUPT_ROWID(p, iRowid);
-    }else if( iTermOff==nIncr ){
-      int nByte;
-      iOff += fts5GetVarint32(&pLeaf->p[iOff], nByte);
-      if( (iOff+nByte)>pLeaf->szLeaf ){
-        FTS5_CORRUPT_ROWID(p, iRowid);
-      }else{
-        fts5BufferSet(&p->rc, &buf1, nByte, &pLeaf->p[iOff]);
-      }
-    }else{
-      int nKeep, nByte;
-      iOff += fts5GetVarint32(&pLeaf->p[iOff], nKeep);
-      iOff += fts5GetVarint32(&pLeaf->p[iOff], nByte);
-      if( nKeep>buf1.n || (iOff+nByte)>pLeaf->szLeaf ){
-        FTS5_CORRUPT_ROWID(p, iRowid);
-      }else{
-        buf1.n = nKeep;
-        fts5BufferAppendBlob(&p->rc, &buf1, nByte, &pLeaf->p[iOff]);
-      }
-
-      if( p->rc==SQLITE_OK ){
-        res = fts5BufferCompare(&buf1, &buf2);
-        if( res<=0 ) FTS5_CORRUPT_ROWID(p, iRowid);
-      }
-    }
-    fts5BufferSet(&p->rc, &buf2, buf1.n, buf1.p);
-  }
-
-  fts5BufferFree(&buf1);
-  fts5BufferFree(&buf2);
-}
-
-static void fts5IndexIntegrityCheckSegment(
-  Fts5Index *p,                   /* FTS5 backend object */
-  Fts5StructureSegment *pSeg      /* Segment to check internal consistency */
-){
-  Fts5Config *pConfig = p->pConfig;
-  int bSecureDelete = (pConfig->iVersion==FTS5_CURRENT_VERSION_SECUREDELETE);
-  sqlite3_stmt *pStmt = 0;
-  int rc2;
-  int iIdxPrevLeaf = pSeg->pgnoFirst-1;
-  int iDlidxPrevLeaf = pSeg->pgnoLast;
-
-  if( pSeg->pgnoFirst==0 ) return;
-
-  fts5IndexPrepareStmt(p, &pStmt, sqlite3_mprintf(
-      "SELECT segid, term, (pgno>>1), (pgno&1) FROM %Q.'%q_idx' WHERE segid=%d "
-      "ORDER BY 1, 2",
-      pConfig->zDb, pConfig->zName, pSeg->iSegid
-  ));
-
-  /* Iterate through the b-tree hierarchy.  */
-  while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
-    i64 iRow;                     /* Rowid for this leaf */
-    Fts5Data *pLeaf;              /* Data for this leaf */
-
-    const char *zIdxTerm = (const char*)sqlite3_column_blob(pStmt, 1);
-    int nIdxTerm = sqlite3_column_bytes(pStmt, 1);
-    int iIdxLeaf = sqlite3_column_int(pStmt, 2);
-    int bIdxDlidx = sqlite3_column_int(pStmt, 3);
-
-    /* If the leaf in question has already been trimmed from the segment,
-    ** ignore this b-tree entry. Otherwise, load it into memory. */
-    if( iIdxLeaf<pSeg->pgnoFirst ) continue;
-    iRow = FTS5_SEGMENT_ROWID(pSeg->iSegid, iIdxLeaf);
-    pLeaf = fts5LeafRead(p, iRow);
-    if( pLeaf==0 ) break;
-
-    /* Check that the leaf contains at least one term, and that it is equal
-    ** to or larger than the split-key in zIdxTerm.  Also check that if there
-    ** is also a rowid pointer within the leaf page header, it points to a
-    ** location before the term.  */
-    if( pLeaf->nn<=pLeaf->szLeaf ){
-
-      if( nIdxTerm==0
-       && pConfig->iVersion==FTS5_CURRENT_VERSION_SECUREDELETE
-       && pLeaf->nn==pLeaf->szLeaf
-       && pLeaf->nn==4
-      ){
-        /* special case - the very first page in a segment keeps its %_idx
-        ** entry even if all the terms are removed from it by secure-delete
-        ** operations. */
-      }else{
-        FTS5_CORRUPT_ROWID(p, iRow);
-      }
-
-    }else{
-      int iOff;                   /* Offset of first term on leaf */
-      int iRowidOff;              /* Offset of first rowid on leaf */
-      int nTerm;                  /* Size of term on leaf in bytes */
-      int res;                    /* Comparison of term and split-key */
-
-      iOff = fts5LeafFirstTermOff(pLeaf);
-      iRowidOff = fts5LeafFirstRowidOff(pLeaf);
-      if( iRowidOff>=iOff || iOff>=pLeaf->szLeaf ){
-        FTS5_CORRUPT_ROWID(p, iRow);
-      }else{
-        iOff += fts5GetVarint32(&pLeaf->p[iOff], nTerm);
-        res = fts5Memcmp(&pLeaf->p[iOff], zIdxTerm, MIN(nTerm, nIdxTerm));
-        if( res==0 ) res = nTerm - nIdxTerm;
-        if( res<0 ) FTS5_CORRUPT_ROWID(p, iRow);
-      }
-
-      fts5IntegrityCheckPgidx(p, iRow, pLeaf);
-    }
-    fts5DataRelease(pLeaf);
-    if( p->rc ) break;
-
-    /* Now check that the iter.nEmpty leaves following the current leaf
-    ** (a) exist and (b) contain no terms. */
-    fts5IndexIntegrityCheckEmpty(
-        p, pSeg, iIdxPrevLeaf+1, iDlidxPrevLeaf+1, iIdxLeaf-1
-    );
-    if( p->rc ) break;
-
-    /* If there is a doclist-index, check that it looks right. */
-    if( bIdxDlidx ){
-      Fts5DlidxIter *pDlidx = 0;  /* For iterating through doclist index */
-      int iPrevLeaf = iIdxLeaf;
-      int iSegid = pSeg->iSegid;
-      int iPg = 0;
-      i64 iKey;
-
-      for(pDlidx=fts5DlidxIterInit(p, 0, iSegid, iIdxLeaf);
-          fts5DlidxIterEof(p, pDlidx)==0;
-          fts5DlidxIterNext(p, pDlidx)
-      ){
-
-        /* Check any rowid-less pages that occur before the current leaf. */
-        for(iPg=iPrevLeaf+1; iPg<fts5DlidxIterPgno(pDlidx); iPg++){
-          iKey = FTS5_SEGMENT_ROWID(iSegid, iPg);
-          pLeaf = fts5DataRead(p, iKey);
-          if( pLeaf ){
-            if( fts5LeafFirstRowidOff(pLeaf)!=0 ) FTS5_CORRUPT_ROWID(p, iKey);
-            fts5DataRelease(pLeaf);
-          }
-        }
-        iPrevLeaf = fts5DlidxIterPgno(pDlidx);
-
-        /* Check that the leaf page indicated by the iterator really does
-        ** contain the rowid suggested by the same. */
-        iKey = FTS5_SEGMENT_ROWID(iSegid, iPrevLeaf);
-        pLeaf = fts5DataRead(p, iKey);
-        if( pLeaf ){
-          i64 iRowid;
-          int iRowidOff = fts5LeafFirstRowidOff(pLeaf);
-          ASSERT_SZLEAF_OK(pLeaf);
-          if( iRowidOff>=pLeaf->szLeaf ){
-            FTS5_CORRUPT_ROWID(p, iKey);
-          }else if( bSecureDelete==0 || iRowidOff>0 ){
-            i64 iDlRowid = fts5DlidxIterRowid(pDlidx);
-            fts5GetVarint(&pLeaf->p[iRowidOff], (u64*)&iRowid);
-            if( iRowid<iDlRowid || (bSecureDelete==0 && iRowid!=iDlRowid) ){
-              FTS5_CORRUPT_ROWID(p, iKey);
-            }
-          }
-          fts5DataRelease(pLeaf);
-        }
-      }
-
-      iDlidxPrevLeaf = iPg;
-      fts5DlidxIterFree(pDlidx);
-      fts5TestDlidxReverse(p, iSegid, iIdxLeaf);
-    }else{
-      iDlidxPrevLeaf = pSeg->pgnoLast;
-      /* TODO: Check there is no doclist index */
-    }
-
-    iIdxPrevLeaf = iIdxLeaf;
-  }
-
-  rc2 = sqlite3_finalize(pStmt);
-  if( p->rc==SQLITE_OK ) p->rc = rc2;
-
-  /* Page iter.iLeaf must now be the rightmost leaf-page in the segment */
-#if 0
-  if( p->rc==SQLITE_OK && iter.iLeaf!=pSeg->pgnoLast ){
-    p->rc = FTS5_CORRUPT;
-  }
-#endif
-}
-
-
-/*
-** Run internal checks to ensure that the FTS index (a) is internally
-** consistent and (b) contains entries for which the XOR of the checksums
-** as calculated by sqlite3Fts5IndexEntryCksum() is cksum.
-**
-** Return SQLITE_CORRUPT if any of the internal checks fail, or if the
-** checksum does not match. Return SQLITE_OK if all checks pass without
-** error, or some other SQLite error code if another error (e.g. OOM)
-** occurs.
-*/
-static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum, int bUseCksum){
-  int eDetail = p->pConfig->eDetail;
-  u64 cksum2 = 0;                 /* Checksum based on contents of indexes */
-  Fts5Buffer poslist = {0,0,0};   /* Buffer used to hold a poslist */
-  Fts5Iter *pIter;                /* Used to iterate through entire index */
-  Fts5Structure *pStruct;         /* Index structure */
-  int iLvl, iSeg;
-
-#ifdef SQLITE_DEBUG
-  /* Used by extra internal tests only run if NDEBUG is not defined */
-  u64 cksum3 = 0;                 /* Checksum based on contents of indexes */
-  Fts5Buffer term = {0,0,0};      /* Buffer used to hold most recent term */
-  int bTestFail = 0;
-#endif
-  const int flags = FTS5INDEX_QUERY_NOOUTPUT;
-
-  /* Load the FTS index structure */
-  pStruct = fts5StructureRead(p);
-  if( pStruct==0 ){
-    assert( p->rc!=SQLITE_OK );
-    return fts5IndexReturn(p);
-  }
-
-  /* Check that the internal nodes of each segment match the leaves */
-  for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
-    for(iSeg=0; iSeg<pStruct->aLevel[iLvl].nSeg; iSeg++){
-      Fts5StructureSegment *pSeg = &pStruct->aLevel[iLvl].aSeg[iSeg];
-      fts5IndexIntegrityCheckSegment(p, pSeg);
-    }
-  }
-
-  /* The cksum argument passed to this function is a checksum calculated
-  ** based on all expected entries in the FTS index (including prefix index
-  ** entries). This block checks that a checksum calculated based on the
-  ** actual contents of FTS index is identical.
-  **
-  ** Two versions of the same checksum are calculated. The first (stack
-  ** variable cksum2) based on entries extracted from the full-text index
-  ** while doing a linear scan of each individual index in turn.
-  **
-  ** As each term visited by the linear scans, a separate query for the
-  ** same term is performed. cksum3 is calculated based on the entries
-  ** extracted by these queries.
-  */
-  for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, -1, 0, &pIter);
-      fts5MultiIterEof(p, pIter)==0;
-      fts5MultiIterNext(p, pIter, 0, 0)
-  ){
-    int n;                      /* Size of term in bytes */
-    i64 iPos = 0;               /* Position read from poslist */
-    int iOff = 0;               /* Offset within poslist */
-    i64 iRowid = fts5MultiIterRowid(pIter);
-    char *z = (char*)fts5MultiIterTerm(pIter, &n);
-
-    /* If this is a new term, query for it. Update cksum3 with the results. */
-    fts5TestTerm(p, &term, z, n, cksum2, &cksum3, &bTestFail);
-    if( p->rc ) break;
-
-    if( eDetail==FTS5_DETAIL_NONE ){
-      if( 0==fts5MultiIterIsEmpty(p, pIter) ){
-        cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, 0, 0, -1, z, n);
-      }
-    }else{
-      poslist.n = 0;
-      fts5SegiterPoslist(p, &pIter->aSeg[pIter->aFirst[1].iFirst], 0, &poslist);
-      fts5BufferAppendBlob(&p->rc, &poslist, 4, (const u8*)"\0\0\0\0");
-      while( 0==sqlite3Fts5PoslistNext64(poslist.p, poslist.n, &iOff, &iPos) ){
-        int iCol = FTS5_POS2COLUMN(iPos);
-        int iTokOff = FTS5_POS2OFFSET(iPos);
-        cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
-      }
-    }
-  }
-  fts5TestTerm(p, &term, 0, 0, cksum2, &cksum3, &bTestFail);
-
-  fts5MultiIterFree(pIter);
-  if( p->rc==SQLITE_OK && bUseCksum && cksum!=cksum2 ){
-    p->rc = FTS5_CORRUPT;
-    sqlite3Fts5ConfigErrmsg(p->pConfig,
-        "fts5: checksum mismatch for table \"%s\"", p->pConfig->zName
-    );
-  }
-#ifdef SQLITE_DEBUG
-  /* In SQLITE_DEBUG builds, expensive extra checks were run as part of
-  ** the integrity-check above. If no other errors were detected, but one
-  ** of these tests failed, set the result to SQLITE_CORRUPT_VTAB here. */
-  if( p->rc==SQLITE_OK && bTestFail ){
-    p->rc = FTS5_CORRUPT;
-  }
-  fts5BufferFree(&term);
-#endif
-
-  fts5StructureRelease(pStruct);
-  fts5BufferFree(&poslist);
-  return fts5IndexReturn(p);
-}
-
-/*************************************************************************
-**************************************************************************
-** Below this point is the implementation of the fts5_decode() scalar
-** function only.
-*/
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-/*
-** Decode a segment-data rowid from the %_data table. This function is
-** the opposite of macro FTS5_SEGMENT_ROWID().
-*/
-static void fts5DecodeRowid(
-  i64 iRowid,                     /* Rowid from %_data table */
-  int *pbTombstone,               /* OUT: Tombstone hash flag */
-  int *piSegid,                   /* OUT: Segment id */
-  int *pbDlidx,                   /* OUT: Dlidx flag */
-  int *piHeight,                  /* OUT: Height */
-  int *piPgno                     /* OUT: Page number */
-){
-  *piPgno = (int)(iRowid & (((i64)1 << FTS5_DATA_PAGE_B) - 1));
-  iRowid >>= FTS5_DATA_PAGE_B;
-
-  *piHeight = (int)(iRowid & (((i64)1 << FTS5_DATA_HEIGHT_B) - 1));
-  iRowid >>= FTS5_DATA_HEIGHT_B;
-
-  *pbDlidx = (int)(iRowid & 0x0001);
-  iRowid >>= FTS5_DATA_DLI_B;
-
-  *piSegid = (int)(iRowid & (((i64)1 << FTS5_DATA_ID_B) - 1));
-  iRowid >>= FTS5_DATA_ID_B;
-
-  *pbTombstone = (int)(iRowid & 0x0001);
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-static void fts5DebugRowid(int *pRc, Fts5Buffer *pBuf, i64 iKey){
-  int iSegid, iHeight, iPgno, bDlidx, bTomb;     /* Rowid components */
-  fts5DecodeRowid(iKey, &bTomb, &iSegid, &bDlidx, &iHeight, &iPgno);
-
-  if( iSegid==0 ){
-    if( iKey==FTS5_AVERAGES_ROWID ){
-      sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{averages} ");
-    }else{
-      sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{structure}");
-    }
-  }
-  else{
-    sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{%s%ssegid=%d h=%d pgno=%d}",
-        bDlidx ? "dlidx " : "",
-        bTomb ? "tombstone " : "",
-        iSegid, iHeight, iPgno
-    );
-  }
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-static void fts5DebugStructure(
-  int *pRc,                       /* IN/OUT: error code */
-  Fts5Buffer *pBuf,
-  Fts5Structure *p
-){
-  int iLvl, iSeg;                 /* Iterate through levels, segments */
-
-  for(iLvl=0; iLvl<p->nLevel; iLvl++){
-    Fts5StructureLevel *pLvl = &p->aLevel[iLvl];
-    sqlite3Fts5BufferAppendPrintf(pRc, pBuf,
-        " {lvl=%d nMerge=%d nSeg=%d", iLvl, pLvl->nMerge, pLvl->nSeg
-    );
-    for(iSeg=0; iSeg<pLvl->nSeg; iSeg++){
-      Fts5StructureSegment *pSeg = &pLvl->aSeg[iSeg];
-      sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " {id=%d leaves=%d..%d",
-          pSeg->iSegid, pSeg->pgnoFirst, pSeg->pgnoLast
-      );
-      if( pSeg->iOrigin1>0 ){
-        sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " origin=%lld..%lld",
-            pSeg->iOrigin1, pSeg->iOrigin2
-        );
-      }
-      sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "}");
-    }
-    sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "}");
-  }
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-/*
-** This is part of the fts5_decode() debugging aid.
-**
-** Arguments pBlob/nBlob contain a serialized Fts5Structure object. This
-** function appends a human-readable representation of the same object
-** to the buffer passed as the second argument.
-*/
-static void fts5DecodeStructure(
-  int *pRc,                       /* IN/OUT: error code */
-  Fts5Buffer *pBuf,
-  const u8 *pBlob, int nBlob
-){
-  int rc;                         /* Return code */
-  Fts5Structure *p = 0;           /* Decoded structure object */
-
-  rc = fts5StructureDecode(pBlob, nBlob, 0, &p);
-  if( rc!=SQLITE_OK ){
-    *pRc = rc;
-    return;
-  }
-
-  fts5DebugStructure(pRc, pBuf, p);
-  fts5StructureRelease(p);
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-/*
-** This is part of the fts5_decode() debugging aid.
-**
-** Arguments pBlob/nBlob contain an "averages" record. This function
-** appends a human-readable representation of record to the buffer passed
-** as the second argument.
-*/
-static void fts5DecodeAverages(
-  int *pRc,                       /* IN/OUT: error code */
-  Fts5Buffer *pBuf,
-  const u8 *pBlob, int nBlob
-){
-  int i = 0;
-  const char *zSpace = "";
-
-  while( i<nBlob ){
-    u64 iVal;
-    i += sqlite3Fts5GetVarint(&pBlob[i], &iVal);
-    sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "%s%d", zSpace, (int)iVal);
-    zSpace = " ";
-  }
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-/*
-** Buffer (a/n) is assumed to contain a list of serialized varints. Read
-** each varint and append its string representation to buffer pBuf. Return
-** after either the input buffer is exhausted or a 0 value is read.
-**
-** The return value is the number of bytes read from the input buffer.
-*/
-static int fts5DecodePoslist(int *pRc, Fts5Buffer *pBuf, const u8 *a, int n){
-  int iOff = 0;
-  while( iOff<n ){
-    int iVal;
-    iOff += fts5GetVarint32(&a[iOff], iVal);
-    sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " %d", iVal);
-  }
-  return iOff;
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-/*
-** The start of buffer (a/n) contains the start of a doclist. The doclist
-** may or may not finish within the buffer. This function appends a text
-** representation of the part of the doclist that is present to buffer
-** pBuf.
-**
-** The return value is the number of bytes read from the input buffer.
-*/
-static int fts5DecodeDoclist(int *pRc, Fts5Buffer *pBuf, const u8 *a, int n){
-  i64 iDocid = 0;
-  int iOff = 0;
-
-  if( n>0 ){
-    iOff = sqlite3Fts5GetVarint(a, (u64*)&iDocid);
-    sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " id=%lld", iDocid);
-  }
-  while( iOff<n ){
-    int nPos;
-    int bDel;
-    iOff += fts5GetPoslistSize(&a[iOff], &nPos, &bDel);
-    sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " nPos=%d%s", nPos, bDel?"*":"");
-    iOff += fts5DecodePoslist(pRc, pBuf, &a[iOff], MIN(n-iOff, nPos));
-    if( iOff<n ){
-      i64 iDelta;
-      iOff += sqlite3Fts5GetVarint(&a[iOff], (u64*)&iDelta);
-      iDocid += iDelta;
-      sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " id=%lld", iDocid);
-    }
-  }
-
-  return iOff;
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-/*
-** This function is part of the fts5_decode() debugging function. It is
-** only ever used with detail=none tables.
-**
-** Buffer (pData/nData) contains a doclist in the format used by detail=none
-** tables. This function appends a human-readable version of that list to
-** buffer pBuf.
-**
-** If *pRc is other than SQLITE_OK when this function is called, it is a
-** no-op. If an OOM or other error occurs within this function, *pRc is
-** set to an SQLite error code before returning. The final state of buffer
-** pBuf is undefined in this case.
-*/
-static void fts5DecodeRowidList(
-  int *pRc,                       /* IN/OUT: Error code */
-  Fts5Buffer *pBuf,               /* Buffer to append text to */
-  const u8 *pData, int nData      /* Data to decode list-of-rowids from */
-){
-  int i = 0;
-  i64 iRowid = 0;
-
-  while( i<nData ){
-    const char *zApp = "";
-    u64 iVal;
-    i += sqlite3Fts5GetVarint(&pData[i], &iVal);
-    iRowid += iVal;
-
-    if( i<nData && pData[i]==0x00 ){
-      i++;
-      if( i<nData && pData[i]==0x00 ){
-        i++;
-        zApp = "+";
-      }else{
-        zApp = "*";
-      }
-    }
-
-    sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " %lld%s", iRowid, zApp);
-  }
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-static void fts5BufferAppendTerm(int *pRc, Fts5Buffer *pBuf, Fts5Buffer *pTerm){
-  int ii;
-  fts5BufferGrow(pRc, pBuf, pTerm->n*2 + 1);
-  if( *pRc==SQLITE_OK ){
-    for(ii=0; ii<pTerm->n; ii++){
-      if( pTerm->p[ii]==0x00 ){
-        pBuf->p[pBuf->n++] = '\\';
-        pBuf->p[pBuf->n++] = '0';
-      }else{
-        pBuf->p[pBuf->n++] = pTerm->p[ii];
-      }
-    }
-    pBuf->p[pBuf->n] = 0x00;
-  }
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-/*
-** The implementation of user-defined scalar function fts5_decode().
-*/
-static void fts5DecodeFunction(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args (always 2) */
-  sqlite3_value **apVal           /* Function arguments */
-){
-  i64 iRowid;                     /* Rowid for record being decoded */
-  int iSegid,iHeight,iPgno,bDlidx;/* Rowid components */
-  int bTomb;
-  const u8 *aBlob; int n;         /* Record to decode */
-  u8 *a = 0;
-  Fts5Buffer s;                   /* Build up text to return here */
-  int rc = SQLITE_OK;             /* Return code */
-  sqlite3_int64 nSpace = 0;
-  int eDetailNone = (sqlite3_user_data(pCtx)!=0);
-
-  assert( nArg==2 );
-  UNUSED_PARAM(nArg);
-  memset(&s, 0, sizeof(Fts5Buffer));
-  iRowid = sqlite3_value_int64(apVal[0]);
-
-  /* Make a copy of the second argument (a blob) in aBlob[]. The aBlob[]
-  ** copy is followed by FTS5_DATA_ZERO_PADDING 0x00 bytes, which prevents
-  ** buffer overreads even if the record is corrupt.  */
-  n = sqlite3_value_bytes(apVal[1]);
-  aBlob = sqlite3_value_blob(apVal[1]);
-  nSpace = ((i64)n) + FTS5_DATA_ZERO_PADDING;
-  a = (u8*)sqlite3Fts5MallocZero(&rc, nSpace);
-  if( a==0 ) goto decode_out;
-  if( n>0 ) memcpy(a, aBlob, n);
-
-  fts5DecodeRowid(iRowid, &bTomb, &iSegid, &bDlidx, &iHeight, &iPgno);
-
-  fts5DebugRowid(&rc, &s, iRowid);
-  if( bDlidx ){
-    Fts5Data dlidx;
-    Fts5DlidxLvl lvl;
-
-    dlidx.p = a;
-    dlidx.nn = n;
-
-    memset(&lvl, 0, sizeof(Fts5DlidxLvl));
-    lvl.pData = &dlidx;
-    lvl.iLeafPgno = iPgno;
-
-    for(fts5DlidxLvlNext(&lvl); lvl.bEof==0; fts5DlidxLvlNext(&lvl)){
-      sqlite3Fts5BufferAppendPrintf(&rc, &s,
-          " %d(%lld)", lvl.iLeafPgno, lvl.iRowid
-      );
-    }
-  }else if( bTomb ){
-    u32 nElem  = fts5GetU32(&a[4]);
-    int szKey = (aBlob[0]==4 || aBlob[0]==8) ? aBlob[0] : 8;
-    int nSlot = (n - 8) / szKey;
-    int ii;
-    sqlite3Fts5BufferAppendPrintf(&rc, &s, " nElem=%d", (int)nElem);
-    if( aBlob[1] ){
-      sqlite3Fts5BufferAppendPrintf(&rc, &s, " 0");
-    }
-    for(ii=0; ii<nSlot; ii++){
-      u64 iVal = 0;
-      if( szKey==4 ){
-        u32 *aSlot = (u32*)&aBlob[8];
-        if( aSlot[ii] ) iVal = fts5GetU32((u8*)&aSlot[ii]);
-      }else{
-        u64 *aSlot = (u64*)&aBlob[8];
-        if( aSlot[ii] ) iVal = fts5GetU64((u8*)&aSlot[ii]);
-      }
-      if( iVal!=0 ){
-        sqlite3Fts5BufferAppendPrintf(&rc, &s, " %lld", (i64)iVal);
-      }
-    }
-  }else if( iSegid==0 ){
-    if( iRowid==FTS5_AVERAGES_ROWID ){
-      fts5DecodeAverages(&rc, &s, a, n);
-    }else{
-      fts5DecodeStructure(&rc, &s, a, n);
-    }
-  }else if( eDetailNone ){
-    Fts5Buffer term;              /* Current term read from page */
-    int szLeaf;
-    int iPgidxOff = szLeaf = fts5GetU16(&a[2]);
-    int iTermOff;
-    int nKeep = 0;
-    int iOff;
-
-    memset(&term, 0, sizeof(Fts5Buffer));
-
-    /* Decode any entries that occur before the first term. */
-    if( szLeaf<n ){
-      iPgidxOff += fts5GetVarint32(&a[iPgidxOff], iTermOff);
-    }else{
-      iTermOff = szLeaf;
-    }
-    fts5DecodeRowidList(&rc, &s, &a[4], iTermOff-4);
-
-    iOff = iTermOff;
-    while( iOff<szLeaf && rc==SQLITE_OK ){
-      int nAppend;
-
-      /* Read the term data for the next term*/
-      iOff += fts5GetVarint32(&a[iOff], nAppend);
-      term.n = nKeep;
-      fts5BufferAppendBlob(&rc, &term, nAppend, &a[iOff]);
-      sqlite3Fts5BufferAppendPrintf(&rc, &s, " term=");
-      fts5BufferAppendTerm(&rc, &s, &term);
-      iOff += nAppend;
-
-      /* Figure out where the doclist for this term ends */
-      if( iPgidxOff<n ){
-        int nIncr;
-        iPgidxOff += fts5GetVarint32(&a[iPgidxOff], nIncr);
-        iTermOff += nIncr;
-      }else{
-        iTermOff = szLeaf;
-      }
-      if( iTermOff>szLeaf ){
-        rc = FTS5_CORRUPT;
-      }else{
-        fts5DecodeRowidList(&rc, &s, &a[iOff], iTermOff-iOff);
-      }
-      iOff = iTermOff;
-      if( iOff<szLeaf ){
-        iOff += fts5GetVarint32(&a[iOff], nKeep);
-      }
-    }
-
-    fts5BufferFree(&term);
-  }else{
-    Fts5Buffer term;              /* Current term read from page */
-    int szLeaf;                   /* Offset of pgidx in a[] */
-    int iPgidxOff;
-    int iPgidxPrev = 0;           /* Previous value read from pgidx */
-    int iTermOff = 0;
-    int iRowidOff = 0;
-    int iOff;
-    int nDoclist;
-
-    memset(&term, 0, sizeof(Fts5Buffer));
-
-    if( n<4 ){
-      sqlite3Fts5BufferSet(&rc, &s, 7, (const u8*)"corrupt");
-      goto decode_out;
-    }else{
-      iRowidOff = fts5GetU16(&a[0]);
-      iPgidxOff = szLeaf = fts5GetU16(&a[2]);
-      if( iPgidxOff<n ){
-        fts5GetVarint32(&a[iPgidxOff], iTermOff);
-      }else if( iPgidxOff>n ){
-        rc = FTS5_CORRUPT;
-        goto decode_out;
-      }
-    }
-
-    /* Decode the position list tail at the start of the page */
-    if( iRowidOff!=0 ){
-      iOff = iRowidOff;
-    }else if( iTermOff!=0 ){
-      iOff = iTermOff;
-    }else{
-      iOff = szLeaf;
-    }
-    if( iOff>n ){
-      rc = FTS5_CORRUPT;
-      goto decode_out;
-    }
-    fts5DecodePoslist(&rc, &s, &a[4], iOff-4);
-
-    /* Decode any more doclist data that appears on the page before the
-    ** first term. */
-    nDoclist = (iTermOff ? iTermOff : szLeaf) - iOff;
-    if( nDoclist+iOff>n ){
-      rc = FTS5_CORRUPT;
-      goto decode_out;
-    }
-    fts5DecodeDoclist(&rc, &s, &a[iOff], nDoclist);
-
-    while( iPgidxOff<n && rc==SQLITE_OK ){
-      int bFirst = (iPgidxOff==szLeaf);     /* True for first term on page */
-      int nByte;                            /* Bytes of data */
-      int iEnd;
-
-      iPgidxOff += fts5GetVarint32(&a[iPgidxOff], nByte);
-      iPgidxPrev += nByte;
-      iOff = iPgidxPrev;
-
-      if( iPgidxOff<n ){
-        fts5GetVarint32(&a[iPgidxOff], nByte);
-        iEnd = iPgidxPrev + nByte;
-      }else{
-        iEnd = szLeaf;
-      }
-      if( iEnd>szLeaf ){
-        rc = FTS5_CORRUPT;
-        break;
-      }
-
-      if( bFirst==0 ){
-        iOff += fts5GetVarint32(&a[iOff], nByte);
-        if( nByte>term.n ){
-          rc = FTS5_CORRUPT;
-          break;
-        }
-        term.n = nByte;
-      }
-      iOff += fts5GetVarint32(&a[iOff], nByte);
-      if( iOff+nByte>n ){
-        rc = FTS5_CORRUPT;
-        break;
-      }
-      fts5BufferAppendBlob(&rc, &term, nByte, &a[iOff]);
-      iOff += nByte;
-
-      sqlite3Fts5BufferAppendPrintf(&rc, &s, " term=");
-      fts5BufferAppendTerm(&rc, &s, &term);
-      iOff += fts5DecodeDoclist(&rc, &s, &a[iOff], iEnd-iOff);
-    }
-
-    fts5BufferFree(&term);
-  }
-
- decode_out:
-  sqlite3_free(a);
-  if( rc==SQLITE_OK ){
-    sqlite3_result_text(pCtx, (const char*)s.p, s.n, SQLITE_TRANSIENT);
-  }else{
-    sqlite3_result_error_code(pCtx, rc);
-  }
-  fts5BufferFree(&s);
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-/*
-** The implementation of user-defined scalar function fts5_rowid().
-*/
-static void fts5RowidFunction(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args (always 2) */
-  sqlite3_value **apVal           /* Function arguments */
-){
-  const char *zArg;
-  if( nArg==0 ){
-    sqlite3_result_error(pCtx, "should be: fts5_rowid(subject, ....)", -1);
-  }else{
-    zArg = (const char*)sqlite3_value_text(apVal[0]);
-    if( 0==sqlite3_stricmp(zArg, "segment") ){
-      i64 iRowid;
-      int segid, pgno;
-      if( nArg!=3 ){
-        sqlite3_result_error(pCtx,
-            "should be: fts5_rowid('segment', segid, pgno))", -1
-        );
-      }else{
-        segid = sqlite3_value_int(apVal[1]);
-        pgno = sqlite3_value_int(apVal[2]);
-        iRowid = FTS5_SEGMENT_ROWID(segid, pgno);
-        sqlite3_result_int64(pCtx, iRowid);
-      }
-    }else{
-      sqlite3_result_error(pCtx,
-        "first arg to fts5_rowid() must be 'segment'" , -1
-      );
-    }
-  }
-}
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-
-typedef struct Fts5StructVtab Fts5StructVtab;
-struct Fts5StructVtab {
-  sqlite3_vtab base;
-};
-
-typedef struct Fts5StructVcsr Fts5StructVcsr;
-struct Fts5StructVcsr {
-  sqlite3_vtab_cursor base;
-  Fts5Structure *pStruct;
-  int iLevel;
-  int iSeg;
-  int iRowid;
-};
-
-/*
-** Create a new fts5_structure() table-valued function.
-*/
-static int fts5structConnectMethod(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  Fts5StructVtab *pNew = 0;
-  int rc = SQLITE_OK;
-
-  rc = sqlite3_declare_vtab(db,
-      "CREATE TABLE xyz("
-          "level, segment, merge, segid, leaf1, leaf2, loc1, loc2, "
-          "npgtombstone, nentrytombstone, nentry, struct HIDDEN);"
-  );
-  if( rc==SQLITE_OK ){
-    pNew = sqlite3Fts5MallocZero(&rc, sizeof(*pNew));
-  }
-
-  *ppVtab = (sqlite3_vtab*)pNew;
-  return rc;
-}
-
-/*
-** We must have a single struct=? constraint that will be passed through
-** into the xFilter method.  If there is no valid struct=? constraint,
-** then return an SQLITE_CONSTRAINT error.
-*/
-static int fts5structBestIndexMethod(
-  sqlite3_vtab *tab,
-  sqlite3_index_info *pIdxInfo
-){
-  int i;
-  int rc = SQLITE_CONSTRAINT;
-  struct sqlite3_index_constraint *p;
-  pIdxInfo->estimatedCost = (double)100;
-  pIdxInfo->estimatedRows = 100;
-  pIdxInfo->idxNum = 0;
-  for(i=0, p=pIdxInfo->aConstraint; i<pIdxInfo->nConstraint; i++, p++){
-    if( p->usable==0 ) continue;
-    if( p->op==SQLITE_INDEX_CONSTRAINT_EQ && p->iColumn==11 ){
-      rc = SQLITE_OK;
-      pIdxInfo->aConstraintUsage[i].omit = 1;
-      pIdxInfo->aConstraintUsage[i].argvIndex = 1;
-      break;
-    }
-  }
-  return rc;
-}
-
-/*
-** This method is the destructor for bytecodevtab objects.
-*/
-static int fts5structDisconnectMethod(sqlite3_vtab *pVtab){
-  Fts5StructVtab *p = (Fts5StructVtab*)pVtab;
-  sqlite3_free(p);
-  return SQLITE_OK;
-}
-
-/*
-** Constructor for a new bytecodevtab_cursor object.
-*/
-static int fts5structOpenMethod(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCsr){
-  int rc = SQLITE_OK;
-  Fts5StructVcsr *pNew = 0;
-
-  pNew = sqlite3Fts5MallocZero(&rc, sizeof(*pNew));
-  *ppCsr = (sqlite3_vtab_cursor*)pNew;
-
-  return SQLITE_OK;
-}
-
-/*
-** Destructor for a bytecodevtab_cursor.
-*/
-static int fts5structCloseMethod(sqlite3_vtab_cursor *cur){
-  Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
-  fts5StructureRelease(pCsr->pStruct);
-  sqlite3_free(pCsr);
-  return SQLITE_OK;
-}
-
-
-/*
-** Advance a bytecodevtab_cursor to its next row of output.
-*/
-static int fts5structNextMethod(sqlite3_vtab_cursor *cur){
-  Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
-  Fts5Structure *p = pCsr->pStruct;
-
-  assert( pCsr->pStruct );
-  pCsr->iSeg++;
-  pCsr->iRowid++;
-  while( pCsr->iLevel<p->nLevel && pCsr->iSeg>=p->aLevel[pCsr->iLevel].nSeg ){
-    pCsr->iLevel++;
-    pCsr->iSeg = 0;
-  }
-  if( pCsr->iLevel>=p->nLevel ){
-    fts5StructureRelease(pCsr->pStruct);
-    pCsr->pStruct = 0;
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Return TRUE if the cursor has been moved off of the last
-** row of output.
-*/
-static int fts5structEofMethod(sqlite3_vtab_cursor *cur){
-  Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
-  return pCsr->pStruct==0;
-}
-
-static int fts5structRowidMethod(
-  sqlite3_vtab_cursor *cur,
-  sqlite_int64 *piRowid
-){
-  Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
-  *piRowid = pCsr->iRowid;
-  return SQLITE_OK;
-}
-
-/*
-** Return values of columns for the row at which the bytecodevtab_cursor
-** is currently pointing.
-*/
-static int fts5structColumnMethod(
-  sqlite3_vtab_cursor *cur,   /* The cursor */
-  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */
-  int i                       /* Which column to return */
-){
-  Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
-  Fts5Structure *p = pCsr->pStruct;
-  Fts5StructureSegment *pSeg = &p->aLevel[pCsr->iLevel].aSeg[pCsr->iSeg];
-
-  switch( i ){
-    case 0: /* level */
-      sqlite3_result_int(ctx, pCsr->iLevel);
-      break;
-    case 1: /* segment */
-      sqlite3_result_int(ctx, pCsr->iSeg);
-      break;
-    case 2: /* merge */
-      sqlite3_result_int(ctx, pCsr->iSeg < p->aLevel[pCsr->iLevel].nMerge);
-      break;
-    case 3: /* segid */
-      sqlite3_result_int(ctx, pSeg->iSegid);
-      break;
-    case 4: /* leaf1 */
-      sqlite3_result_int(ctx, pSeg->pgnoFirst);
-      break;
-    case 5: /* leaf2 */
-      sqlite3_result_int(ctx, pSeg->pgnoLast);
-      break;
-    case 6: /* origin1 */
-      sqlite3_result_int64(ctx, pSeg->iOrigin1);
-      break;
-    case 7: /* origin2 */
-      sqlite3_result_int64(ctx, pSeg->iOrigin2);
-      break;
-    case 8: /* npgtombstone */
-      sqlite3_result_int(ctx, pSeg->nPgTombstone);
-      break;
-    case 9: /* nentrytombstone */
-      sqlite3_result_int64(ctx, pSeg->nEntryTombstone);
-      break;
-    case 10: /* nentry */
-      sqlite3_result_int64(ctx, pSeg->nEntry);
-      break;
-  }
-  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 fts5structFilterMethod(
-  sqlite3_vtab_cursor *pVtabCursor,
-  int idxNum, const char *idxStr,
-  int argc, sqlite3_value **argv
-){
-  Fts5StructVcsr *pCsr = (Fts5StructVcsr *)pVtabCursor;
-  int rc = SQLITE_OK;
-
-  const u8 *aBlob = 0;
-  int nBlob = 0;
-
-  assert( argc==1 );
-  fts5StructureRelease(pCsr->pStruct);
-  pCsr->pStruct = 0;
-
-  nBlob = sqlite3_value_bytes(argv[0]);
-  aBlob = (const u8*)sqlite3_value_blob(argv[0]);
-  rc = fts5StructureDecode(aBlob, nBlob, 0, &pCsr->pStruct);
-  if( rc==SQLITE_OK ){
-    pCsr->iLevel = 0;
-    pCsr->iRowid = 0;
-    pCsr->iSeg = -1;
-    rc = fts5structNextMethod(pVtabCursor);
-  }
-
-  return rc;
-}
-
-#endif /* SQLITE_TEST || SQLITE_FTS5_DEBUG */
-
-/*
-** This is called as part of registering the FTS5 module with database
-** connection db. It registers several user-defined scalar functions useful
-** with FTS5.
-**
-** If successful, SQLITE_OK is returned. If an error occurs, some other
-** SQLite error code is returned instead.
-*/
-static int sqlite3Fts5IndexInit(sqlite3 *db){
-#if defined(SQLITE_TEST) || defined(SQLITE_FTS5_DEBUG)
-  int rc = sqlite3_create_function(
-      db, "fts5_decode", 2, SQLITE_UTF8, 0, fts5DecodeFunction, 0, 0
-  );
-
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_create_function(
-        db, "fts5_decode_none", 2,
-        SQLITE_UTF8, (void*)db, fts5DecodeFunction, 0, 0
-    );
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_create_function(
-        db, "fts5_rowid", -1, SQLITE_UTF8, 0, fts5RowidFunction, 0, 0
-    );
-  }
-
-  if( rc==SQLITE_OK ){
-    static const sqlite3_module fts5structure_module = {
-      0,                           /* iVersion      */
-      0,                           /* xCreate       */
-      fts5structConnectMethod,     /* xConnect      */
-      fts5structBestIndexMethod,   /* xBestIndex    */
-      fts5structDisconnectMethod,  /* xDisconnect   */
-      0,                           /* xDestroy      */
-      fts5structOpenMethod,        /* xOpen         */
-      fts5structCloseMethod,       /* xClose        */
-      fts5structFilterMethod,      /* xFilter       */
-      fts5structNextMethod,        /* xNext         */
-      fts5structEofMethod,         /* xEof          */
-      fts5structColumnMethod,      /* xColumn       */
-      fts5structRowidMethod,       /* xRowid        */
-      0,                           /* xUpdate       */
-      0,                           /* xBegin        */
-      0,                           /* xSync         */
-      0,                           /* xCommit       */
-      0,                           /* xRollback     */
-      0,                           /* xFindFunction */
-      0,                           /* xRename       */
-      0,                           /* xSavepoint    */
-      0,                           /* xRelease      */
-      0,                           /* xRollbackTo   */
-      0,                           /* xShadowName   */
-      0                            /* xIntegrity    */
-    };
-    rc = sqlite3_create_module(db, "fts5_structure", &fts5structure_module, 0);
-  }
-  return rc;
-#else
-  return SQLITE_OK;
-  UNUSED_PARAM(db);
-#endif
-}
-
-
-static int sqlite3Fts5IndexReset(Fts5Index *p){
-  assert( p->pStruct==0 || p->iStructVersion!=0 );
-  if( fts5IndexDataVersion(p)!=p->iStructVersion ){
-    fts5StructureInvalidate(p);
-  }
-  return fts5IndexReturn(p);
-}
-
-/*
-** 2014 Jun 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 is an SQLite module implementing full-text search.
-*/
-
-
-/* #include "fts5Int.h" */
-
-/*
-** 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 fts5 code are activated - conditions that are
-** only true if it is guaranteed that the fts5 database is not corrupt.
-*/
-#ifdef SQLITE_DEBUG
-SQLITE_API int sqlite3_fts5_may_be_corrupt = 1;
-#endif
-
-
-typedef struct Fts5Auxdata Fts5Auxdata;
-typedef struct Fts5Auxiliary Fts5Auxiliary;
-typedef struct Fts5Cursor Fts5Cursor;
-typedef struct Fts5FullTable Fts5FullTable;
-typedef struct Fts5Sorter Fts5Sorter;
-typedef struct Fts5TokenizerModule Fts5TokenizerModule;
-
-/*
-** NOTES ON TRANSACTIONS:
-**
-** SQLite invokes the following virtual table methods as transactions are
-** opened and closed by the user:
-**
-**     xBegin():    Start of a new transaction.
-**     xSync():     Initial part of two-phase commit.
-**     xCommit():   Final part of two-phase commit.
-**     xRollback(): Rollback the transaction.
-**
-** Anything that is required as part of a commit that may fail is performed
-** in the xSync() callback. Current versions of SQLite ignore any errors
-** returned by xCommit().
-**
-** And as sub-transactions are opened/closed:
-**
-**     xSavepoint(int S):  Open savepoint S.
-**     xRelease(int S):    Commit and close savepoint S.
-**     xRollbackTo(int S): Rollback to start of savepoint S.
-**
-** During a write-transaction the fts5_index.c module may cache some data
-** in-memory. It is flushed to disk whenever xSync(), xRelease() or
-** xSavepoint() is called. And discarded whenever xRollback() or xRollbackTo()
-** is called.
-**
-** Additionally, if SQLITE_DEBUG is defined, an instance of the following
-** structure is used to record the current transaction state. This information
-** is not required, but it is used in the assert() statements executed by
-** function fts5CheckTransactionState() (see below).
-*/
-struct Fts5TransactionState {
-  int eState;                     /* 0==closed, 1==open, 2==synced */
-  int iSavepoint;                 /* Number of open savepoints (0 -> none) */
-};
-
-/*
-** A single object of this type is allocated when the FTS5 module is
-** registered with a database handle. It is used to store pointers to
-** all registered FTS5 extensions - tokenizers and auxiliary functions.
-*/
-struct Fts5Global {
-  fts5_api api;                   /* User visible part of object (see fts5.h) */
-  sqlite3 *db;                    /* Associated database connection */
-  i64 iNextId;                    /* Used to allocate unique cursor ids */
-  Fts5Auxiliary *pAux;            /* First in list of all aux. functions */
-  Fts5TokenizerModule *pTok;      /* First in list of all tokenizer modules */
-  Fts5TokenizerModule *pDfltTok;  /* Default tokenizer module */
-  Fts5Cursor *pCsr;               /* First in list of all open cursors */
-  u32 aLocaleHdr[4];
-};
-
-/*
-** Size of header on fts5_locale() values. And macro to access a buffer
-** containing a copy of the header from an Fts5Config pointer.
-*/
-#define FTS5_LOCALE_HDR_SIZE ((int)sizeof( ((Fts5Global*)0)->aLocaleHdr ))
-#define FTS5_LOCALE_HDR(pConfig) ((const u8*)(pConfig->pGlobal->aLocaleHdr))
-
-#define FTS5_INSTTOKEN_SUBTYPE 73
-
-/*
-** Each auxiliary function registered with the FTS5 module is represented
-** by an object of the following type. All such objects are stored as part
-** of the Fts5Global.pAux list.
-*/
-struct Fts5Auxiliary {
-  Fts5Global *pGlobal;            /* Global context for this function */
-  char *zFunc;                    /* Function name (nul-terminated) */
-  void *pUserData;                /* User-data pointer */
-  fts5_extension_function xFunc;  /* Callback function */
-  void (*xDestroy)(void*);        /* Destructor function */
-  Fts5Auxiliary *pNext;           /* Next registered auxiliary function */
-};
-
-/*
-** Each tokenizer module registered with the FTS5 module is represented
-** by an object of the following type. All such objects are stored as part
-** of the Fts5Global.pTok list.
-**
-** bV2Native:
-**  True if the tokenizer was registered using xCreateTokenizer_v2(), false
-**  for xCreateTokenizer(). If this variable is true, then x2 is populated
-**  with the routines as supplied by the caller and x1 contains synthesized
-**  wrapper routines. In this case the user-data pointer passed to
-**  x1.xCreate should be a pointer to the Fts5TokenizerModule structure,
-**  not a copy of pUserData.
-**
-**  Of course, if bV2Native is false, then x1 contains the real routines and
-**  x2 the synthesized ones. In this case a pointer to the Fts5TokenizerModule
-**  object should be passed to x2.xCreate.
-**
-**  The synthesized wrapper routines are necessary for xFindTokenizer(_v2)
-**  calls.
-*/
-struct Fts5TokenizerModule {
-  char *zName;                    /* Name of tokenizer */
-  void *pUserData;                /* User pointer passed to xCreate() */
-  int bV2Native;                  /* True if v2 native tokenizer */
-  fts5_tokenizer x1;              /* Tokenizer functions */
-  fts5_tokenizer_v2 x2;           /* V2 tokenizer functions */
-  void (*xDestroy)(void*);        /* Destructor function */
-  Fts5TokenizerModule *pNext;     /* Next registered tokenizer module */
-};
-
-struct Fts5FullTable {
-  Fts5Table p;                    /* Public class members from fts5Int.h */
-  Fts5Storage *pStorage;          /* Document store */
-  Fts5Global *pGlobal;            /* Global (connection wide) data */
-  Fts5Cursor *pSortCsr;           /* Sort data from this cursor */
-  int iSavepoint;                 /* Successful xSavepoint()+1 */
-
-#ifdef SQLITE_DEBUG
-  struct Fts5TransactionState ts;
-#endif
-};
-
-struct Fts5MatchPhrase {
-  Fts5Buffer *pPoslist;           /* Pointer to current poslist */
-  int nTerm;                      /* Size of phrase in terms */
-};
-
-/*
-** pStmt:
-**   SELECT rowid, <fts> FROM <fts> ORDER BY +rank;
-**
-** aIdx[]:
-**   There is one entry in the aIdx[] array for each phrase in the query,
-**   the value of which is the offset within aPoslist[] following the last
-**   byte of the position list for the corresponding phrase.
-*/
-struct Fts5Sorter {
-  sqlite3_stmt *pStmt;
-  i64 iRowid;                     /* Current rowid */
-  const u8 *aPoslist;             /* Position lists for current row */
-  int nIdx;                       /* Number of entries in aIdx[] */
-  int aIdx[FLEXARRAY];            /* Offsets into aPoslist for current row */
-};
-
-/* Size (int bytes) of an Fts5Sorter object with N indexes */
-#define SZ_FTS5SORTER(N) (offsetof(Fts5Sorter,nIdx)+((N+2)/2)*sizeof(i64))
-
-/*
-** Virtual-table cursor object.
-**
-** iSpecial:
-**   If this is a 'special' query (refer to function fts5SpecialMatch()),
-**   then this variable contains the result of the query.
-**
-** iFirstRowid, iLastRowid:
-**   These variables are only used for FTS5_PLAN_MATCH cursors. Assuming the
-**   cursor iterates in ascending order of rowids, iFirstRowid is the lower
-**   limit of rowids to return, and iLastRowid the upper. In other words, the
-**   WHERE clause in the user's query might have been:
-**
-**       <tbl> MATCH <expr> AND rowid BETWEEN $iFirstRowid AND $iLastRowid
-**
-**   If the cursor iterates in descending order of rowid, iFirstRowid
-**   is the upper limit (i.e. the "first" rowid visited) and iLastRowid
-**   the lower.
-*/
-struct Fts5Cursor {
-  sqlite3_vtab_cursor base;       /* Base class used by SQLite core */
-  Fts5Cursor *pNext;              /* Next cursor in Fts5Cursor.pCsr list */
-  int *aColumnSize;               /* Values for xColumnSize() */
-  i64 iCsrId;                     /* Cursor id */
-
-  /* Zero from this point onwards on cursor reset */
-  int ePlan;                      /* FTS5_PLAN_XXX value */
-  int bDesc;                      /* True for "ORDER BY rowid DESC" queries */
-  i64 iFirstRowid;                /* Return no rowids earlier than this */
-  i64 iLastRowid;                 /* Return no rowids later than this */
-  sqlite3_stmt *pStmt;            /* Statement used to read %_content */
-  Fts5Expr *pExpr;                /* Expression for MATCH queries */
-  Fts5Sorter *pSorter;            /* Sorter for "ORDER BY rank" queries */
-  int csrflags;                   /* Mask of cursor flags (see below) */
-  i64 iSpecial;                   /* Result of special query */
-
-  /* "rank" function. Populated on demand from vtab.xColumn(). */
-  char *zRank;                    /* Custom rank function */
-  char *zRankArgs;                /* Custom rank function args */
-  Fts5Auxiliary *pRank;           /* Rank callback (or NULL) */
-  int nRankArg;                   /* Number of trailing arguments for rank() */
-  sqlite3_value **apRankArg;      /* Array of trailing arguments */
-  sqlite3_stmt *pRankArgStmt;     /* Origin of objects in apRankArg[] */
-
-  /* Auxiliary data storage */
-  Fts5Auxiliary *pAux;            /* Currently executing extension function */
-  Fts5Auxdata *pAuxdata;          /* First in linked list of saved aux-data */
-
-  /* Cache used by auxiliary API functions xInst() and xInstCount() */
-  Fts5PoslistReader *aInstIter;   /* One for each phrase */
-  int nInstAlloc;                 /* Size of aInst[] array (entries / 3) */
-  int nInstCount;                 /* Number of phrase instances */
-  int *aInst;                     /* 3 integers per phrase instance */
-};
-
-/*
-** Bits that make up the "idxNum" parameter passed indirectly by
-** xBestIndex() to xFilter().
-*/
-#define FTS5_BI_MATCH        0x0001         /* <tbl> MATCH ? */
-#define FTS5_BI_RANK         0x0002         /* rank MATCH ? */
-#define FTS5_BI_ROWID_EQ     0x0004         /* rowid == ? */
-#define FTS5_BI_ROWID_LE     0x0008         /* rowid <= ? */
-#define FTS5_BI_ROWID_GE     0x0010         /* rowid >= ? */
-
-#define FTS5_BI_ORDER_RANK   0x0020
-#define FTS5_BI_ORDER_ROWID  0x0040
-#define FTS5_BI_ORDER_DESC   0x0080
-
-/*
-** Values for Fts5Cursor.csrflags
-*/
-#define FTS5CSR_EOF               0x01
-#define FTS5CSR_REQUIRE_CONTENT   0x02
-#define FTS5CSR_REQUIRE_DOCSIZE   0x04
-#define FTS5CSR_REQUIRE_INST      0x08
-#define FTS5CSR_FREE_ZRANK        0x10
-#define FTS5CSR_REQUIRE_RESEEK    0x20
-#define FTS5CSR_REQUIRE_POSLIST   0x40
-
-#define BitFlagAllTest(x,y) (((x) & (y))==(y))
-#define BitFlagTest(x,y)    (((x) & (y))!=0)
-
-
-/*
-** Macros to Set(), Clear() and Test() cursor flags.
-*/
-#define CsrFlagSet(pCsr, flag)   ((pCsr)->csrflags |= (flag))
-#define CsrFlagClear(pCsr, flag) ((pCsr)->csrflags &= ~(flag))
-#define CsrFlagTest(pCsr, flag)  ((pCsr)->csrflags & (flag))
-
-struct Fts5Auxdata {
-  Fts5Auxiliary *pAux;            /* Extension to which this belongs */
-  void *pPtr;                     /* Pointer value */
-  void(*xDelete)(void*);          /* Destructor */
-  Fts5Auxdata *pNext;             /* Next object in linked list */
-};
-
-#ifdef SQLITE_DEBUG
-#define FTS5_BEGIN      1
-#define FTS5_SYNC       2
-#define FTS5_COMMIT     3
-#define FTS5_ROLLBACK   4
-#define FTS5_SAVEPOINT  5
-#define FTS5_RELEASE    6
-#define FTS5_ROLLBACKTO 7
-static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){
-  switch( op ){
-    case FTS5_BEGIN:
-      assert( p->ts.eState==0 );
-      p->ts.eState = 1;
-      p->ts.iSavepoint = -1;
-      break;
-
-    case FTS5_SYNC:
-      assert( p->ts.eState==1 || p->ts.eState==2 );
-      p->ts.eState = 2;
-      break;
-
-    case FTS5_COMMIT:
-      assert( p->ts.eState==2 );
-      p->ts.eState = 0;
-      break;
-
-    case FTS5_ROLLBACK:
-      assert( p->ts.eState==1 || p->ts.eState==2 || p->ts.eState==0 );
-      p->ts.eState = 0;
-      break;
-
-    case FTS5_SAVEPOINT:
-      assert( p->ts.eState>=1 );
-      assert( iSavepoint>=0 );
-      assert( iSavepoint>=p->ts.iSavepoint );
-      p->ts.iSavepoint = iSavepoint;
-      break;
-
-    case FTS5_RELEASE:
-      assert( p->ts.eState>=1 );
-      assert( iSavepoint>=0 );
-      assert( iSavepoint<=p->ts.iSavepoint );
-      p->ts.iSavepoint = iSavepoint-1;
-      break;
-
-    case FTS5_ROLLBACKTO:
-      assert( p->ts.eState>=1 );
-      assert( iSavepoint>=-1 );
-      /* The following assert() can fail if another vtab strikes an error
-      ** within an xSavepoint() call then SQLite calls xRollbackTo() - without
-      ** having called xSavepoint() on this vtab.  */
-      /* assert( iSavepoint<=p->ts.iSavepoint ); */
-      p->ts.iSavepoint = iSavepoint;
-      break;
-  }
-}
-#else
-# define fts5CheckTransactionState(x,y,z)
-#endif
-
-/*
-** Return true if pTab is a contentless table. If parameter bIncludeUnindexed
-** is true, this includes contentless tables that store UNINDEXED columns
-** only.
-*/
-static int fts5IsContentless(Fts5FullTable *pTab, int bIncludeUnindexed){
-  int eContent = pTab->p.pConfig->eContent;
-  return (
-    eContent==FTS5_CONTENT_NONE
-    || (bIncludeUnindexed && eContent==FTS5_CONTENT_UNINDEXED)
-  );
-}
-
-/*
-** Delete a virtual table handle allocated by fts5InitVtab().
-*/
-static void fts5FreeVtab(Fts5FullTable *pTab){
-  if( pTab ){
-    sqlite3Fts5IndexClose(pTab->p.pIndex);
-    sqlite3Fts5StorageClose(pTab->pStorage);
-    sqlite3Fts5ConfigFree(pTab->p.pConfig);
-    sqlite3_free(pTab);
-  }
-}
-
-/*
-** The xDisconnect() virtual table method.
-*/
-static int fts5DisconnectMethod(sqlite3_vtab *pVtab){
-  fts5FreeVtab((Fts5FullTable*)pVtab);
-  return SQLITE_OK;
-}
-
-/*
-** The xDestroy() virtual table method.
-*/
-static int fts5DestroyMethod(sqlite3_vtab *pVtab){
-  Fts5Table *pTab = (Fts5Table*)pVtab;
-  int rc = sqlite3Fts5DropAll(pTab->pConfig);
-  if( rc==SQLITE_OK ){
-    fts5FreeVtab((Fts5FullTable*)pVtab);
-  }
-  return rc;
-}
-
-/*
-** This function is the implementation of both the xConnect and xCreate
-** methods of the FTS3 virtual table.
-**
-** The argv[] array contains the following:
-**
-**   argv[0]   -> module name  ("fts5")
-**   argv[1]   -> database name
-**   argv[2]   -> table name
-**   argv[...] -> "column name" and other module argument fields.
-*/
-static int fts5InitVtab(
-  int bCreate,                    /* 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 */
-){
-  Fts5Global *pGlobal = (Fts5Global*)pAux;
-  const char **azConfig = (const char**)argv;
-  int rc = SQLITE_OK;             /* Return code */
-  Fts5Config *pConfig = 0;        /* Results of parsing argc/argv */
-  Fts5FullTable *pTab = 0;        /* New virtual table object */
-
-  /* Allocate the new vtab object and parse the configuration */
-  pTab = (Fts5FullTable*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5FullTable));
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5ConfigParse(pGlobal, db, argc, azConfig, &pConfig, pzErr);
-    assert( (rc==SQLITE_OK && *pzErr==0) || pConfig==0 );
-  }
-  if( rc==SQLITE_OK ){
-    pConfig->pzErrmsg = pzErr;
-    pTab->p.pConfig = pConfig;
-    pTab->pGlobal = pGlobal;
-    if( bCreate || sqlite3Fts5TokenizerPreload(&pConfig->t) ){
-      rc = sqlite3Fts5LoadTokenizer(pConfig);
-    }
-  }
-
-  /* Open the index sub-system */
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5IndexOpen(pConfig, bCreate, &pTab->p.pIndex, pzErr);
-  }
-
-  /* Open the storage sub-system */
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5StorageOpen(
-        pConfig, pTab->p.pIndex, bCreate, &pTab->pStorage, pzErr
-    );
-  }
-
-  /* Call sqlite3_declare_vtab() */
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5ConfigDeclareVtab(pConfig);
-  }
-
-  /* Load the initial configuration */
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5ConfigLoad(pTab->p.pConfig, pTab->p.pConfig->iCookie-1);
-  }
-
-  if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
-    rc = sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, (int)1);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS);
-  }
-
-  if( pConfig ) pConfig->pzErrmsg = 0;
-  if( rc!=SQLITE_OK ){
-    fts5FreeVtab(pTab);
-    pTab = 0;
-  }else if( bCreate ){
-    fts5CheckTransactionState(pTab, FTS5_BEGIN, 0);
-  }
-  *ppVTab = (sqlite3_vtab*)pTab;
-  return rc;
-}
-
-/*
-** The xConnect() and xCreate() methods for the virtual table. All the
-** work is done in function fts5InitVtab().
-*/
-static int fts5ConnectMethod(
-  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 fts5InitVtab(0, db, pAux, argc, argv, ppVtab, pzErr);
-}
-static int fts5CreateMethod(
-  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 fts5InitVtab(1, db, pAux, argc, argv, ppVtab, pzErr);
-}
-
-/*
-** The different query plans.
-*/
-#define FTS5_PLAN_MATCH          1       /* (<tbl> MATCH ?) */
-#define FTS5_PLAN_SOURCE         2       /* A source cursor for SORTED_MATCH */
-#define FTS5_PLAN_SPECIAL        3       /* An internal query */
-#define FTS5_PLAN_SORTED_MATCH   4       /* (<tbl> MATCH ? ORDER BY rank) */
-#define FTS5_PLAN_SCAN           5       /* No usable constraint */
-#define FTS5_PLAN_ROWID          6       /* (rowid = ?) */
-
-/*
-** 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 fts5SetUniqueFlag(sqlite3_index_info *pIdxInfo){
-#if SQLITE_VERSION_NUMBER>=3008012
-#ifndef SQLITE_CORE
-  if( sqlite3_libversion_number()>=3008012 )
-#endif
-  {
-    pIdxInfo->idxFlags |= SQLITE_INDEX_SCAN_UNIQUE;
-  }
-#endif
-}
-
-static void fts5SetEstimatedRows(sqlite3_index_info *pIdxInfo, i64 nRow){
-#if SQLITE_VERSION_NUMBER>=3008002
-#ifndef SQLITE_CORE
-  if( sqlite3_libversion_number()>=3008002 )
-#endif
-  {
-    pIdxInfo->estimatedRows = MAX(1, nRow);
-  }
-#endif
-}
-
-static int fts5UsePatternMatch(
-  Fts5Config *pConfig,
-  struct sqlite3_index_constraint *p
-){
-  assert( FTS5_PATTERN_GLOB==SQLITE_INDEX_CONSTRAINT_GLOB );
-  assert( FTS5_PATTERN_LIKE==SQLITE_INDEX_CONSTRAINT_LIKE );
-  if( pConfig->t.ePattern==FTS5_PATTERN_GLOB && p->op==FTS5_PATTERN_GLOB ){
-    return 1;
-  }
-  if( pConfig->t.ePattern==FTS5_PATTERN_LIKE
-   && (p->op==FTS5_PATTERN_LIKE || p->op==FTS5_PATTERN_GLOB)
-  ){
-    return 1;
-  }
-  return 0;
-}
-
-/*
-** Implementation of the xBestIndex method for FTS5 tables. Within the
-** WHERE constraint, it searches for the following:
-**
-**   1. A MATCH constraint against the table column.
-**   2. A MATCH constraint against the "rank" column.
-**   3. A MATCH constraint against some other column.
-**   4. An == constraint against the rowid column.
-**   5. A < or <= constraint against the rowid column.
-**   6. A > or >= constraint against the rowid column.
-**
-** Within the ORDER BY, the following are supported:
-**
-**   5. ORDER BY rank [ASC|DESC]
-**   6. ORDER BY rowid [ASC|DESC]
-**
-** Information for the xFilter call is passed via both the idxNum and
-** idxStr variables. Specifically, idxNum is a bitmask of the following
-** flags used to encode the ORDER BY clause:
-**
-**     FTS5_BI_ORDER_RANK
-**     FTS5_BI_ORDER_ROWID
-**     FTS5_BI_ORDER_DESC
-**
-** idxStr is used to encode data from the WHERE clause. For each argument
-** passed to the xFilter method, the following is appended to idxStr:
-**
-**   Match against table column:            "m"
-**   Match against rank column:             "r"
-**   Match against other column:            "M<column-number>"
-**   LIKE  against other column:            "L<column-number>"
-**   GLOB  against other column:            "G<column-number>"
-**   Equality constraint against the rowid: "="
-**   A < or <= against the rowid:           "<"
-**   A > or >= against the rowid:           ">"
-**
-** This function ensures that there is at most one "r" or "=". And that if
-** there exists an "=" then there is no "<" or ">".
-**
-** If an unusable MATCH operator is present in the WHERE clause, then
-** SQLITE_CONSTRAINT is returned.
-**
-** Costs are assigned as follows:
-**
-**  a) If a MATCH operator is present, the cost depends on the other
-**     constraints also present. As follows:
-**
-**       * No other constraints:         cost=50000.0
-**       * One rowid range constraint:   cost=37500.0
-**       * Both rowid range constraints: cost=30000.0
-**       * An == rowid constraint:       cost=25000.0
-**
-**  b) Otherwise, if there is no MATCH:
-**
-**       * No other constraints:         cost=3000000.0
-**       * One rowid range constraints:  cost=2250000.0
-**       * Both rowid range constraint:  cost=750000.0
-**       * An == rowid constraint:       cost=25.0
-**
-** Costs are not modified by the ORDER BY clause.
-**
-** The ratios used in case (a) are based on informal results obtained from
-** the tool/fts5cost.tcl script. The "MATCH and ==" combination has the
-** cost set quite high because the query may be a prefix query. Unless
-** there is a prefix index, prefix queries with rowid constraints are much
-** more expensive than non-prefix queries with rowid constraints.
-**
-** The estimated rows returned is set to the cost/40. For simple queries,
-** experimental results show that cost/4 might be about right. But for
-** more complex queries that use multiple terms the number of rows might
-** be far fewer than this. So we compromise and use cost/40.
-*/
-static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
-  Fts5Table *pTab = (Fts5Table*)pVTab;
-  Fts5Config *pConfig = pTab->pConfig;
-  const int nCol = pConfig->nCol;
-  int idxFlags = 0;               /* Parameter passed through to xFilter() */
-  int i;
-
-  char *idxStr;
-  int iIdxStr = 0;
-  int iCons = 0;
-
-  int bSeenEq = 0;
-  int bSeenGt = 0;
-  int bSeenLt = 0;
-  int nSeenMatch = 0;
-  int bSeenRank = 0;
-
-
-  assert( SQLITE_INDEX_CONSTRAINT_EQ<SQLITE_INDEX_CONSTRAINT_MATCH );
-  assert( SQLITE_INDEX_CONSTRAINT_GT<SQLITE_INDEX_CONSTRAINT_MATCH );
-  assert( SQLITE_INDEX_CONSTRAINT_LE<SQLITE_INDEX_CONSTRAINT_MATCH );
-  assert( SQLITE_INDEX_CONSTRAINT_GE<SQLITE_INDEX_CONSTRAINT_MATCH );
-  assert( SQLITE_INDEX_CONSTRAINT_LE<SQLITE_INDEX_CONSTRAINT_MATCH );
-
-  if( pConfig->bLock ){
-    pTab->base.zErrMsg = sqlite3_mprintf(
-        "recursively defined fts5 content table"
-    );
-    return SQLITE_ERROR;
-  }
-
-  idxStr = (char*)sqlite3_malloc64((i64)pInfo->nConstraint * 8 + 1);
-  if( idxStr==0 ) return SQLITE_NOMEM;
-  pInfo->idxStr = idxStr;
-  pInfo->needToFreeIdxStr = 1;
-
-  for(i=0; i<pInfo->nConstraint; i++){
-    struct sqlite3_index_constraint *p = &pInfo->aConstraint[i];
-    int iCol = p->iColumn;
-    if( p->op==SQLITE_INDEX_CONSTRAINT_MATCH
-     || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
-    ){
-      /* A MATCH operator or equivalent */
-      if( p->usable==0 || iCol<0 ){
-        /* As there exists an unusable MATCH constraint this is an
-        ** unusable plan. Return SQLITE_CONSTRAINT. */
-        idxStr[iIdxStr] = 0;
-        return SQLITE_CONSTRAINT;
-      }else{
-        if( iCol==nCol+1 ){
-          if( bSeenRank ) continue;
-          idxStr[iIdxStr++] = 'r';
-          bSeenRank = 1;
-        }else{
-          nSeenMatch++;
-          idxStr[iIdxStr++] = 'M';
-          sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
-          iIdxStr += (int)strlen(&idxStr[iIdxStr]);
-          assert( idxStr[iIdxStr]=='\0' );
-        }
-        pInfo->aConstraintUsage[i].argvIndex = ++iCons;
-        pInfo->aConstraintUsage[i].omit = 1;
-      }
-    }else if( p->usable ){
-      if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
-        assert( p->op==FTS5_PATTERN_LIKE || p->op==FTS5_PATTERN_GLOB );
-        idxStr[iIdxStr++] = p->op==FTS5_PATTERN_LIKE ? 'L' : 'G';
-        sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
-        idxStr += strlen(&idxStr[iIdxStr]);
-        pInfo->aConstraintUsage[i].argvIndex = ++iCons;
-        assert( idxStr[iIdxStr]=='\0' );
-        nSeenMatch++;
-      }else if( bSeenEq==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol<0 ){
-        idxStr[iIdxStr++] = '=';
-        bSeenEq = 1;
-        pInfo->aConstraintUsage[i].argvIndex = ++iCons;
-        pInfo->aConstraintUsage[i].omit = 1;
-      }
-    }
-  }
-
-  if( bSeenEq==0 ){
-    for(i=0; i<pInfo->nConstraint; i++){
-      struct sqlite3_index_constraint *p = &pInfo->aConstraint[i];
-      if( p->iColumn<0 && p->usable ){
-        int op = p->op;
-        if( op==SQLITE_INDEX_CONSTRAINT_LT || op==SQLITE_INDEX_CONSTRAINT_LE ){
-          if( bSeenLt ) continue;
-          idxStr[iIdxStr++] = '<';
-          pInfo->aConstraintUsage[i].argvIndex = ++iCons;
-          bSeenLt = 1;
-        }else
-        if( op==SQLITE_INDEX_CONSTRAINT_GT || op==SQLITE_INDEX_CONSTRAINT_GE ){
-          if( bSeenGt ) continue;
-          idxStr[iIdxStr++] = '>';
-          pInfo->aConstraintUsage[i].argvIndex = ++iCons;
-          bSeenGt = 1;
-        }
-      }
-    }
-  }
-  idxStr[iIdxStr] = '\0';
-
-  /* Set idxFlags flags for the ORDER BY clause
-  **
-  ** Note that tokendata=1 tables cannot currently handle "ORDER BY rowid DESC".
-  */
-  if( pInfo->nOrderBy==1 ){
-    int iSort = pInfo->aOrderBy[0].iColumn;
-    if( iSort==(pConfig->nCol+1) && nSeenMatch>0 ){
-      idxFlags |= FTS5_BI_ORDER_RANK;
-    }else if( iSort==-1 && (!pInfo->aOrderBy[0].desc || !pConfig->bTokendata) ){
-      idxFlags |= FTS5_BI_ORDER_ROWID;
-    }
-    if( BitFlagTest(idxFlags, FTS5_BI_ORDER_RANK|FTS5_BI_ORDER_ROWID) ){
-      pInfo->orderByConsumed = 1;
-      if( pInfo->aOrderBy[0].desc ){
-        idxFlags |= FTS5_BI_ORDER_DESC;
-      }
-    }
-  }
-
-  /* Calculate the estimated cost based on the flags set in idxFlags. */
-  if( bSeenEq ){
-    pInfo->estimatedCost = nSeenMatch ? 25000.0 : 25.0;
-    fts5SetEstimatedRows(pInfo, 1);
-    fts5SetUniqueFlag(pInfo);
-  }else{
-    i64 nEstRows;
-    if( nSeenMatch ){
-      if( bSeenLt && bSeenGt ){
-        pInfo->estimatedCost = 50000.0;
-      }else if( bSeenLt || bSeenGt ){
-        pInfo->estimatedCost = 37500.0;
-      }else{
-        pInfo->estimatedCost = 50000.0;
-      }
-      nEstRows = (i64)(pInfo->estimatedCost / 40.0);
-      for(i=1; i<nSeenMatch; i++){
-        pInfo->estimatedCost *= 2.5;
-        nEstRows = nEstRows / 2;
-      }
-    }else{
-      if( bSeenLt && bSeenGt ){
-        pInfo->estimatedCost = 750000.0;
-      }else if( bSeenLt || bSeenGt ){
-        pInfo->estimatedCost = 2250000.0;
-      }else{
-        pInfo->estimatedCost = 3000000.0;
-      }
-      nEstRows = (i64)(pInfo->estimatedCost / 4.0);
-    }
-    fts5SetEstimatedRows(pInfo, nEstRows);
-  }
-
-  pInfo->idxNum = idxFlags;
-  return SQLITE_OK;
-}
-
-static int fts5NewTransaction(Fts5FullTable *pTab){
-  Fts5Cursor *pCsr;
-  for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
-    if( pCsr->base.pVtab==(sqlite3_vtab*)pTab ) return SQLITE_OK;
-  }
-  return sqlite3Fts5StorageReset(pTab->pStorage);
-}
-
-/*
-** Implementation of xOpen method.
-*/
-static int fts5OpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVTab;
-  Fts5Config *pConfig = pTab->p.pConfig;
-  Fts5Cursor *pCsr = 0;           /* New cursor object */
-  sqlite3_int64 nByte;            /* Bytes of space to allocate */
-  int rc;                         /* Return code */
-
-  rc = fts5NewTransaction(pTab);
-  if( rc==SQLITE_OK ){
-    nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
-    pCsr = (Fts5Cursor*)sqlite3_malloc64(nByte);
-    if( pCsr ){
-      Fts5Global *pGlobal = pTab->pGlobal;
-      memset(pCsr, 0, (size_t)nByte);
-      pCsr->aColumnSize = (int*)&pCsr[1];
-      pCsr->pNext = pGlobal->pCsr;
-      pGlobal->pCsr = pCsr;
-      pCsr->iCsrId = ++pGlobal->iNextId;
-    }else{
-      rc = SQLITE_NOMEM;
-    }
-  }
-  *ppCsr = (sqlite3_vtab_cursor*)pCsr;
-  return rc;
-}
-
-static int fts5StmtType(Fts5Cursor *pCsr){
-  if( pCsr->ePlan==FTS5_PLAN_SCAN ){
-    return (pCsr->bDesc) ? FTS5_STMT_SCAN_DESC : FTS5_STMT_SCAN_ASC;
-  }
-  return FTS5_STMT_LOOKUP;
-}
-
-/*
-** This function is called after the cursor passed as the only argument
-** is moved to point at a different row. It clears all cached data
-** specific to the previous row stored by the cursor object.
-*/
-static void fts5CsrNewrow(Fts5Cursor *pCsr){
-  CsrFlagSet(pCsr,
-      FTS5CSR_REQUIRE_CONTENT
-    | FTS5CSR_REQUIRE_DOCSIZE
-    | FTS5CSR_REQUIRE_INST
-    | FTS5CSR_REQUIRE_POSLIST
-  );
-}
-
-static void fts5FreeCursorComponents(Fts5Cursor *pCsr){
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-  Fts5Auxdata *pData;
-  Fts5Auxdata *pNext;
-
-  sqlite3_free(pCsr->aInstIter);
-  sqlite3_free(pCsr->aInst);
-  if( pCsr->pStmt ){
-    int eStmt = fts5StmtType(pCsr);
-    sqlite3Fts5StorageStmtRelease(pTab->pStorage, eStmt, pCsr->pStmt);
-  }
-  if( pCsr->pSorter ){
-    Fts5Sorter *pSorter = pCsr->pSorter;
-    sqlite3_finalize(pSorter->pStmt);
-    sqlite3_free(pSorter);
-  }
-
-  if( pCsr->ePlan!=FTS5_PLAN_SOURCE ){
-    sqlite3Fts5ExprFree(pCsr->pExpr);
-  }
-
-  for(pData=pCsr->pAuxdata; pData; pData=pNext){
-    pNext = pData->pNext;
-    if( pData->xDelete ) pData->xDelete(pData->pPtr);
-    sqlite3_free(pData);
-  }
-
-  sqlite3_finalize(pCsr->pRankArgStmt);
-  sqlite3_free(pCsr->apRankArg);
-
-  if( CsrFlagTest(pCsr, FTS5CSR_FREE_ZRANK) ){
-    sqlite3_free(pCsr->zRank);
-    sqlite3_free(pCsr->zRankArgs);
-  }
-
-  sqlite3Fts5IndexCloseReader(pTab->p.pIndex);
-  memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan - (u8*)pCsr));
-}
-
-
-/*
-** Close the cursor.  For additional information see the documentation
-** on the xClose method of the virtual table interface.
-*/
-static int fts5CloseMethod(sqlite3_vtab_cursor *pCursor){
-  if( pCursor ){
-    Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
-    Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
-    Fts5Cursor **pp;
-
-    fts5FreeCursorComponents(pCsr);
-    /* Remove the cursor from the Fts5Global.pCsr list */
-    for(pp=&pTab->pGlobal->pCsr; (*pp)!=pCsr; pp=&(*pp)->pNext);
-    *pp = pCsr->pNext;
-
-    sqlite3_free(pCsr);
-  }
-  return SQLITE_OK;
-}
-
-static int fts5SorterNext(Fts5Cursor *pCsr){
-  Fts5Sorter *pSorter = pCsr->pSorter;
-  int rc;
-
-  rc = sqlite3_step(pSorter->pStmt);
-  if( rc==SQLITE_DONE ){
-    rc = SQLITE_OK;
-    CsrFlagSet(pCsr, FTS5CSR_EOF|FTS5CSR_REQUIRE_CONTENT);
-  }else if( rc==SQLITE_ROW ){
-    const u8 *a;
-    const u8 *aBlob;
-    int nBlob;
-    int i;
-    int iOff = 0;
-    rc = SQLITE_OK;
-
-    pSorter->iRowid = sqlite3_column_int64(pSorter->pStmt, 0);
-    nBlob = sqlite3_column_bytes(pSorter->pStmt, 1);
-    aBlob = a = sqlite3_column_blob(pSorter->pStmt, 1);
-
-    /* nBlob==0 in detail=none mode. */
-    if( nBlob>0 ){
-      for(i=0; i<(pSorter->nIdx-1); i++){
-        int iVal;
-        a += fts5GetVarint32(a, iVal);
-        iOff += iVal;
-        pSorter->aIdx[i] = iOff;
-      }
-      pSorter->aIdx[i] = &aBlob[nBlob] - a;
-      pSorter->aPoslist = a;
-    }
-
-    fts5CsrNewrow(pCsr);
-  }
-
-  return rc;
-}
-
-
-/*
-** Set the FTS5CSR_REQUIRE_RESEEK flag on all FTS5_PLAN_MATCH cursors
-** open on table pTab.
-*/
-static void fts5TripCursors(Fts5FullTable *pTab){
-  Fts5Cursor *pCsr;
-  for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
-    if( pCsr->ePlan==FTS5_PLAN_MATCH
-     && pCsr->base.pVtab==(sqlite3_vtab*)pTab
-    ){
-      CsrFlagSet(pCsr, FTS5CSR_REQUIRE_RESEEK);
-    }
-  }
-}
-
-/*
-** If the REQUIRE_RESEEK flag is set on the cursor passed as the first
-** argument, close and reopen all Fts5IndexIter iterators that the cursor
-** is using. Then attempt to move the cursor to a rowid equal to or laster
-** (in the cursors sort order - ASC or DESC) than the current rowid.
-**
-** If the new rowid is not equal to the old, set output parameter *pbSkip
-** to 1 before returning. Otherwise, leave it unchanged.
-**
-** Return SQLITE_OK if successful or if no reseek was required, or an
-** error code if an error occurred.
-*/
-static int fts5CursorReseek(Fts5Cursor *pCsr, int *pbSkip){
-  int rc = SQLITE_OK;
-  assert( *pbSkip==0 );
-  if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_RESEEK) ){
-    Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-    int bDesc = pCsr->bDesc;
-    i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
-
-    rc = sqlite3Fts5ExprFirst(
-        pCsr->pExpr, pTab->p.pIndex, iRowid, pCsr->iLastRowid, bDesc
-    );
-    if( rc==SQLITE_OK &&  iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
-      *pbSkip = 1;
-    }
-
-    CsrFlagClear(pCsr, FTS5CSR_REQUIRE_RESEEK);
-    fts5CsrNewrow(pCsr);
-    if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
-      CsrFlagSet(pCsr, FTS5CSR_EOF);
-      *pbSkip = 1;
-    }
-  }
-  return rc;
-}
-
-
-/*
-** Advance the cursor to the next row in the table that matches the
-** search criteria.
-**
-** Return SQLITE_OK if nothing goes wrong.  SQLITE_OK is returned
-** even if we reach end-of-file.  The fts5EofMethod() will be called
-** subsequently to determine whether or not an EOF was hit.
-*/
-static int fts5NextMethod(sqlite3_vtab_cursor *pCursor){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
-  int rc;
-
-  assert( (pCsr->ePlan<3)==
-          (pCsr->ePlan==FTS5_PLAN_MATCH || pCsr->ePlan==FTS5_PLAN_SOURCE)
-  );
-  assert( !CsrFlagTest(pCsr, FTS5CSR_EOF) );
-
-  /* If this cursor uses FTS5_PLAN_MATCH and this is a tokendata=1 table,
-  ** clear any token mappings accumulated at the fts5_index.c level. In
-  ** other cases, specifically FTS5_PLAN_SOURCE and FTS5_PLAN_SORTED_MATCH,
-  ** we need to retain the mappings for the entire query.  */
-  if( pCsr->ePlan==FTS5_PLAN_MATCH
-   && ((Fts5Table*)pCursor->pVtab)->pConfig->bTokendata
-  ){
-    sqlite3Fts5ExprClearTokens(pCsr->pExpr);
-  }
-
-  if( pCsr->ePlan<3 ){
-    int bSkip = 0;
-    if( (rc = fts5CursorReseek(pCsr, &bSkip)) || bSkip ) return rc;
-    rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
-    CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
-    fts5CsrNewrow(pCsr);
-  }else{
-    switch( pCsr->ePlan ){
-      case FTS5_PLAN_SPECIAL: {
-        CsrFlagSet(pCsr, FTS5CSR_EOF);
-        rc = SQLITE_OK;
-        break;
-      }
-
-      case FTS5_PLAN_SORTED_MATCH: {
-        rc = fts5SorterNext(pCsr);
-        break;
-      }
-
-      default: {
-        Fts5Config *pConfig = ((Fts5Table*)pCursor->pVtab)->pConfig;
-        pConfig->bLock++;
-        rc = sqlite3_step(pCsr->pStmt);
-        pConfig->bLock--;
-        if( rc!=SQLITE_ROW ){
-          CsrFlagSet(pCsr, FTS5CSR_EOF);
-          rc = sqlite3_reset(pCsr->pStmt);
-          if( rc!=SQLITE_OK ){
-            pCursor->pVtab->zErrMsg = sqlite3_mprintf(
-                "%s", sqlite3_errmsg(pConfig->db)
-            );
-          }
-        }else{
-          rc = SQLITE_OK;
-          CsrFlagSet(pCsr, FTS5CSR_REQUIRE_DOCSIZE);
-        }
-        break;
-      }
-    }
-  }
-
-  return rc;
-}
-
-
-static int fts5PrepareStatement(
-  sqlite3_stmt **ppStmt,
-  Fts5Config *pConfig,
-  const char *zFmt,
-  ...
-){
-  sqlite3_stmt *pRet = 0;
-  int rc;
-  char *zSql;
-  va_list ap;
-
-  va_start(ap, zFmt);
-  zSql = sqlite3_vmprintf(zFmt, ap);
-  if( zSql==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    rc = sqlite3_prepare_v3(pConfig->db, zSql, -1,
-                            SQLITE_PREPARE_PERSISTENT, &pRet, 0);
-    if( rc!=SQLITE_OK ){
-      sqlite3Fts5ConfigErrmsg(pConfig, "%s", sqlite3_errmsg(pConfig->db));
-    }
-    sqlite3_free(zSql);
-  }
-
-  va_end(ap);
-  *ppStmt = pRet;
-  return rc;
-}
-
-static int fts5CursorFirstSorted(
-  Fts5FullTable *pTab,
-  Fts5Cursor *pCsr,
-  int bDesc
-){
-  Fts5Config *pConfig = pTab->p.pConfig;
-  Fts5Sorter *pSorter;
-  int nPhrase;
-  sqlite3_int64 nByte;
-  int rc;
-  const char *zRank = pCsr->zRank;
-  const char *zRankArgs = pCsr->zRankArgs;
-
-  nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
-  nByte = SZ_FTS5SORTER(nPhrase);
-  pSorter = (Fts5Sorter*)sqlite3_malloc64(nByte);
-  if( pSorter==0 ) return SQLITE_NOMEM;
-  memset(pSorter, 0, (size_t)nByte);
-  pSorter->nIdx = nPhrase;
-
-  /* TODO: It would be better to have some system for reusing statement
-  ** handles here, rather than preparing a new one for each query. But that
-  ** is not possible as SQLite reference counts the virtual table objects.
-  ** And since the statement required here reads from this very virtual
-  ** table, saving it creates a circular reference.
-  **
-  ** If SQLite a built-in statement cache, this wouldn't be a problem. */
-  rc = fts5PrepareStatement(&pSorter->pStmt, pConfig,
-      "SELECT rowid, rank FROM %Q.%Q ORDER BY %s(\"%w\"%s%s) %s",
-      pConfig->zDb, pConfig->zName, zRank, pConfig->zName,
-      (zRankArgs ? ", " : ""),
-      (zRankArgs ? zRankArgs : ""),
-      bDesc ? "DESC" : "ASC"
-  );
-
-  pCsr->pSorter = pSorter;
-  if( rc==SQLITE_OK ){
-    assert( pTab->pSortCsr==0 );
-    pTab->pSortCsr = pCsr;
-    rc = fts5SorterNext(pCsr);
-    pTab->pSortCsr = 0;
-  }
-
-  if( rc!=SQLITE_OK ){
-    sqlite3_finalize(pSorter->pStmt);
-    sqlite3_free(pSorter);
-    pCsr->pSorter = 0;
-  }
-
-  return rc;
-}
-
-static int fts5CursorFirst(Fts5FullTable *pTab, Fts5Cursor *pCsr, int bDesc){
-  int rc;
-  Fts5Expr *pExpr = pCsr->pExpr;
-  rc = sqlite3Fts5ExprFirst(
-      pExpr, pTab->p.pIndex, pCsr->iFirstRowid, pCsr->iLastRowid, bDesc
-  );
-  if( sqlite3Fts5ExprEof(pExpr) ){
-    CsrFlagSet(pCsr, FTS5CSR_EOF);
-  }
-  fts5CsrNewrow(pCsr);
-  return rc;
-}
-
-/*
-** Process a "special" query. A special query is identified as one with a
-** MATCH expression that begins with a '*' character. The remainder of
-** the text passed to the MATCH operator are used as  the special query
-** parameters.
-*/
-static int fts5SpecialMatch(
-  Fts5FullTable *pTab,
-  Fts5Cursor *pCsr,
-  const char *zQuery
-){
-  int rc = SQLITE_OK;             /* Return code */
-  const char *z = zQuery;         /* Special query text */
-  int n;                          /* Number of bytes in text at z */
-
-  while( z[0]==' ' ) z++;
-  for(n=0; z[n] && z[n]!=' '; n++);
-
-  assert( pTab->p.base.zErrMsg==0 );
-  pCsr->ePlan = FTS5_PLAN_SPECIAL;
-
-  if( n==5 && 0==sqlite3_strnicmp("reads", z, n) ){
-    pCsr->iSpecial = sqlite3Fts5IndexReads(pTab->p.pIndex);
-  }
-  else if( n==2 && 0==sqlite3_strnicmp("id", z, n) ){
-    pCsr->iSpecial = pCsr->iCsrId;
-  }
-  else{
-    /* An unrecognized directive. Return an error message. */
-    pTab->p.base.zErrMsg = sqlite3_mprintf("unknown special query: %.*s", n, z);
-    rc = SQLITE_ERROR;
-  }
-
-  return rc;
-}
-
-/*
-** Search for an auxiliary function named zName that can be used with table
-** pTab. If one is found, return a pointer to the corresponding Fts5Auxiliary
-** structure. Otherwise, if no such function exists, return NULL.
-*/
-static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
-  Fts5Auxiliary *pAux;
-
-  for(pAux=pTab->pGlobal->pAux; pAux; pAux=pAux->pNext){
-    if( sqlite3_stricmp(zName, pAux->zFunc)==0 ) return pAux;
-  }
-
-  /* No function of the specified name was found. Return 0. */
-  return 0;
-}
-
-
-static int fts5FindRankFunction(Fts5Cursor *pCsr){
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-  Fts5Config *pConfig = pTab->p.pConfig;
-  int rc = SQLITE_OK;
-  Fts5Auxiliary *pAux = 0;
-  const char *zRank = pCsr->zRank;
-  const char *zRankArgs = pCsr->zRankArgs;
-
-  if( zRankArgs ){
-    char *zSql = sqlite3Fts5Mprintf(&rc, "SELECT %s", zRankArgs);
-    if( zSql ){
-      sqlite3_stmt *pStmt = 0;
-      rc = sqlite3_prepare_v3(pConfig->db, zSql, -1,
-                              SQLITE_PREPARE_PERSISTENT, &pStmt, 0);
-      sqlite3_free(zSql);
-      assert( rc==SQLITE_OK || pCsr->pRankArgStmt==0 );
-      if( rc==SQLITE_OK ){
-        if( SQLITE_ROW==sqlite3_step(pStmt) ){
-          sqlite3_int64 nByte;
-          pCsr->nRankArg = sqlite3_column_count(pStmt);
-          nByte = sizeof(sqlite3_value*)*pCsr->nRankArg;
-          pCsr->apRankArg = (sqlite3_value**)sqlite3Fts5MallocZero(&rc, nByte);
-          if( rc==SQLITE_OK ){
-            int i;
-            for(i=0; i<pCsr->nRankArg; i++){
-              pCsr->apRankArg[i] = sqlite3_column_value(pStmt, i);
-            }
-          }
-          pCsr->pRankArgStmt = pStmt;
-        }else{
-          rc = sqlite3_finalize(pStmt);
-          assert( rc!=SQLITE_OK );
-        }
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    pAux = fts5FindAuxiliary(pTab, zRank);
-    if( pAux==0 ){
-      assert( pTab->p.base.zErrMsg==0 );
-      pTab->p.base.zErrMsg = sqlite3_mprintf("no such function: %s", zRank);
-      rc = SQLITE_ERROR;
-    }
-  }
-
-  pCsr->pRank = pAux;
-  return rc;
-}
-
-
-static int fts5CursorParseRank(
-  Fts5Config *pConfig,
-  Fts5Cursor *pCsr,
-  sqlite3_value *pRank
-){
-  int rc = SQLITE_OK;
-  if( pRank ){
-    const char *z = (const char*)sqlite3_value_text(pRank);
-    char *zRank = 0;
-    char *zRankArgs = 0;
-
-    if( z==0 ){
-      if( sqlite3_value_type(pRank)==SQLITE_NULL ) rc = SQLITE_ERROR;
-    }else{
-      rc = sqlite3Fts5ConfigParseRank(z, &zRank, &zRankArgs);
-    }
-    if( rc==SQLITE_OK ){
-      pCsr->zRank = zRank;
-      pCsr->zRankArgs = zRankArgs;
-      CsrFlagSet(pCsr, FTS5CSR_FREE_ZRANK);
-    }else if( rc==SQLITE_ERROR ){
-      pCsr->base.pVtab->zErrMsg = sqlite3_mprintf(
-          "parse error in rank function: %s", z
-      );
-    }
-  }else{
-    if( pConfig->zRank ){
-      pCsr->zRank = (char*)pConfig->zRank;
-      pCsr->zRankArgs = (char*)pConfig->zRankArgs;
-    }else{
-      pCsr->zRank = (char*)FTS5_DEFAULT_RANK;
-      pCsr->zRankArgs = 0;
-    }
-  }
-  return rc;
-}
-
-static i64 fts5GetRowidLimit(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;
-}
-
-/*
-** Set the error message on the virtual table passed as the first argument.
-*/
-static void fts5SetVtabError(Fts5FullTable *p, const char *zFormat, ...){
-  va_list ap;                     /* ... printf arguments */
-  va_start(ap, zFormat);
-  sqlite3_free(p->p.base.zErrMsg);
-  p->p.base.zErrMsg = sqlite3_vmprintf(zFormat, ap);
-  va_end(ap);
-}
-
-/*
-** Arrange for subsequent calls to sqlite3Fts5Tokenize() to use the locale
-** specified by pLocale/nLocale. The buffer indicated by pLocale must remain
-** valid until after the final call to sqlite3Fts5Tokenize() that will use
-** the locale.
-*/
-static void sqlite3Fts5SetLocale(
-  Fts5Config *pConfig,
-  const char *zLocale,
-  int nLocale
-){
-  Fts5TokenizerConfig *pT = &pConfig->t;
-  pT->pLocale = zLocale;
-  pT->nLocale = nLocale;
-}
-
-/*
-** Clear any locale configured by an earlier call to sqlite3Fts5SetLocale().
-*/
-static void sqlite3Fts5ClearLocale(Fts5Config *pConfig){
-  sqlite3Fts5SetLocale(pConfig, 0, 0);
-}
-
-/*
-** Return true if the value passed as the only argument is an
-** fts5_locale() value.
-*/
-static int sqlite3Fts5IsLocaleValue(Fts5Config *pConfig, sqlite3_value *pVal){
-  int ret = 0;
-  if( sqlite3_value_type(pVal)==SQLITE_BLOB ){
-    /* Call sqlite3_value_bytes() after sqlite3_value_blob() in this case.
-    ** If the blob was created using zeroblob(), then sqlite3_value_blob()
-    ** may call malloc(). If this malloc() fails, then the values returned
-    ** by both value_blob() and value_bytes() will be 0. If value_bytes() were
-    ** called first, then the NULL pointer returned by value_blob() might
-    ** be dereferenced.  */
-    const u8 *pBlob = sqlite3_value_blob(pVal);
-    int nBlob = sqlite3_value_bytes(pVal);
-    if( nBlob>FTS5_LOCALE_HDR_SIZE
-     && 0==memcmp(pBlob, FTS5_LOCALE_HDR(pConfig), FTS5_LOCALE_HDR_SIZE)
-    ){
-      ret = 1;
-    }
-  }
-  return ret;
-}
-
-/*
-** Value pVal is guaranteed to be an fts5_locale() value, according to
-** sqlite3Fts5IsLocaleValue(). This function extracts the text and locale
-** from the value and returns them separately.
-**
-** If successful, SQLITE_OK is returned and (*ppText) and (*ppLoc) set
-** to point to buffers containing the text and locale, as utf-8,
-** respectively. In this case output parameters (*pnText) and (*pnLoc) are
-** set to the sizes in bytes of these two buffers.
-**
-** Or, if an error occurs, then an SQLite error code is returned. The final
-** value of the four output parameters is undefined in this case.
-*/
-static int sqlite3Fts5DecodeLocaleValue(
-  sqlite3_value *pVal,
-  const char **ppText,
-  int *pnText,
-  const char **ppLoc,
-  int *pnLoc
-){
-  const char *p = sqlite3_value_blob(pVal);
-  int n = sqlite3_value_bytes(pVal);
-  int nLoc = 0;
-
-  assert( sqlite3_value_type(pVal)==SQLITE_BLOB );
-  assert( n>FTS5_LOCALE_HDR_SIZE );
-
-  for(nLoc=FTS5_LOCALE_HDR_SIZE; p[nLoc]; nLoc++){
-    if( nLoc==(n-1) ){
-      return SQLITE_MISMATCH;
-    }
-  }
-  *ppLoc = &p[FTS5_LOCALE_HDR_SIZE];
-  *pnLoc = nLoc - FTS5_LOCALE_HDR_SIZE;
-
-  *ppText = &p[nLoc+1];
-  *pnText = n - nLoc - 1;
-  return SQLITE_OK;
-}
-
-/*
-** Argument pVal is the text of a full-text search expression. It may or
-** may not have been wrapped by fts5_locale(). This function extracts
-** the text of the expression, and sets output variable (*pzText) to
-** point to a nul-terminated buffer containing the expression.
-**
-** If pVal was an fts5_locale() value, then sqlite3Fts5SetLocale() is called
-** to set the tokenizer to use the specified locale.
-**
-** If output variable (*pbFreeAndReset) is set to true, then the caller
-** is required to (a) call sqlite3Fts5ClearLocale() to reset the tokenizer
-** locale, and (b) call sqlite3_free() to free (*pzText).
-*/
-static int fts5ExtractExprText(
-  Fts5Config *pConfig,            /* Fts5 configuration */
-  sqlite3_value *pVal,            /* Value to extract expression text from */
-  char **pzText,                  /* OUT: nul-terminated buffer of text */
-  int *pbFreeAndReset             /* OUT: Free (*pzText) and clear locale */
-){
-  int rc = SQLITE_OK;
-
-  if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
-    const char *pText = 0;
-    int nText = 0;
-    const char *pLoc = 0;
-    int nLoc = 0;
-    rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
-    *pzText = sqlite3Fts5Mprintf(&rc, "%.*s", nText, pText);
-    if( rc==SQLITE_OK ){
-      sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
-    }
-    *pbFreeAndReset = 1;
-  }else{
-    *pzText = (char*)sqlite3_value_text(pVal);
-    *pbFreeAndReset = 0;
-  }
-
-  return rc;
-}
-
-
-/*
-** This is the xFilter interface for the virtual table.  See
-** the virtual table xFilter method documentation for additional
-** information.
-**
-** There are three possible query strategies:
-**
-**   1. Full-text search using a MATCH operator.
-**   2. A by-rowid lookup.
-**   3. A full-table scan.
-*/
-static int fts5FilterMethod(
-  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 */
-){
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
-  Fts5Config *pConfig = pTab->p.pConfig;
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
-  int rc = SQLITE_OK;             /* Error code */
-  int bDesc;                      /* True if ORDER BY [rank|rowid] DESC */
-  int bOrderByRank;               /* True if ORDER BY rank */
-  sqlite3_value *pRank = 0;       /* rank MATCH ? expression (or NULL) */
-  sqlite3_value *pRowidEq = 0;    /* rowid = ? expression (or NULL) */
-  sqlite3_value *pRowidLe = 0;    /* rowid <= ? expression (or NULL) */
-  sqlite3_value *pRowidGe = 0;    /* rowid >= ? expression (or NULL) */
-  int iCol;                       /* Column on LHS of MATCH operator */
-  char **pzErrmsg = pConfig->pzErrmsg;
-  int bPrefixInsttoken = pConfig->bPrefixInsttoken;
-  int i;
-  int iIdxStr = 0;
-  Fts5Expr *pExpr = 0;
-
-  assert( pConfig->bLock==0 );
-  if( pCsr->ePlan ){
-    fts5FreeCursorComponents(pCsr);
-    memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan-(u8*)pCsr));
-  }
-
-  assert( pCsr->pStmt==0 );
-  assert( pCsr->pExpr==0 );
-  assert( pCsr->csrflags==0 );
-  assert( pCsr->pRank==0 );
-  assert( pCsr->zRank==0 );
-  assert( pCsr->zRankArgs==0 );
-  assert( pTab->pSortCsr==0 || nVal==0 );
-
-  assert( pzErrmsg==0 || pzErrmsg==&pTab->p.base.zErrMsg );
-  pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
-
-  /* Decode the arguments passed through to this function. */
-  for(i=0; i<nVal; i++){
-    switch( idxStr[iIdxStr++] ){
-      case 'r':
-        pRank = apVal[i];
-        break;
-      case 'M': {
-        char *zText = 0;
-        int bFreeAndReset = 0;
-        int bInternal = 0;
-
-        rc = fts5ExtractExprText(pConfig, apVal[i], &zText, &bFreeAndReset);
-        if( rc!=SQLITE_OK ) goto filter_out;
-        if( zText==0 ) zText = "";
-        if( sqlite3_value_subtype(apVal[i])==FTS5_INSTTOKEN_SUBTYPE ){
-          pConfig->bPrefixInsttoken = 1;
-        }
-
-        iCol = 0;
-        do{
-          iCol = iCol*10 + (idxStr[iIdxStr]-'0');
-          iIdxStr++;
-        }while( idxStr[iIdxStr]>='0' && idxStr[iIdxStr]<='9' );
-
-        if( zText[0]=='*' ){
-          /* The user has issued a query of the form "MATCH '*...'". This
-          ** indicates that the MATCH expression is not a full text query,
-          ** but a request for an internal parameter.  */
-          rc = fts5SpecialMatch(pTab, pCsr, &zText[1]);
-          bInternal = 1;
-        }else{
-          char **pzErr = &pTab->p.base.zErrMsg;
-          rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
-          if( rc==SQLITE_OK ){
-            rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
-            pExpr = 0;
-          }
-        }
-
-        if( bFreeAndReset ){
-          sqlite3_free(zText);
-          sqlite3Fts5ClearLocale(pConfig);
-        }
-
-        if( bInternal || rc!=SQLITE_OK ) goto filter_out;
-
-        break;
-      }
-      case 'L':
-      case 'G': {
-        int bGlob = (idxStr[iIdxStr-1]=='G');
-        const char *zText = (const char*)sqlite3_value_text(apVal[i]);
-        iCol = 0;
-        do{
-          iCol = iCol*10 + (idxStr[iIdxStr]-'0');
-          iIdxStr++;
-        }while( idxStr[iIdxStr]>='0' && idxStr[iIdxStr]<='9' );
-        if( zText ){
-          rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
-        }
-        if( rc==SQLITE_OK ){
-          rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
-          pExpr = 0;
-        }
-        if( rc!=SQLITE_OK ) goto filter_out;
-        break;
-      }
-      case '=':
-        pRowidEq = apVal[i];
-        break;
-      case '<':
-        pRowidLe = apVal[i];
-        break;
-      default: assert( idxStr[iIdxStr-1]=='>' );
-        pRowidGe = apVal[i];
-        break;
-    }
-  }
-  bOrderByRank = ((idxNum & FTS5_BI_ORDER_RANK) ? 1 : 0);
-  pCsr->bDesc = bDesc = ((idxNum & FTS5_BI_ORDER_DESC) ? 1 : 0);
-
-  /* Set the cursor upper and lower rowid limits. Only some strategies
-  ** actually use them. This is ok, as the xBestIndex() method leaves the
-  ** sqlite3_index_constraint.omit flag clear for range constraints
-  ** on the rowid field.  */
-  if( pRowidEq ){
-    pRowidLe = pRowidGe = pRowidEq;
-  }
-  if( bDesc ){
-    pCsr->iFirstRowid = fts5GetRowidLimit(pRowidLe, LARGEST_INT64);
-    pCsr->iLastRowid = fts5GetRowidLimit(pRowidGe, SMALLEST_INT64);
-  }else{
-    pCsr->iLastRowid = fts5GetRowidLimit(pRowidLe, LARGEST_INT64);
-    pCsr->iFirstRowid = fts5GetRowidLimit(pRowidGe, SMALLEST_INT64);
-  }
-
-  rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
-  if( rc!=SQLITE_OK ) goto filter_out;
-
-  if( pTab->pSortCsr ){
-    /* If pSortCsr is non-NULL, then this call is being made as part of
-    ** processing for a "... MATCH <expr> ORDER BY rank" query (ePlan is
-    ** set to FTS5_PLAN_SORTED_MATCH). pSortCsr is the cursor that will
-    ** return results to the user for this query. The current cursor
-    ** (pCursor) is used to execute the query issued by function
-    ** fts5CursorFirstSorted() above.  */
-    assert( pRowidEq==0 && pRowidLe==0 && pRowidGe==0 && pRank==0 );
-    assert( nVal==0 && bOrderByRank==0 && bDesc==0 );
-    assert( pCsr->iLastRowid==LARGEST_INT64 );
-    assert( pCsr->iFirstRowid==SMALLEST_INT64 );
-    if( pTab->pSortCsr->bDesc ){
-      pCsr->iLastRowid = pTab->pSortCsr->iFirstRowid;
-      pCsr->iFirstRowid = pTab->pSortCsr->iLastRowid;
-    }else{
-      pCsr->iLastRowid = pTab->pSortCsr->iLastRowid;
-      pCsr->iFirstRowid = pTab->pSortCsr->iFirstRowid;
-    }
-    pCsr->ePlan = FTS5_PLAN_SOURCE;
-    pCsr->pExpr = pTab->pSortCsr->pExpr;
-    rc = fts5CursorFirst(pTab, pCsr, bDesc);
-  }else if( pCsr->pExpr ){
-    assert( rc==SQLITE_OK );
-    rc = fts5CursorParseRank(pConfig, pCsr, pRank);
-    if( rc==SQLITE_OK ){
-      if( bOrderByRank ){
-        pCsr->ePlan = FTS5_PLAN_SORTED_MATCH;
-        rc = fts5CursorFirstSorted(pTab, pCsr, bDesc);
-      }else{
-        pCsr->ePlan = FTS5_PLAN_MATCH;
-        rc = fts5CursorFirst(pTab, pCsr, bDesc);
-      }
-    }
-  }else if( pConfig->zContent==0 ){
-    fts5SetVtabError(pTab,"%s: table does not support scanning",pConfig->zName);
-    rc = SQLITE_ERROR;
-  }else{
-    /* This is either a full-table scan (ePlan==FTS5_PLAN_SCAN) or a lookup
-    ** by rowid (ePlan==FTS5_PLAN_ROWID).  */
-    pCsr->ePlan = (pRowidEq ? FTS5_PLAN_ROWID : FTS5_PLAN_SCAN);
-    rc = sqlite3Fts5StorageStmt(
-        pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
-    );
-    if( rc==SQLITE_OK ){
-      if( pRowidEq!=0 ){
-        assert( pCsr->ePlan==FTS5_PLAN_ROWID );
-        sqlite3_bind_value(pCsr->pStmt, 1, pRowidEq);
-      }else{
-        sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iFirstRowid);
-        sqlite3_bind_int64(pCsr->pStmt, 2, pCsr->iLastRowid);
-      }
-      rc = fts5NextMethod(pCursor);
-    }
-  }
-
- filter_out:
-  sqlite3Fts5ExprFree(pExpr);
-  pConfig->pzErrmsg = pzErrmsg;
-  pConfig->bPrefixInsttoken = bPrefixInsttoken;
-  return rc;
-}
-
-/*
-** 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 fts5EofMethod(sqlite3_vtab_cursor *pCursor){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
-  return (CsrFlagTest(pCsr, FTS5CSR_EOF) ? 1 : 0);
-}
-
-/*
-** Return the rowid that the cursor currently points to.
-*/
-static i64 fts5CursorRowid(Fts5Cursor *pCsr){
-  assert( pCsr->ePlan==FTS5_PLAN_MATCH
-       || pCsr->ePlan==FTS5_PLAN_SORTED_MATCH
-       || pCsr->ePlan==FTS5_PLAN_SOURCE
-       || pCsr->ePlan==FTS5_PLAN_SCAN
-       || pCsr->ePlan==FTS5_PLAN_ROWID
-  );
-  if( pCsr->pSorter ){
-    return pCsr->pSorter->iRowid;
-  }else if( pCsr->ePlan>=FTS5_PLAN_SCAN ){
-    return sqlite3_column_int64(pCsr->pStmt, 0);
-  }else{
-    return sqlite3Fts5ExprRowid(pCsr->pExpr);
-  }
-}
-
-/*
-** This is the xRowid method. The SQLite core calls this routine to
-** retrieve the rowid for the current row of the result set. fts5
-** exposes %_content.rowid as the rowid for the virtual table. The
-** rowid should be written to *pRowid.
-*/
-static int fts5RowidMethod(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
-  int ePlan = pCsr->ePlan;
-
-  assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
-  if( ePlan==FTS5_PLAN_SPECIAL ){
-    *pRowid = 0;
-  }else{
-    *pRowid = fts5CursorRowid(pCsr);
-  }
-
-  return SQLITE_OK;
-}
-
-
-/*
-** If the cursor requires seeking (bSeekRequired flag is set), seek it.
-** Return SQLITE_OK if no error occurs, or an SQLite error code otherwise.
-**
-** If argument bErrormsg is true and an error occurs, an error message may
-** be left in sqlite3_vtab.zErrMsg.
-*/
-static int fts5SeekCursor(Fts5Cursor *pCsr, int bErrormsg){
-  int rc = SQLITE_OK;
-
-  /* If the cursor does not yet have a statement handle, obtain one now. */
-  if( pCsr->pStmt==0 ){
-    Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-    int eStmt = fts5StmtType(pCsr);
-    rc = sqlite3Fts5StorageStmt(
-        pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0)
-    );
-    assert( rc!=SQLITE_OK || pTab->p.base.zErrMsg==0 );
-    assert( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) );
-  }
-
-  if( rc==SQLITE_OK && CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) ){
-    Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
-    assert( pCsr->pExpr );
-    sqlite3_reset(pCsr->pStmt);
-    sqlite3_bind_int64(pCsr->pStmt, 1, fts5CursorRowid(pCsr));
-    pTab->pConfig->bLock++;
-    rc = sqlite3_step(pCsr->pStmt);
-    pTab->pConfig->bLock--;
-    if( rc==SQLITE_ROW ){
-      rc = SQLITE_OK;
-      CsrFlagClear(pCsr, FTS5CSR_REQUIRE_CONTENT);
-    }else{
-      rc = sqlite3_reset(pCsr->pStmt);
-      if( rc==SQLITE_OK ){
-        rc = FTS5_CORRUPT;
-        fts5SetVtabError((Fts5FullTable*)pTab,
-            "fts5: missing row %lld from content table %s",
-            fts5CursorRowid(pCsr),
-            pTab->pConfig->zContent
-        );
-      }else if( pTab->pConfig->pzErrmsg ){
-        fts5SetVtabError((Fts5FullTable*)pTab,
-            "%s", sqlite3_errmsg(pTab->pConfig->db)
-        );
-      }
-    }
-  }
-  return rc;
-}
-
-/*
-** This function is called to handle an FTS INSERT command. In other words,
-** an INSERT statement of the form:
-**
-**     INSERT INTO fts(fts) VALUES($pCmd)
-**     INSERT INTO fts(fts, rank) VALUES($pCmd, $pVal)
-**
-** Argument pVal is the value assigned to column "fts" by the INSERT
-** statement. This function returns SQLITE_OK if successful, or an SQLite
-** error code if an error occurs.
-**
-** The commands implemented by this function are documented in the "Special
-** INSERT Directives" section of the documentation. It should be updated if
-** more commands are added to this function.
-*/
-static int fts5SpecialInsert(
-  Fts5FullTable *pTab,            /* Fts5 table object */
-  const char *zCmd,               /* Text inserted into table-name column */
-  sqlite3_value *pVal             /* Value inserted into rank column */
-){
-  Fts5Config *pConfig = pTab->p.pConfig;
-  int rc = SQLITE_OK;
-  int bError = 0;
-  int bLoadConfig = 0;
-
-  if( 0==sqlite3_stricmp("delete-all", zCmd) ){
-    if( pConfig->eContent==FTS5_CONTENT_NORMAL ){
-      fts5SetVtabError(pTab,
-          "'delete-all' may only be used with a "
-          "contentless or external content fts5 table"
-      );
-      rc = SQLITE_ERROR;
-    }else{
-      rc = sqlite3Fts5StorageDeleteAll(pTab->pStorage);
-    }
-    bLoadConfig = 1;
-  }else if( 0==sqlite3_stricmp("rebuild", zCmd) ){
-    if( fts5IsContentless(pTab, 1) ){
-      fts5SetVtabError(pTab,
-          "'rebuild' may not be used with a contentless fts5 table"
-      );
-      rc = SQLITE_ERROR;
-    }else{
-      rc = sqlite3Fts5StorageRebuild(pTab->pStorage);
-    }
-    bLoadConfig = 1;
-  }else if( 0==sqlite3_stricmp("optimize", zCmd) ){
-    rc = sqlite3Fts5StorageOptimize(pTab->pStorage);
-  }else if( 0==sqlite3_stricmp("merge", zCmd) ){
-    int nMerge = sqlite3_value_int(pVal);
-    rc = sqlite3Fts5StorageMerge(pTab->pStorage, nMerge);
-  }else if( 0==sqlite3_stricmp("integrity-check", zCmd) ){
-    int iArg = sqlite3_value_int(pVal);
-    rc = sqlite3Fts5StorageIntegrity(pTab->pStorage, iArg);
-#ifdef SQLITE_DEBUG
-  }else if( 0==sqlite3_stricmp("prefix-index", zCmd) ){
-    pConfig->bPrefixIndex = sqlite3_value_int(pVal);
-#endif
-  }else if( 0==sqlite3_stricmp("flush", zCmd) ){
-    rc = sqlite3Fts5FlushToDisk(&pTab->p);
-  }else{
-    rc = sqlite3Fts5FlushToDisk(&pTab->p);
-    if( rc==SQLITE_OK ){
-      rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
-    }
-    if( rc==SQLITE_OK ){
-      rc = sqlite3Fts5ConfigSetValue(pTab->p.pConfig, zCmd, pVal, &bError);
-    }
-    if( rc==SQLITE_OK ){
-      if( bError ){
-        rc = SQLITE_ERROR;
-      }else{
-        rc = sqlite3Fts5StorageConfigValue(pTab->pStorage, zCmd, pVal, 0);
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK && bLoadConfig ){
-    pTab->p.pConfig->iCookie--;
-    rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
-  }
-
-  return rc;
-}
-
-static int fts5SpecialDelete(
-  Fts5FullTable *pTab,
-  sqlite3_value **apVal
-){
-  int rc = SQLITE_OK;
-  int eType1 = sqlite3_value_type(apVal[1]);
-  if( eType1==SQLITE_INTEGER ){
-    sqlite3_int64 iDel = sqlite3_value_int64(apVal[1]);
-    rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, &apVal[2], 0);
-  }
-  return rc;
-}
-
-static void fts5StorageInsert(
-  int *pRc,
-  Fts5FullTable *pTab,
-  sqlite3_value **apVal,
-  i64 *piRowid
-){
-  int rc = *pRc;
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, 0, apVal, piRowid);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal, *piRowid);
-  }
-  *pRc = rc;
-}
-
-/*
-**
-** This function is called when the user attempts an UPDATE on a contentless
-** table. Parameter bRowidModified is true if the UPDATE statement modifies
-** the rowid value. Parameter apVal[] contains the new values for each user
-** defined column of the fts5 table. pConfig is the configuration object of the
-** table being updated (guaranteed to be contentless). The contentless_delete=1
-** and contentless_unindexed=1 options may or may not be set.
-**
-** This function returns SQLITE_OK if the UPDATE can go ahead, or an SQLite
-** error code if it cannot. In this case an error message is also loaded into
-** pConfig. Output parameter (*pbContent) is set to true if the caller should
-** update the %_content table only - not the FTS index or any other shadow
-** table. This occurs when an UPDATE modifies only UNINDEXED columns of the
-** table.
-**
-** An UPDATE may proceed if:
-**
-**   * The only columns modified are UNINDEXED columns, or
-**
-**   * The contentless_delete=1 option was specified and all of the indexed
-**     columns (not a subset) have been modified.
-*/
-static int fts5ContentlessUpdate(
-  Fts5Config *pConfig,
-  sqlite3_value **apVal,
-  int bRowidModified,
-  int *pbContent
-){
-  int ii;
-  int bSeenIndex = 0;             /* Have seen modified indexed column */
-  int bSeenIndexNC = 0;           /* Have seen unmodified indexed column */
-  int rc = SQLITE_OK;
-
-  for(ii=0; ii<pConfig->nCol; ii++){
-    if( pConfig->abUnindexed[ii]==0 ){
-      if( sqlite3_value_nochange(apVal[ii]) ){
-        bSeenIndexNC++;
-      }else{
-        bSeenIndex++;
-      }
-    }
-  }
-
-  if( bSeenIndex==0 && bRowidModified==0 ){
-    *pbContent = 1;
-  }else{
-    if( bSeenIndexNC || pConfig->bContentlessDelete==0 ){
-      rc = SQLITE_ERROR;
-      sqlite3Fts5ConfigErrmsg(pConfig,
-          (pConfig->bContentlessDelete ?
-          "%s a subset of columns on fts5 contentless-delete table: %s" :
-          "%s contentless fts5 table: %s")
-          , "cannot UPDATE", pConfig->zName
-      );
-    }
-  }
-
-  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.
-**
-** A delete specifies a single argument - the rowid of the row to remove.
-**
-** Update and insert operations pass:
-**
-**   1. The "old" rowid, or NULL.
-**   2. The "new" rowid.
-**   3. Values for each of the nCol matchable columns.
-**   4. Values for the two hidden columns (<tablename> and "rank").
-*/
-static int fts5UpdateMethod(
-  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 */
-){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  Fts5Config *pConfig = pTab->p.pConfig;
-  int eType0;                     /* value_type() of apVal[0] */
-  int rc = SQLITE_OK;             /* Return code */
-
-  /* A transaction must be open when this is called. */
-  assert( pTab->ts.eState==1 || pTab->ts.eState==2 );
-
-  assert( pVtab->zErrMsg==0 );
-  assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
-  assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER
-       || sqlite3_value_type(apVal[0])==SQLITE_NULL
-  );
-  assert( pTab->p.pConfig->pzErrmsg==0 );
-  if( pConfig->pgsz==0 ){
-    rc = sqlite3Fts5ConfigLoad(pTab->p.pConfig, pTab->p.pConfig->iCookie);
-    if( rc!=SQLITE_OK ) return rc;
-  }
-
-  pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
-
-  /* Put any active cursors into REQUIRE_SEEK state. */
-  fts5TripCursors(pTab);
-
-  eType0 = sqlite3_value_type(apVal[0]);
-  if( eType0==SQLITE_NULL
-   && sqlite3_value_type(apVal[2+pConfig->nCol])!=SQLITE_NULL
-  ){
-    /* A "special" INSERT op. These are handled separately. */
-    const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
-    if( pConfig->eContent!=FTS5_CONTENT_NORMAL
-      && 0==sqlite3_stricmp("delete", z)
-    ){
-      if( pConfig->bContentlessDelete ){
-        fts5SetVtabError(pTab,
-            "'delete' may not be used with a contentless_delete=1 table"
-        );
-        rc = SQLITE_ERROR;
-      }else{
-        rc = fts5SpecialDelete(pTab, apVal);
-      }
-    }else{
-      rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
-    }
-  }else{
-    /* A regular INSERT, UPDATE or DELETE statement. The trick here is that
-    ** any conflict on the rowid value must be detected before any
-    ** modifications are made to the database file. There are 4 cases:
-    **
-    **   1) DELETE
-    **   2) UPDATE (rowid not modified)
-    **   3) UPDATE (rowid modified)
-    **   4) INSERT
-    **
-    ** Cases 3 and 4 may violate the rowid constraint.
-    */
-    int eConflict = SQLITE_ABORT;
-    if( pConfig->eContent==FTS5_CONTENT_NORMAL || pConfig->bContentlessDelete ){
-      eConflict = sqlite3_vtab_on_conflict(pConfig->db);
-    }
-
-    assert( eType0==SQLITE_INTEGER || eType0==SQLITE_NULL );
-    assert( nArg!=1 || eType0==SQLITE_INTEGER );
-
-    /* DELETE */
-    if( nArg==1 ){
-      /* It is only possible to DELETE from a contentless table if the
-      ** contentless_delete=1 flag is set. */
-      if( fts5IsContentless(pTab, 1) && pConfig->bContentlessDelete==0 ){
-        fts5SetVtabError(pTab,
-            "cannot DELETE from contentless fts5 table: %s", pConfig->zName
-        );
-        rc = SQLITE_ERROR;
-      }else{
-        i64 iDel = sqlite3_value_int64(apVal[0]);  /* Rowid to delete */
-        rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, 0, 0);
-      }
-    }
-
-    /* INSERT or UPDATE */
-    else{
-      int eType1 = sqlite3_value_numeric_type(apVal[1]);
-
-      /* It is an error to write an fts5_locale() value to a table without
-      ** the locale=1 option. */
-      if( pConfig->bLocale==0 ){
-        int ii;
-        for(ii=0; ii<pConfig->nCol; ii++){
-          sqlite3_value *pVal = apVal[ii+2];
-          if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
-            fts5SetVtabError(pTab, "fts5_locale() requires locale=1");
-            rc = SQLITE_MISMATCH;
-            goto update_out;
-          }
-        }
-      }
-
-      if( eType0!=SQLITE_INTEGER ){
-        /* An INSERT statement. If the conflict-mode is REPLACE, first remove
-        ** the current entry (if any). */
-        if( eConflict==SQLITE_REPLACE && eType1==SQLITE_INTEGER ){
-          i64 iNew = sqlite3_value_int64(apVal[1]);  /* Rowid to delete */
-          rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0, 0);
-        }
-        fts5StorageInsert(&rc, pTab, apVal, pRowid);
-      }
-
-      /* UPDATE */
-      else{
-        Fts5Storage *pStorage = pTab->pStorage;
-        i64 iOld = sqlite3_value_int64(apVal[0]);  /* Old rowid */
-        i64 iNew = sqlite3_value_int64(apVal[1]);  /* New rowid */
-        int bContent = 0;         /* Content only update */
-
-        /* If this is a contentless table (including contentless_unindexed=1
-        ** tables), check if the UPDATE may proceed.  */
-        if( fts5IsContentless(pTab, 1) ){
-          rc = fts5ContentlessUpdate(pConfig, &apVal[2], iOld!=iNew, &bContent);
-          if( rc!=SQLITE_OK ) goto update_out;
-        }
-
-        if( eType1!=SQLITE_INTEGER ){
-          rc = SQLITE_MISMATCH;
-        }else if( iOld!=iNew ){
-          assert( bContent==0 );
-          if( eConflict==SQLITE_REPLACE ){
-            rc = sqlite3Fts5StorageDelete(pStorage, iOld, 0, 1);
-            if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageDelete(pStorage, iNew, 0, 0);
-            }
-            fts5StorageInsert(&rc, pTab, apVal, pRowid);
-          }else{
-            rc = sqlite3Fts5StorageFindDeleteRow(pStorage, iOld);
-            if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageContentInsert(pStorage, 0, apVal, pRowid);
-            }
-            if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageDelete(pStorage, iOld, 0, 0);
-            }
-            if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageIndexInsert(pStorage, apVal, *pRowid);
-            }
-          }
-        }else if( bContent ){
-          /* This occurs when an UPDATE on a contentless table affects *only*
-          ** UNINDEXED columns. This is a no-op for contentless_unindexed=0
-          ** tables, or a write to the %_content table only for =1 tables.  */
-          assert( fts5IsContentless(pTab, 1) );
-          rc = sqlite3Fts5StorageFindDeleteRow(pStorage, iOld);
-          if( rc==SQLITE_OK ){
-            rc = sqlite3Fts5StorageContentInsert(pStorage, 1, apVal, pRowid);
-          }
-        }else{
-          rc = sqlite3Fts5StorageDelete(pStorage, iOld, 0, 1);
-          fts5StorageInsert(&rc, pTab, apVal, pRowid);
-        }
-        sqlite3Fts5StorageReleaseDeleteRow(pStorage);
-      }
-    }
-  }
-
- update_out:
-  sqlite3Fts5IndexCloseReader(pTab->p.pIndex);
-  pTab->p.pConfig->pzErrmsg = 0;
-  return rc;
-}
-
-/*
-** Implementation of xSync() method.
-*/
-static int fts5SyncMethod(sqlite3_vtab *pVtab){
-  int rc;
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  fts5CheckTransactionState(pTab, FTS5_SYNC, 0);
-  pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
-  rc = sqlite3Fts5FlushToDisk(&pTab->p);
-  pTab->p.pConfig->pzErrmsg = 0;
-  return rc;
-}
-
-/*
-** Implementation of xBegin() method.
-*/
-static int fts5BeginMethod(sqlite3_vtab *pVtab){
-  int rc = fts5NewTransaction((Fts5FullTable*)pVtab);
-  if( rc==SQLITE_OK ){
-    fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_BEGIN, 0);
-  }
-  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 fts5SyncMethod().
-*/
-static int fts5CommitMethod(sqlite3_vtab *pVtab){
-  UNUSED_PARAM(pVtab);  /* Call below is a no-op for NDEBUG builds */
-  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_COMMIT, 0);
-  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 fts5RollbackMethod(sqlite3_vtab *pVtab){
-  int rc;
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  fts5CheckTransactionState(pTab, FTS5_ROLLBACK, 0);
-  rc = sqlite3Fts5StorageRollback(pTab->pStorage);
-  pTab->p.pConfig->pgsz = 0;
-  return rc;
-}
-
-static int fts5CsrPoslist(Fts5Cursor*, int, const u8**, int*);
-
-static void *fts5ApiUserData(Fts5Context *pCtx){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  return pCsr->pAux->pUserData;
-}
-
-static int fts5ApiColumnCount(Fts5Context *pCtx){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
-}
-
-static int fts5ApiColumnTotalSize(
-  Fts5Context *pCtx,
-  int iCol,
-  sqlite3_int64 *pnToken
-){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-  return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
-}
-
-static int fts5ApiRowCount(Fts5Context *pCtx, i64 *pnRow){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-  return sqlite3Fts5StorageRowCount(pTab->pStorage, pnRow);
-}
-
-/*
-** Implementation of xTokenize_v2() API.
-*/
-static int fts5ApiTokenize_v2(
-  Fts5Context *pCtx,
-  const char *pText, int nText,
-  const char *pLoc, int nLoc,
-  void *pUserData,
-  int (*xToken)(void*, int, const char*, int, int, int)
-){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
-  int rc = SQLITE_OK;
-
-  sqlite3Fts5SetLocale(pTab->pConfig, pLoc, nLoc);
-  rc = sqlite3Fts5Tokenize(pTab->pConfig,
-      FTS5_TOKENIZE_AUX, pText, nText, pUserData, xToken
-  );
-  sqlite3Fts5SetLocale(pTab->pConfig, 0, 0);
-
-  return rc;
-}
-
-/*
-** Implementation of xTokenize() API. This is just xTokenize_v2() with NULL/0
-** passed as the locale.
-*/
-static int fts5ApiTokenize(
-  Fts5Context *pCtx,
-  const char *pText, int nText,
-  void *pUserData,
-  int (*xToken)(void*, int, const char*, int, int, int)
-){
-  return fts5ApiTokenize_v2(pCtx, pText, nText, 0, 0, pUserData, xToken);
-}
-
-static int fts5ApiPhraseCount(Fts5Context *pCtx){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
-}
-
-static int fts5ApiPhraseSize(Fts5Context *pCtx, int iPhrase){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
-}
-
-/*
-** Argument pStmt is an SQL statement of the type used by Fts5Cursor. This
-** function extracts the text value of column iCol of the current row.
-** Additionally, if there is an associated locale, it invokes
-** sqlite3Fts5SetLocale() to configure the tokenizer. In all cases the caller
-** should invoke sqlite3Fts5ClearLocale() to clear the locale at some point
-** after this function returns.
-**
-** If successful, (*ppText) is set to point to a buffer containing the text
-** value as utf-8 and SQLITE_OK returned. (*pnText) is set to the size of that
-** buffer in bytes. It is not guaranteed to be nul-terminated. If an error
-** occurs, an SQLite error code is returned. The final values of the two
-** output parameters are undefined in this case.
-*/
-static int fts5TextFromStmt(
-  Fts5Config *pConfig,
-  sqlite3_stmt *pStmt,
-  int iCol,
-  const char **ppText,
-  int *pnText
-){
-  sqlite3_value *pVal = sqlite3_column_value(pStmt, iCol+1);
-  const char *pLoc = 0;
-  int nLoc = 0;
-  int rc = SQLITE_OK;
-
-  if( pConfig->bLocale
-   && pConfig->eContent==FTS5_CONTENT_EXTERNAL
-   && sqlite3Fts5IsLocaleValue(pConfig, pVal)
-  ){
-    rc = sqlite3Fts5DecodeLocaleValue(pVal, ppText, pnText, &pLoc, &nLoc);
-  }else{
-    *ppText = (const char*)sqlite3_value_text(pVal);
-    *pnText = sqlite3_value_bytes(pVal);
-    if( pConfig->bLocale && pConfig->eContent==FTS5_CONTENT_NORMAL ){
-      pLoc = (const char*)sqlite3_column_text(pStmt, iCol+1+pConfig->nCol);
-      nLoc = sqlite3_column_bytes(pStmt, iCol+1+pConfig->nCol);
-    }
-  }
-  sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
-  return rc;
-}
-
-static int fts5ApiColumnText(
-  Fts5Context *pCtx,
-  int iCol,
-  const char **pz,
-  int *pn
-){
-  int rc = SQLITE_OK;
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
-
-  assert( pCsr->ePlan!=FTS5_PLAN_SPECIAL );
-  if( iCol<0 || iCol>=pTab->pConfig->nCol ){
-    rc = SQLITE_RANGE;
-  }else if( fts5IsContentless((Fts5FullTable*)(pCsr->base.pVtab), 0) ){
-    *pz = 0;
-    *pn = 0;
-  }else{
-    rc = fts5SeekCursor(pCsr, 0);
-    if( rc==SQLITE_OK ){
-      rc = fts5TextFromStmt(pTab->pConfig, pCsr->pStmt, iCol, pz, pn);
-      sqlite3Fts5ClearLocale(pTab->pConfig);
-    }
-  }
-  return rc;
-}
-
-/*
-** This is called by various API functions - xInst, xPhraseFirst,
-** xPhraseFirstColumn etc. - to obtain the position list for phrase iPhrase
-** of the current row. This function works for both detail=full tables (in
-** which case the position-list was read from the fts index) or for other
-** detail= modes if the row content is available.
-*/
-static int fts5CsrPoslist(
-  Fts5Cursor *pCsr,               /* Fts5 cursor object */
-  int iPhrase,                    /* Phrase to find position list for */
-  const u8 **pa,                  /* OUT: Pointer to position list buffer */
-  int *pn                         /* OUT: Size of (*pa) in bytes */
-){
-  Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
-  int rc = SQLITE_OK;
-  int bLive = (pCsr->pSorter==0);
-
-  if( iPhrase<0 || iPhrase>=sqlite3Fts5ExprPhraseCount(pCsr->pExpr) ){
-    rc = SQLITE_RANGE;
-  }else if( pConfig->eDetail!=FTS5_DETAIL_FULL
-         && fts5IsContentless((Fts5FullTable*)pCsr->base.pVtab, 1)
-  ){
-    *pa = 0;
-    *pn = 0;
-    return SQLITE_OK;
-  }else if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_POSLIST) ){
-    if( pConfig->eDetail!=FTS5_DETAIL_FULL ){
-      Fts5PoslistPopulator *aPopulator;
-      int i;
-
-      aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
-      if( aPopulator==0 ) rc = SQLITE_NOMEM;
-      if( rc==SQLITE_OK ){
-        rc = fts5SeekCursor(pCsr, 0);
-      }
-      for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
-        const char *z = 0;
-        int n = 0;
-        rc = fts5TextFromStmt(pConfig, pCsr->pStmt, i, &z, &n);
-        if( rc==SQLITE_OK ){
-          rc = sqlite3Fts5ExprPopulatePoslists(
-              pConfig, pCsr->pExpr, aPopulator, i, z, n
-          );
-        }
-        sqlite3Fts5ClearLocale(pConfig);
-      }
-      sqlite3_free(aPopulator);
-
-      if( pCsr->pSorter ){
-        sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
-      }
-    }
-    CsrFlagClear(pCsr, FTS5CSR_REQUIRE_POSLIST);
-  }
-
-  if( rc==SQLITE_OK ){
-    if( pCsr->pSorter && pConfig->eDetail==FTS5_DETAIL_FULL ){
-      Fts5Sorter *pSorter = pCsr->pSorter;
-      int i1 = (iPhrase==0 ? 0 : pSorter->aIdx[iPhrase-1]);
-      *pn = pSorter->aIdx[iPhrase] - i1;
-      *pa = &pSorter->aPoslist[i1];
-    }else{
-      *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
-    }
-  }else{
-    *pa = 0;
-    *pn = 0;
-  }
-
-  return rc;
-}
-
-/*
-** Ensure that the Fts5Cursor.nInstCount and aInst[] variables are populated
-** correctly for the current view. Return SQLITE_OK if successful, or an
-** SQLite error code otherwise.
-*/
-static int fts5CacheInstArray(Fts5Cursor *pCsr){
-  int rc = SQLITE_OK;
-  Fts5PoslistReader *aIter;       /* One iterator for each phrase */
-  int nIter;                      /* Number of iterators/phrases */
-  int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
-
-  nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
-  if( pCsr->aInstIter==0 ){
-    sqlite3_int64 nByte = sizeof(Fts5PoslistReader) * nIter;
-    pCsr->aInstIter = (Fts5PoslistReader*)sqlite3Fts5MallocZero(&rc, nByte);
-  }
-  aIter = pCsr->aInstIter;
-
-  if( aIter ){
-    int nInst = 0;                /* Number instances seen so far */
-    int i;
-
-    /* Initialize all iterators */
-    for(i=0; i<nIter && rc==SQLITE_OK; i++){
-      const u8 *a;
-      int n;
-      rc = fts5CsrPoslist(pCsr, i, &a, &n);
-      if( rc==SQLITE_OK ){
-        sqlite3Fts5PoslistReaderInit(a, n, &aIter[i]);
-      }
-    }
-
-    if( rc==SQLITE_OK ){
-      while( 1 ){
-        int *aInst;
-        int iBest = -1;
-        for(i=0; i<nIter; i++){
-          if( (aIter[i].bEof==0)
-              && (iBest<0 || aIter[i].iPos<aIter[iBest].iPos)
-            ){
-            iBest = i;
-          }
-        }
-        if( iBest<0 ) break;
-
-        nInst++;
-        if( nInst>=pCsr->nInstAlloc ){
-          int nNewSize = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
-          aInst = (int*)sqlite3_realloc64(
-              pCsr->aInst, nNewSize*sizeof(int)*3
-              );
-          if( aInst ){
-            pCsr->aInst = aInst;
-            pCsr->nInstAlloc = nNewSize;
-          }else{
-            nInst--;
-            rc = SQLITE_NOMEM;
-            break;
-          }
-        }
-
-        aInst = &pCsr->aInst[3 * (nInst-1)];
-        aInst[0] = iBest;
-        aInst[1] = FTS5_POS2COLUMN(aIter[iBest].iPos);
-        aInst[2] = FTS5_POS2OFFSET(aIter[iBest].iPos);
-        assert( aInst[1]>=0 );
-        if( aInst[1]>=nCol ){
-          rc = FTS5_CORRUPT;
-          break;
-        }
-        sqlite3Fts5PoslistReaderNext(&aIter[iBest]);
-      }
-    }
-
-    pCsr->nInstCount = nInst;
-    CsrFlagClear(pCsr, FTS5CSR_REQUIRE_INST);
-  }
-  return rc;
-}
-
-static int fts5ApiInstCount(Fts5Context *pCtx, int *pnInst){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  int rc = SQLITE_OK;
-  if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
-   || SQLITE_OK==(rc = fts5CacheInstArray(pCsr)) ){
-    *pnInst = pCsr->nInstCount;
-  }
-  return rc;
-}
-
-static int fts5ApiInst(
-  Fts5Context *pCtx,
-  int iIdx,
-  int *piPhrase,
-  int *piCol,
-  int *piOff
-){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  int rc = SQLITE_OK;
-  if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
-   || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
-  ){
-    if( iIdx<0 || iIdx>=pCsr->nInstCount ){
-      rc = SQLITE_RANGE;
-    }else{
-      *piPhrase = pCsr->aInst[iIdx*3];
-      *piCol = pCsr->aInst[iIdx*3 + 1];
-      *piOff = pCsr->aInst[iIdx*3 + 2];
-    }
-  }
-  return rc;
-}
-
-static sqlite3_int64 fts5ApiRowid(Fts5Context *pCtx){
-  return fts5CursorRowid((Fts5Cursor*)pCtx);
-}
-
-static int fts5ColumnSizeCb(
-  void *pContext,                 /* Pointer to int */
-  int tflags,
-  const char *pUnused,            /* Buffer containing token */
-  int nUnused,                    /* Size of token in bytes */
-  int iUnused1,                   /* Start offset of token */
-  int iUnused2                    /* End offset of token */
-){
-  int *pCnt = (int*)pContext;
-  UNUSED_PARAM2(pUnused, nUnused);
-  UNUSED_PARAM2(iUnused1, iUnused2);
-  if( (tflags & FTS5_TOKEN_COLOCATED)==0 ){
-    (*pCnt)++;
-  }
-  return SQLITE_OK;
-}
-
-static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-  Fts5Config *pConfig = pTab->p.pConfig;
-  int rc = SQLITE_OK;
-
-  if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_DOCSIZE) ){
-    if( pConfig->bColumnsize ){
-      i64 iRowid = fts5CursorRowid(pCsr);
-      rc = sqlite3Fts5StorageDocsize(pTab->pStorage, iRowid, pCsr->aColumnSize);
-    }else if( !pConfig->zContent || pConfig->eContent==FTS5_CONTENT_UNINDEXED ){
-      int i;
-      for(i=0; i<pConfig->nCol; i++){
-        if( pConfig->abUnindexed[i]==0 ){
-          pCsr->aColumnSize[i] = -1;
-        }
-      }
-    }else{
-      int i;
-      rc = fts5SeekCursor(pCsr, 0);
-      for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
-        if( pConfig->abUnindexed[i]==0 ){
-          const char *z = 0;
-          int n = 0;
-          pCsr->aColumnSize[i] = 0;
-          rc = fts5TextFromStmt(pConfig, pCsr->pStmt, i, &z, &n);
-          if( rc==SQLITE_OK ){
-            rc = sqlite3Fts5Tokenize(pConfig, FTS5_TOKENIZE_AUX,
-                z, n, (void*)&pCsr->aColumnSize[i], fts5ColumnSizeCb
-            );
-          }
-          sqlite3Fts5ClearLocale(pConfig);
-        }
-      }
-    }
-    CsrFlagClear(pCsr, FTS5CSR_REQUIRE_DOCSIZE);
-  }
-  if( iCol<0 ){
-    int i;
-    *pnToken = 0;
-    for(i=0; i<pConfig->nCol; i++){
-      *pnToken += pCsr->aColumnSize[i];
-    }
-  }else if( iCol<pConfig->nCol ){
-    *pnToken = pCsr->aColumnSize[iCol];
-  }else{
-    *pnToken = 0;
-    rc = SQLITE_RANGE;
-  }
-  return rc;
-}
-
-/*
-** Implementation of the xSetAuxdata() method.
-*/
-static int fts5ApiSetAuxdata(
-  Fts5Context *pCtx,              /* Fts5 context */
-  void *pPtr,                     /* Pointer to save as auxdata */
-  void(*xDelete)(void*)           /* Destructor for pPtr (or NULL) */
-){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5Auxdata *pData;
-
-  /* Search through the cursors list of Fts5Auxdata objects for one that
-  ** corresponds to the currently executing auxiliary function.  */
-  for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
-    if( pData->pAux==pCsr->pAux ) break;
-  }
-
-  if( pData ){
-    if( pData->xDelete ){
-      pData->xDelete(pData->pPtr);
-    }
-  }else{
-    int rc = SQLITE_OK;
-    pData = (Fts5Auxdata*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5Auxdata));
-    if( pData==0 ){
-      if( xDelete ) xDelete(pPtr);
-      return rc;
-    }
-    pData->pAux = pCsr->pAux;
-    pData->pNext = pCsr->pAuxdata;
-    pCsr->pAuxdata = pData;
-  }
-
-  pData->xDelete = xDelete;
-  pData->pPtr = pPtr;
-  return SQLITE_OK;
-}
-
-static void *fts5ApiGetAuxdata(Fts5Context *pCtx, int bClear){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5Auxdata *pData;
-  void *pRet = 0;
-
-  for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
-    if( pData->pAux==pCsr->pAux ) break;
-  }
-
-  if( pData ){
-    pRet = pData->pPtr;
-    if( bClear ){
-      pData->pPtr = 0;
-      pData->xDelete = 0;
-    }
-  }
-
-  return pRet;
-}
-
-static void fts5ApiPhraseNext(
-  Fts5Context *pCtx,
-  Fts5PhraseIter *pIter,
-  int *piCol, int *piOff
-){
-  if( pIter->a>=pIter->b ){
-    *piCol = -1;
-    *piOff = -1;
-  }else{
-    int iVal;
-    pIter->a += fts5GetVarint32(pIter->a, iVal);
-    if( iVal==1 ){
-      /* Avoid returning a (*piCol) value that is too large for the table,
-      ** even if the position-list is corrupt. The caller might not be
-      ** expecting it.  */
-      int nCol = ((Fts5Table*)(((Fts5Cursor*)pCtx)->base.pVtab))->pConfig->nCol;
-      pIter->a += fts5GetVarint32(pIter->a, iVal);
-      *piCol = (iVal>=nCol ? nCol-1 : iVal);
-      *piOff = 0;
-      pIter->a += fts5GetVarint32(pIter->a, iVal);
-    }
-    *piOff += (iVal-2);
-  }
-}
-
-static int fts5ApiPhraseFirst(
-  Fts5Context *pCtx,
-  int iPhrase,
-  Fts5PhraseIter *pIter,
-  int *piCol, int *piOff
-){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  int n;
-  int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
-  if( rc==SQLITE_OK ){
-    assert( pIter->a || n==0 );
-    pIter->b = (pIter->a ? &pIter->a[n] : 0);
-    *piCol = 0;
-    *piOff = 0;
-    fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
-  }
-  return rc;
-}
-
-static void fts5ApiPhraseNextColumn(
-  Fts5Context *pCtx,
-  Fts5PhraseIter *pIter,
-  int *piCol
-){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
-
-  if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
-    if( pIter->a>=pIter->b ){
-      *piCol = -1;
-    }else{
-      int iIncr;
-      pIter->a += fts5GetVarint32(&pIter->a[0], iIncr);
-      *piCol += (iIncr-2);
-    }
-  }else{
-    while( 1 ){
-      int dummy;
-      if( pIter->a>=pIter->b ){
-        *piCol = -1;
-        return;
-      }
-      if( pIter->a[0]==0x01 ) break;
-      pIter->a += fts5GetVarint32(pIter->a, dummy);
-    }
-    pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
-  }
-}
-
-static int fts5ApiPhraseFirstColumn(
-  Fts5Context *pCtx,
-  int iPhrase,
-  Fts5PhraseIter *pIter,
-  int *piCol
-){
-  int rc = SQLITE_OK;
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
-
-  if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
-    Fts5Sorter *pSorter = pCsr->pSorter;
-    int n;
-    if( pSorter ){
-      int i1 = (iPhrase==0 ? 0 : pSorter->aIdx[iPhrase-1]);
-      n = pSorter->aIdx[iPhrase] - i1;
-      pIter->a = &pSorter->aPoslist[i1];
-    }else{
-      rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
-    }
-    if( rc==SQLITE_OK ){
-      assert( pIter->a || n==0 );
-      pIter->b = (pIter->a ? &pIter->a[n] : 0);
-      *piCol = 0;
-      fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
-    }
-  }else{
-    int n;
-    rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
-    if( rc==SQLITE_OK ){
-      assert( pIter->a || n==0 );
-      pIter->b = (pIter->a ? &pIter->a[n] : 0);
-      if( n<=0 ){
-        *piCol = -1;
-      }else if( pIter->a[0]==0x01 ){
-        pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
-      }else{
-        *piCol = 0;
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** xQueryToken() API implemenetation.
-*/
-static int fts5ApiQueryToken(
-  Fts5Context* pCtx,
-  int iPhrase,
-  int iToken,
-  const char **ppOut,
-  int *pnOut
-){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  return sqlite3Fts5ExprQueryToken(pCsr->pExpr, iPhrase, iToken, ppOut, pnOut);
-}
-
-/*
-** xInstToken() API implemenetation.
-*/
-static int fts5ApiInstToken(
-  Fts5Context *pCtx,
-  int iIdx,
-  int iToken,
-  const char **ppOut, int *pnOut
-){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  int rc = SQLITE_OK;
-  if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
-   || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
-  ){
-    if( iIdx<0 || iIdx>=pCsr->nInstCount ){
-      rc = SQLITE_RANGE;
-    }else{
-      int iPhrase = pCsr->aInst[iIdx*3];
-      int iCol = pCsr->aInst[iIdx*3 + 1];
-      int iOff = pCsr->aInst[iIdx*3 + 2];
-      i64 iRowid = fts5CursorRowid(pCsr);
-      rc = sqlite3Fts5ExprInstToken(
-          pCsr->pExpr, iRowid, iPhrase, iCol, iOff, iToken, ppOut, pnOut
-      );
-    }
-  }
-  return rc;
-}
-
-
-static int fts5ApiQueryPhrase(Fts5Context*, int, void*,
-    int(*)(const Fts5ExtensionApi*, Fts5Context*, void*)
-);
-
-/*
-** The xColumnLocale() API.
-*/
-static int fts5ApiColumnLocale(
-  Fts5Context *pCtx,
-  int iCol,
-  const char **pzLocale,
-  int *pnLocale
-){
-  int rc = SQLITE_OK;
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
-
-  *pzLocale = 0;
-  *pnLocale = 0;
-
-  assert( pCsr->ePlan!=FTS5_PLAN_SPECIAL );
-  if( iCol<0 || iCol>=pConfig->nCol ){
-    rc = SQLITE_RANGE;
-  }else if(
-      pConfig->abUnindexed[iCol]==0
-   && 0==fts5IsContentless((Fts5FullTable*)pCsr->base.pVtab, 1)
-   && pConfig->bLocale
-  ){
-    rc = fts5SeekCursor(pCsr, 0);
-    if( rc==SQLITE_OK ){
-      const char *zDummy = 0;
-      int nDummy = 0;
-      rc = fts5TextFromStmt(pConfig, pCsr->pStmt, iCol, &zDummy, &nDummy);
-      if( rc==SQLITE_OK ){
-        *pzLocale = pConfig->t.pLocale;
-        *pnLocale = pConfig->t.nLocale;
-      }
-      sqlite3Fts5ClearLocale(pConfig);
-    }
-  }
-
-  return rc;
-}
-
-static const Fts5ExtensionApi sFts5Api = {
-  4,                            /* iVersion */
-  fts5ApiUserData,
-  fts5ApiColumnCount,
-  fts5ApiRowCount,
-  fts5ApiColumnTotalSize,
-  fts5ApiTokenize,
-  fts5ApiPhraseCount,
-  fts5ApiPhraseSize,
-  fts5ApiInstCount,
-  fts5ApiInst,
-  fts5ApiRowid,
-  fts5ApiColumnText,
-  fts5ApiColumnSize,
-  fts5ApiQueryPhrase,
-  fts5ApiSetAuxdata,
-  fts5ApiGetAuxdata,
-  fts5ApiPhraseFirst,
-  fts5ApiPhraseNext,
-  fts5ApiPhraseFirstColumn,
-  fts5ApiPhraseNextColumn,
-  fts5ApiQueryToken,
-  fts5ApiInstToken,
-  fts5ApiColumnLocale,
-  fts5ApiTokenize_v2
-};
-
-/*
-** Implementation of API function xQueryPhrase().
-*/
-static int fts5ApiQueryPhrase(
-  Fts5Context *pCtx,
-  int iPhrase,
-  void *pUserData,
-  int(*xCallback)(const Fts5ExtensionApi*, Fts5Context*, void*)
-){
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-  int rc;
-  Fts5Cursor *pNew = 0;
-
-  rc = fts5OpenMethod(pCsr->base.pVtab, (sqlite3_vtab_cursor**)&pNew);
-  if( rc==SQLITE_OK ){
-    pNew->ePlan = FTS5_PLAN_MATCH;
-    pNew->iFirstRowid = SMALLEST_INT64;
-    pNew->iLastRowid = LARGEST_INT64;
-    pNew->base.pVtab = (sqlite3_vtab*)pTab;
-    rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
-  }
-
-  if( rc==SQLITE_OK ){
-    for(rc = fts5CursorFirst(pTab, pNew, 0);
-        rc==SQLITE_OK && CsrFlagTest(pNew, FTS5CSR_EOF)==0;
-        rc = fts5NextMethod((sqlite3_vtab_cursor*)pNew)
-    ){
-      rc = xCallback(&sFts5Api, (Fts5Context*)pNew, pUserData);
-      if( rc!=SQLITE_OK ){
-        if( rc==SQLITE_DONE ) rc = SQLITE_OK;
-        break;
-      }
-    }
-  }
-
-  fts5CloseMethod((sqlite3_vtab_cursor*)pNew);
-  return rc;
-}
-
-static void fts5ApiInvoke(
-  Fts5Auxiliary *pAux,
-  Fts5Cursor *pCsr,
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  assert( pCsr->pAux==0 );
-  assert( pCsr->ePlan!=FTS5_PLAN_SPECIAL );
-  pCsr->pAux = pAux;
-  pAux->xFunc(&sFts5Api, (Fts5Context*)pCsr, context, argc, argv);
-  pCsr->pAux = 0;
-}
-
-static Fts5Cursor *fts5CursorFromCsrid(Fts5Global *pGlobal, i64 iCsrId){
-  Fts5Cursor *pCsr;
-  for(pCsr=pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
-    if( pCsr->iCsrId==iCsrId ) break;
-  }
-  return pCsr;
-}
-
-/*
-** Parameter zFmt is a printf() style formatting string. This function
-** formats it using the trailing arguments and returns the result as
-** an error message to the context passed as the first argument.
-*/
-static void fts5ResultError(sqlite3_context *pCtx, const char *zFmt, ...){
-  char *zErr = 0;
-  va_list ap;
-  va_start(ap, zFmt);
-  zErr = sqlite3_vmprintf(zFmt, ap);
-  sqlite3_result_error(pCtx, zErr, -1);
-  sqlite3_free(zErr);
-  va_end(ap);
-}
-
-static void fts5ApiCallback(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-
-  Fts5Auxiliary *pAux;
-  Fts5Cursor *pCsr;
-  i64 iCsrId;
-
-  assert( argc>=1 );
-  pAux = (Fts5Auxiliary*)sqlite3_user_data(context);
-  iCsrId = sqlite3_value_int64(argv[0]);
-
-  pCsr = fts5CursorFromCsrid(pAux->pGlobal, iCsrId);
-  if( pCsr==0 || (pCsr->ePlan==0 || pCsr->ePlan==FTS5_PLAN_SPECIAL) ){
-    fts5ResultError(context, "no such cursor: %lld", iCsrId);
-  }else{
-    sqlite3_vtab *pTab = pCsr->base.pVtab;
-    fts5ApiInvoke(pAux, pCsr, context, argc-1, &argv[1]);
-    sqlite3_free(pTab->zErrMsg);
-    pTab->zErrMsg = 0;
-  }
-}
-
-
-/*
-** Given cursor id iId, return a pointer to the corresponding Fts5Table
-** object. Or NULL If the cursor id does not exist.
-*/
-static Fts5Table *sqlite3Fts5TableFromCsrid(
-  Fts5Global *pGlobal,            /* FTS5 global context for db handle */
-  i64 iCsrId                      /* Id of cursor to find */
-){
-  Fts5Cursor *pCsr;
-  pCsr = fts5CursorFromCsrid(pGlobal, iCsrId);
-  if( pCsr ){
-    return (Fts5Table*)pCsr->base.pVtab;
-  }
-  return 0;
-}
-
-/*
-** Return a "position-list blob" corresponding to the current position of
-** cursor pCsr via sqlite3_result_blob(). A position-list blob contains
-** the current position-list for each phrase in the query associated with
-** cursor pCsr.
-**
-** A position-list blob begins with (nPhrase-1) varints, where nPhrase is
-** the number of phrases in the query. Following the varints are the
-** concatenated position lists for each phrase, in order.
-**
-** The first varint (if it exists) contains the size of the position list
-** for phrase 0. The second (same disclaimer) contains the size of position
-** list 1. And so on. There is no size field for the final position list,
-** as it can be derived from the total size of the blob.
-*/
-static int fts5PoslistBlob(sqlite3_context *pCtx, Fts5Cursor *pCsr){
-  int i;
-  int rc = SQLITE_OK;
-  int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
-  Fts5Buffer val;
-
-  memset(&val, 0, sizeof(Fts5Buffer));
-  switch( ((Fts5Table*)(pCsr->base.pVtab))->pConfig->eDetail ){
-    case FTS5_DETAIL_FULL:
-
-      /* Append the varints */
-      for(i=0; i<(nPhrase-1); i++){
-        const u8 *dummy;
-        int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
-        sqlite3Fts5BufferAppendVarint(&rc, &val, nByte);
-      }
-
-      /* Append the position lists */
-      for(i=0; i<nPhrase; i++){
-        const u8 *pPoslist;
-        int nPoslist;
-        nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
-        sqlite3Fts5BufferAppendBlob(&rc, &val, nPoslist, pPoslist);
-      }
-      break;
-
-    case FTS5_DETAIL_COLUMNS:
-
-      /* Append the varints */
-      for(i=0; rc==SQLITE_OK && i<(nPhrase-1); i++){
-        const u8 *dummy;
-        int nByte;
-        rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
-        sqlite3Fts5BufferAppendVarint(&rc, &val, nByte);
-      }
-
-      /* Append the position lists */
-      for(i=0; rc==SQLITE_OK && i<nPhrase; i++){
-        const u8 *pPoslist;
-        int nPoslist;
-        rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);
-        sqlite3Fts5BufferAppendBlob(&rc, &val, nPoslist, pPoslist);
-      }
-      break;
-
-    default:
-      break;
-  }
-
-  sqlite3_result_blob(pCtx, val.p, val.n, sqlite3_free);
-  return rc;
-}
-
-/*
-** This is the xColumn method, called by SQLite to request a value from
-** the row that the supplied cursor currently points to.
-*/
-static int fts5ColumnMethod(
-  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 */
-){
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
-  Fts5Config *pConfig = pTab->p.pConfig;
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
-  int rc = SQLITE_OK;
-
-  assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
-
-  if( pCsr->ePlan==FTS5_PLAN_SPECIAL ){
-    if( iCol==pConfig->nCol ){
-      sqlite3_result_int64(pCtx, pCsr->iSpecial);
-    }
-  }else
-
-  if( iCol==pConfig->nCol ){
-    /* User is requesting the value of the special column with the same name
-    ** as the table. Return the cursor integer id number. This value is only
-    ** useful in that it may be passed as the first argument to an FTS5
-    ** auxiliary function.  */
-    sqlite3_result_int64(pCtx, pCsr->iCsrId);
-  }else if( iCol==pConfig->nCol+1 ){
-    /* The value of the "rank" column. */
-
-    if( pCsr->ePlan==FTS5_PLAN_SOURCE ){
-      fts5PoslistBlob(pCtx, pCsr);
-    }else if(
-        pCsr->ePlan==FTS5_PLAN_MATCH
-     || pCsr->ePlan==FTS5_PLAN_SORTED_MATCH
-    ){
-      if( pCsr->pRank || SQLITE_OK==(rc = fts5FindRankFunction(pCsr)) ){
-        fts5ApiInvoke(pCsr->pRank, pCsr, pCtx, pCsr->nRankArg, pCsr->apRankArg);
-      }
-    }
-  }else{
-    if( !sqlite3_vtab_nochange(pCtx) && pConfig->eContent!=FTS5_CONTENT_NONE ){
-      pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
-      rc = fts5SeekCursor(pCsr, 1);
-      if( rc==SQLITE_OK ){
-        sqlite3_value *pVal = sqlite3_column_value(pCsr->pStmt, iCol+1);
-        if( pConfig->bLocale
-         && pConfig->eContent==FTS5_CONTENT_EXTERNAL
-         && sqlite3Fts5IsLocaleValue(pConfig, pVal)
-        ){
-          const char *z = 0;
-          int n = 0;
-          rc = fts5TextFromStmt(pConfig, pCsr->pStmt, iCol, &z, &n);
-          if( rc==SQLITE_OK ){
-            sqlite3_result_text(pCtx, z, n, SQLITE_TRANSIENT);
-          }
-          sqlite3Fts5ClearLocale(pConfig);
-        }else{
-          sqlite3_result_value(pCtx, pVal);
-        }
-      }
-
-      pConfig->pzErrmsg = 0;
-    }
-  }
-
-  return rc;
-}
-
-
-/*
-** This routine implements the xFindFunction method for the FTS3
-** virtual table.
-*/
-static int fts5FindFunctionMethod(
-  sqlite3_vtab *pVtab,            /* Virtual table handle */
-  int nUnused,                    /* Number of SQL function arguments */
-  const char *zName,              /* Name of SQL function */
-  void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
-  void **ppArg                    /* OUT: User data for *pxFunc */
-){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  Fts5Auxiliary *pAux;
-
-  UNUSED_PARAM(nUnused);
-  pAux = fts5FindAuxiliary(pTab, zName);
-  if( pAux ){
-    *pxFunc = fts5ApiCallback;
-    *ppArg = (void*)pAux;
-    return 1;
-  }
-
-  /* No function of the specified name was found. Return 0. */
-  return 0;
-}
-
-/*
-** Implementation of FTS5 xRename method. Rename an fts5 table.
-*/
-static int fts5RenameMethod(
-  sqlite3_vtab *pVtab,            /* Virtual table handle */
-  const char *zName               /* New name of table */
-){
-  int rc;
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  rc = sqlite3Fts5StorageRename(pTab->pStorage, zName);
-  return rc;
-}
-
-static int sqlite3Fts5FlushToDisk(Fts5Table *pTab){
-  fts5TripCursors((Fts5FullTable*)pTab);
-  return sqlite3Fts5StorageSync(((Fts5FullTable*)pTab)->pStorage);
-}
-
-/*
-** The xSavepoint() method.
-**
-** Flush the contents of the pending-terms table to disk.
-*/
-static int fts5SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  int rc = SQLITE_OK;
-
-  fts5CheckTransactionState(pTab, FTS5_SAVEPOINT, iSavepoint);
-  rc = sqlite3Fts5FlushToDisk((Fts5Table*)pVtab);
-  if( rc==SQLITE_OK ){
-    pTab->iSavepoint = iSavepoint+1;
-  }
-  return rc;
-}
-
-/*
-** The xRelease() method.
-**
-** This is a no-op.
-*/
-static int fts5ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  int rc = SQLITE_OK;
-  fts5CheckTransactionState(pTab, FTS5_RELEASE, iSavepoint);
-  if( (iSavepoint+1)<pTab->iSavepoint ){
-    rc = sqlite3Fts5FlushToDisk(&pTab->p);
-    if( rc==SQLITE_OK ){
-      pTab->iSavepoint = iSavepoint;
-    }
-  }
-  return rc;
-}
-
-/*
-** The xRollbackTo() method.
-**
-** Discard the contents of the pending terms table.
-*/
-static int fts5RollbackToMethod(sqlite3_vtab *pVtab, int iSavepoint){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  int rc = SQLITE_OK;
-  fts5CheckTransactionState(pTab, FTS5_ROLLBACKTO, iSavepoint);
-  fts5TripCursors(pTab);
-  if( (iSavepoint+1)<=pTab->iSavepoint ){
-    pTab->p.pConfig->pgsz = 0;
-    rc = sqlite3Fts5StorageRollback(pTab->pStorage);
-  }
-  return rc;
-}
-
-/*
-** Register a new auxiliary function with global context pGlobal.
-*/
-static int fts5CreateAux(
-  fts5_api *pApi,                 /* Global context (one per db handle) */
-  const char *zName,              /* Name of new function */
-  void *pUserData,                /* User data for aux. function */
-  fts5_extension_function xFunc,  /* Aux. function implementation */
-  void(*xDestroy)(void*)          /* Destructor for pUserData */
-){
-  Fts5Global *pGlobal = (Fts5Global*)pApi;
-  int rc = sqlite3_overload_function(pGlobal->db, zName, -1);
-  if( rc==SQLITE_OK ){
-    Fts5Auxiliary *pAux;
-    sqlite3_int64 nName;            /* Size of zName in bytes, including \0 */
-    sqlite3_int64 nByte;            /* Bytes of space to allocate */
-
-    nName = strlen(zName) + 1;
-    nByte = sizeof(Fts5Auxiliary) + nName;
-    pAux = (Fts5Auxiliary*)sqlite3_malloc64(nByte);
-    if( pAux ){
-      memset(pAux, 0, (size_t)nByte);
-      pAux->zFunc = (char*)&pAux[1];
-      memcpy(pAux->zFunc, zName, nName);
-      pAux->pGlobal = pGlobal;
-      pAux->pUserData = pUserData;
-      pAux->xFunc = xFunc;
-      pAux->xDestroy = xDestroy;
-      pAux->pNext = pGlobal->pAux;
-      pGlobal->pAux = pAux;
-    }else{
-      rc = SQLITE_NOMEM;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** This function is used by xCreateTokenizer_v2() and xCreateTokenizer().
-** It allocates and partially populates a new Fts5TokenizerModule object.
-** The new object is already linked into the Fts5Global context before
-** returning.
-**
-** If successful, SQLITE_OK is returned and a pointer to the new
-** Fts5TokenizerModule object returned via output parameter (*ppNew). All
-** that is required is for the caller to fill in the methods in
-** Fts5TokenizerModule.x1 and x2, and to set Fts5TokenizerModule.bV2Native
-** as appropriate.
-**
-** If an error occurs, an SQLite error code is returned and the final value
-** of (*ppNew) undefined.
-*/
-static int fts5NewTokenizerModule(
-  Fts5Global *pGlobal,            /* Global context (one per db handle) */
-  const char *zName,              /* Name of new function */
-  void *pUserData,                /* User data for aux. function */
-  void(*xDestroy)(void*),         /* Destructor for pUserData */
-  Fts5TokenizerModule **ppNew
-){
-  int rc = SQLITE_OK;
-  Fts5TokenizerModule *pNew;
-  sqlite3_int64 nName;          /* Size of zName and its \0 terminator */
-  sqlite3_int64 nByte;          /* Bytes of space to allocate */
-
-  nName = strlen(zName) + 1;
-  nByte = sizeof(Fts5TokenizerModule) + nName;
-  *ppNew = pNew = (Fts5TokenizerModule*)sqlite3Fts5MallocZero(&rc, nByte);
-  if( pNew ){
-    pNew->zName = (char*)&pNew[1];
-    memcpy(pNew->zName, zName, nName);
-    pNew->pUserData = pUserData;
-    pNew->xDestroy = xDestroy;
-    pNew->pNext = pGlobal->pTok;
-    pGlobal->pTok = pNew;
-    if( pNew->pNext==0 ){
-      pGlobal->pDfltTok = pNew;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** An instance of this type is used as the Fts5Tokenizer object for
-** wrapper tokenizers - those that provide access to a v1 tokenizer via
-** the fts5_tokenizer_v2 API, and those that provide access to a v2 tokenizer
-** via the fts5_tokenizer API.
-*/
-typedef struct Fts5VtoVTokenizer Fts5VtoVTokenizer;
-struct Fts5VtoVTokenizer {
-  int bV2Native;                  /* True if v2 native tokenizer */
-  fts5_tokenizer x1;              /* Tokenizer functions */
-  fts5_tokenizer_v2 x2;           /* V2 tokenizer functions */
-  Fts5Tokenizer *pReal;
-};
-
-/*
-** Create a wrapper tokenizer. The context argument pCtx points to the
-** Fts5TokenizerModule object.
-*/
-static int fts5VtoVCreate(
-  void *pCtx,
-  const char **azArg,
-  int nArg,
-  Fts5Tokenizer **ppOut
-){
-  Fts5TokenizerModule *pMod = (Fts5TokenizerModule*)pCtx;
-  Fts5VtoVTokenizer *pNew = 0;
-  int rc = SQLITE_OK;
-
-  pNew = (Fts5VtoVTokenizer*)sqlite3Fts5MallocZero(&rc, sizeof(*pNew));
-  if( rc==SQLITE_OK ){
-    pNew->x1 = pMod->x1;
-    pNew->x2 = pMod->x2;
-    pNew->bV2Native = pMod->bV2Native;
-    if( pMod->bV2Native ){
-      rc = pMod->x2.xCreate(pMod->pUserData, azArg, nArg, &pNew->pReal);
-    }else{
-      rc = pMod->x1.xCreate(pMod->pUserData, azArg, nArg, &pNew->pReal);
-    }
-    if( rc!=SQLITE_OK ){
-      sqlite3_free(pNew);
-      pNew = 0;
-    }
-  }
-
-  *ppOut = (Fts5Tokenizer*)pNew;
-  return rc;
-}
-
-/*
-** Delete an Fts5VtoVTokenizer wrapper tokenizer.
-*/
-static void fts5VtoVDelete(Fts5Tokenizer *pTok){
-  Fts5VtoVTokenizer *p = (Fts5VtoVTokenizer*)pTok;
-  if( p ){
-    if( p->bV2Native ){
-      p->x2.xDelete(p->pReal);
-    }else{
-      p->x1.xDelete(p->pReal);
-    }
-    sqlite3_free(p);
-  }
-}
-
-
-/*
-** xTokenizer method for a wrapper tokenizer that offers the v1 interface
-** (no support for locales).
-*/
-static int fts5V1toV2Tokenize(
-  Fts5Tokenizer *pTok,
-  void *pCtx, int flags,
-  const char *pText, int nText,
-  int (*xToken)(void*, int, const char*, int, int, int)
-){
-  Fts5VtoVTokenizer *p = (Fts5VtoVTokenizer*)pTok;
-  assert( p->bV2Native );
-  return p->x2.xTokenize(p->pReal, pCtx, flags, pText, nText, 0, 0, xToken);
-}
-
-/*
-** xTokenizer method for a wrapper tokenizer that offers the v2 interface
-** (with locale support).
-*/
-static int fts5V2toV1Tokenize(
-  Fts5Tokenizer *pTok,
-  void *pCtx, int flags,
-  const char *pText, int nText,
-  const char *pLocale, int nLocale,
-  int (*xToken)(void*, int, const char*, int, int, int)
-){
-  Fts5VtoVTokenizer *p = (Fts5VtoVTokenizer*)pTok;
-  assert( p->bV2Native==0 );
-  UNUSED_PARAM2(pLocale,nLocale);
-  return p->x1.xTokenize(p->pReal, pCtx, flags, pText, nText, xToken);
-}
-
-/*
-** Register a new tokenizer. This is the implementation of the
-** fts5_api.xCreateTokenizer_v2() method.
-*/
-static int fts5CreateTokenizer_v2(
-  fts5_api *pApi,                 /* Global context (one per db handle) */
-  const char *zName,              /* Name of new function */
-  void *pUserData,                /* User data for aux. function */
-  fts5_tokenizer_v2 *pTokenizer,  /* Tokenizer implementation */
-  void(*xDestroy)(void*)          /* Destructor for pUserData */
-){
-  Fts5Global *pGlobal = (Fts5Global*)pApi;
-  int rc = SQLITE_OK;
-
-  if( pTokenizer->iVersion>2 ){
-    rc = SQLITE_ERROR;
-  }else{
-    Fts5TokenizerModule *pNew = 0;
-    rc = fts5NewTokenizerModule(pGlobal, zName, pUserData, xDestroy, &pNew);
-    if( pNew ){
-      pNew->x2 = *pTokenizer;
-      pNew->bV2Native = 1;
-      pNew->x1.xCreate = fts5VtoVCreate;
-      pNew->x1.xTokenize = fts5V1toV2Tokenize;
-      pNew->x1.xDelete = fts5VtoVDelete;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** The fts5_api.xCreateTokenizer() method.
-*/
-static int fts5CreateTokenizer(
-  fts5_api *pApi,                 /* Global context (one per db handle) */
-  const char *zName,              /* Name of new function */
-  void *pUserData,                /* User data for aux. function */
-  fts5_tokenizer *pTokenizer,     /* Tokenizer implementation */
-  void(*xDestroy)(void*)          /* Destructor for pUserData */
-){
-  Fts5TokenizerModule *pNew = 0;
-  int rc = SQLITE_OK;
-
-  rc = fts5NewTokenizerModule(
-      (Fts5Global*)pApi, zName, pUserData, xDestroy, &pNew
-  );
-  if( pNew ){
-    pNew->x1 = *pTokenizer;
-    pNew->x2.xCreate = fts5VtoVCreate;
-    pNew->x2.xTokenize = fts5V2toV1Tokenize;
-    pNew->x2.xDelete = fts5VtoVDelete;
-  }
-  return rc;
-}
-
-/*
-** Search the global context passed as the first argument for a tokenizer
-** module named zName. If found, return a pointer to the Fts5TokenizerModule
-** object. Otherwise, return NULL.
-*/
-static Fts5TokenizerModule *fts5LocateTokenizer(
-  Fts5Global *pGlobal,            /* Global (one per db handle) object */
-  const char *zName               /* Name of tokenizer module to find */
-){
-  Fts5TokenizerModule *pMod = 0;
-
-  if( zName==0 ){
-    pMod = pGlobal->pDfltTok;
-  }else{
-    for(pMod=pGlobal->pTok; pMod; pMod=pMod->pNext){
-      if( sqlite3_stricmp(zName, pMod->zName)==0 ) break;
-    }
-  }
-
-  return pMod;
-}
-
-/*
-** Find a tokenizer. This is the implementation of the
-** fts5_api.xFindTokenizer_v2() method.
-*/
-static int fts5FindTokenizer_v2(
-  fts5_api *pApi,                 /* Global context (one per db handle) */
-  const char *zName,              /* Name of tokenizer */
-  void **ppUserData,
-  fts5_tokenizer_v2 **ppTokenizer /* Populate this object */
-){
-  int rc = SQLITE_OK;
-  Fts5TokenizerModule *pMod;
-
-  pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
-  if( pMod ){
-    if( pMod->bV2Native ){
-      *ppUserData = pMod->pUserData;
-    }else{
-      *ppUserData = (void*)pMod;
-    }
-    *ppTokenizer = &pMod->x2;
-  }else{
-    *ppTokenizer = 0;
-    *ppUserData = 0;
-    rc = SQLITE_ERROR;
-  }
-
-  return rc;
-}
-
-/*
-** Find a tokenizer. This is the implementation of the
-** fts5_api.xFindTokenizer() method.
-*/
-static int fts5FindTokenizer(
-  fts5_api *pApi,                 /* Global context (one per db handle) */
-  const char *zName,              /* Name of new function */
-  void **ppUserData,
-  fts5_tokenizer *pTokenizer      /* Populate this object */
-){
-  int rc = SQLITE_OK;
-  Fts5TokenizerModule *pMod;
-
-  pMod = fts5LocateTokenizer((Fts5Global*)pApi, zName);
-  if( pMod ){
-    if( pMod->bV2Native==0 ){
-      *ppUserData = pMod->pUserData;
-    }else{
-      *ppUserData = (void*)pMod;
-    }
-    *pTokenizer = pMod->x1;
-  }else{
-    memset(pTokenizer, 0, sizeof(*pTokenizer));
-    *ppUserData = 0;
-    rc = SQLITE_ERROR;
-  }
-
-  return rc;
-}
-
-/*
-** Attempt to instantiate the tokenizer.
-*/
-static int sqlite3Fts5LoadTokenizer(Fts5Config *pConfig){
-  const char **azArg = pConfig->t.azArg;
-  const int nArg = pConfig->t.nArg;
-  Fts5TokenizerModule *pMod = 0;
-  int rc = SQLITE_OK;
-
-  pMod = fts5LocateTokenizer(pConfig->pGlobal, nArg==0 ? 0 : azArg[0]);
-  if( pMod==0 ){
-    assert( nArg>0 );
-    rc = SQLITE_ERROR;
-    sqlite3Fts5ConfigErrmsg(pConfig, "no such tokenizer: %s", azArg[0]);
-  }else{
-    int (*xCreate)(void*, const char**, int, Fts5Tokenizer**) = 0;
-    if( pMod->bV2Native ){
-      xCreate = pMod->x2.xCreate;
-      pConfig->t.pApi2 = &pMod->x2;
-    }else{
-      pConfig->t.pApi1 = &pMod->x1;
-      xCreate = pMod->x1.xCreate;
-    }
-
-    rc = xCreate(pMod->pUserData,
-        (azArg?&azArg[1]:0), (nArg?nArg-1:0), &pConfig->t.pTok
-    );
-
-    if( rc!=SQLITE_OK ){
-      if( rc!=SQLITE_NOMEM ){
-        sqlite3Fts5ConfigErrmsg(pConfig, "error in tokenizer constructor");
-      }
-    }else if( pMod->bV2Native==0 ){
-      pConfig->t.ePattern = sqlite3Fts5TokenizerPattern(
-          pMod->x1.xCreate, pConfig->t.pTok
-      );
-    }
-  }
-
-  if( rc!=SQLITE_OK ){
-    pConfig->t.pApi1 = 0;
-    pConfig->t.pApi2 = 0;
-    pConfig->t.pTok = 0;
-  }
-
-  return rc;
-}
-
-
-/*
-** xDestroy callback passed to sqlite3_create_module(). This is invoked
-** when the db handle is being closed. Free memory associated with
-** tokenizers and aux functions registered with this db handle.
-*/
-static void fts5ModuleDestroy(void *pCtx){
-  Fts5TokenizerModule *pTok, *pNextTok;
-  Fts5Auxiliary *pAux, *pNextAux;
-  Fts5Global *pGlobal = (Fts5Global*)pCtx;
-
-  for(pAux=pGlobal->pAux; pAux; pAux=pNextAux){
-    pNextAux = pAux->pNext;
-    if( pAux->xDestroy ) pAux->xDestroy(pAux->pUserData);
-    sqlite3_free(pAux);
-  }
-
-  for(pTok=pGlobal->pTok; pTok; pTok=pNextTok){
-    pNextTok = pTok->pNext;
-    if( pTok->xDestroy ) pTok->xDestroy(pTok->pUserData);
-    sqlite3_free(pTok);
-  }
-
-  sqlite3_free(pGlobal);
-}
-
-/*
-** Implementation of the fts5() function used by clients to obtain the
-** API pointer.
-*/
-static void fts5Fts5Func(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args */
-  sqlite3_value **apArg           /* Function arguments */
-){
-  Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
-  fts5_api **ppApi;
-  UNUSED_PARAM(nArg);
-  assert( nArg==1 );
-  ppApi = (fts5_api**)sqlite3_value_pointer(apArg[0], "fts5_api_ptr");
-  if( ppApi ) *ppApi = &pGlobal->api;
-}
-
-/*
-** Implementation of fts5_source_id() function.
-*/
-static void fts5SourceIdFunc(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args */
-  sqlite3_value **apUnused        /* Function arguments */
-){
-  assert( nArg==0 );
-  UNUSED_PARAM2(nArg, apUnused);
-  sqlite3_result_text(pCtx, "fts5: 2026-05-05 10:34:17 c88b22011a54b4f6fbd149e9f8e4de77658ce58143a1af0e3785e4e6475127e9", -1, SQLITE_TRANSIENT);
-}
-
-/*
-** Implementation of fts5_locale(LOCALE, TEXT) function.
-**
-** If parameter LOCALE is NULL, or a zero-length string, then a copy of
-** TEXT is returned. Otherwise, both LOCALE and TEXT are interpreted as
-** text, and the value returned is a blob consisting of:
-**
-**     * The 4 bytes 0x00, 0xE0, 0xB2, 0xEb (FTS5_LOCALE_HEADER).
-**     * The LOCALE, as utf-8 text, followed by
-**     * 0x00, followed by
-**     * The TEXT, as utf-8 text.
-**
-** There is no final nul-terminator following the TEXT value.
-*/
-static void fts5LocaleFunc(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args */
-  sqlite3_value **apArg           /* Function arguments */
-){
-  const char *zLocale = 0;
-  i64 nLocale = 0;
-  const char *zText = 0;
-  i64 nText = 0;
-
-  assert( nArg==2 );
-  UNUSED_PARAM(nArg);
-
-  zLocale = (const char*)sqlite3_value_text(apArg[0]);
-  nLocale = sqlite3_value_bytes(apArg[0]);
-
-  zText = (const char*)sqlite3_value_text(apArg[1]);
-  nText = sqlite3_value_bytes(apArg[1]);
-
-  if( zLocale==0 || zLocale[0]=='\0' ){
-    sqlite3_result_text(pCtx, zText, nText, SQLITE_TRANSIENT);
-  }else{
-    Fts5Global *p = (Fts5Global*)sqlite3_user_data(pCtx);
-    u8 *pBlob = 0;
-    u8 *pCsr = 0;
-    i64 nBlob = 0;
-
-    nBlob = FTS5_LOCALE_HDR_SIZE + nLocale + 1 + nText;
-    pBlob = (u8*)sqlite3_malloc64(nBlob);
-    if( pBlob==0 ){
-      sqlite3_result_error_nomem(pCtx);
-      return;
-    }
-
-    pCsr = pBlob;
-    memcpy(pCsr, (const u8*)p->aLocaleHdr, FTS5_LOCALE_HDR_SIZE);
-    pCsr += FTS5_LOCALE_HDR_SIZE;
-    memcpy(pCsr, zLocale, nLocale);
-    pCsr += nLocale;
-    (*pCsr++) = 0x00;
-    if( zText ) memcpy(pCsr, zText, nText);
-    assert( &pCsr[nText]==&pBlob[nBlob] );
-
-    sqlite3_result_blob(pCtx, pBlob, nBlob, sqlite3_free);
-  }
-}
-
-/*
-** Implementation of fts5_insttoken() function.
-*/
-static void fts5InsttokenFunc(
-  sqlite3_context *pCtx,          /* Function call context */
-  int nArg,                       /* Number of args */
-  sqlite3_value **apArg           /* Function arguments */
-){
-  assert( nArg==1 );
-  (void)nArg;
-  sqlite3_result_value(pCtx, apArg[0]);
-  sqlite3_result_subtype(pCtx, FTS5_INSTTOKEN_SUBTYPE);
-}
-
-/*
-** Return true if zName is the extension on one of the shadow tables used
-** by this module.
-*/
-static int fts5ShadowName(const char *zName){
-  static const char *azName[] = {
-    "config", "content", "data", "docsize", "idx"
-  };
-  unsigned int i;
-  for(i=0; i<sizeof(azName)/sizeof(azName[0]); i++){
-    if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
-  }
-  return 0;
-}
-
-/*
-** Run an integrity check on the FTS5 data structures.  Return a string
-** if anything is found amiss.  Return a NULL pointer if everything is
-** OK.
-*/
-static int fts5IntegrityMethod(
-  sqlite3_vtab *pVtab,    /* the FTS5 virtual table to check */
-  const char *zSchema,    /* Name of schema in which this table lives */
-  const char *zTabname,   /* Name of the table itself */
-  int isQuick,            /* True if this is a quick-check */
-  char **pzErr            /* Write error message here */
-){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  int rc;
-
-  assert( pzErr!=0 && *pzErr==0 );
-  UNUSED_PARAM(isQuick);
-  assert( pTab->p.pConfig->pzErrmsg==0 );
-  pTab->p.pConfig->pzErrmsg = pzErr;
-  rc = sqlite3Fts5StorageIntegrity(pTab->pStorage, 0);
-  if( *pzErr==0 && rc!=SQLITE_OK ){
-    if( (rc&0xff)==SQLITE_CORRUPT ){
-      *pzErr = sqlite3_mprintf("malformed inverted index for FTS5 table %s.%s",
-          zSchema, zTabname);
-      rc = (*pzErr) ? SQLITE_OK : SQLITE_NOMEM;
-    }else{
-      *pzErr = sqlite3_mprintf("unable to validate the inverted index for"
-          " FTS5 table %s.%s: %s",
-          zSchema, zTabname, sqlite3_errstr(rc));
-    }
-  }else if( (rc&0xff)==SQLITE_CORRUPT ){
-    rc = SQLITE_OK;
-  }
-  sqlite3Fts5IndexCloseReader(pTab->p.pIndex);
-  pTab->p.pConfig->pzErrmsg = 0;
-
-  return rc;
-}
-
-static int fts5Init(sqlite3 *db){
-  static const sqlite3_module fts5Mod = {
-    /* iVersion      */ 4,
-    /* xCreate       */ fts5CreateMethod,
-    /* xConnect      */ fts5ConnectMethod,
-    /* xBestIndex    */ fts5BestIndexMethod,
-    /* xDisconnect   */ fts5DisconnectMethod,
-    /* xDestroy      */ fts5DestroyMethod,
-    /* xOpen         */ fts5OpenMethod,
-    /* xClose        */ fts5CloseMethod,
-    /* xFilter       */ fts5FilterMethod,
-    /* xNext         */ fts5NextMethod,
-    /* xEof          */ fts5EofMethod,
-    /* xColumn       */ fts5ColumnMethod,
-    /* xRowid        */ fts5RowidMethod,
-    /* xUpdate       */ fts5UpdateMethod,
-    /* xBegin        */ fts5BeginMethod,
-    /* xSync         */ fts5SyncMethod,
-    /* xCommit       */ fts5CommitMethod,
-    /* xRollback     */ fts5RollbackMethod,
-    /* xFindFunction */ fts5FindFunctionMethod,
-    /* xRename       */ fts5RenameMethod,
-    /* xSavepoint    */ fts5SavepointMethod,
-    /* xRelease      */ fts5ReleaseMethod,
-    /* xRollbackTo   */ fts5RollbackToMethod,
-    /* xShadowName   */ fts5ShadowName,
-    /* xIntegrity    */ fts5IntegrityMethod
-  };
-
-  int rc;
-  Fts5Global *pGlobal = 0;
-
-  pGlobal = (Fts5Global*)sqlite3_malloc64(sizeof(Fts5Global));
-  if( pGlobal==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    void *p = (void*)pGlobal;
-    memset(pGlobal, 0, sizeof(Fts5Global));
-    pGlobal->db = db;
-    pGlobal->api.iVersion = 3;
-    pGlobal->api.xCreateFunction = fts5CreateAux;
-    pGlobal->api.xCreateTokenizer = fts5CreateTokenizer;
-    pGlobal->api.xFindTokenizer = fts5FindTokenizer;
-    pGlobal->api.xCreateTokenizer_v2 = fts5CreateTokenizer_v2;
-    pGlobal->api.xFindTokenizer_v2 = fts5FindTokenizer_v2;
-
-    /* Initialize pGlobal->aLocaleHdr[] to a 128-bit pseudo-random vector.
-    ** The constants below were generated randomly.  */
-    sqlite3_randomness(sizeof(pGlobal->aLocaleHdr), pGlobal->aLocaleHdr);
-    pGlobal->aLocaleHdr[0] ^= 0xF924976D;
-    pGlobal->aLocaleHdr[1] ^= 0x16596E13;
-    pGlobal->aLocaleHdr[2] ^= 0x7C80BEAA;
-    pGlobal->aLocaleHdr[3] ^= 0x9B03A67F;
-    assert( sizeof(pGlobal->aLocaleHdr)==16 );
-
-    rc = sqlite3_create_module_v2(db, "fts5", &fts5Mod, p, fts5ModuleDestroy);
-    if( rc==SQLITE_OK ) rc = sqlite3Fts5IndexInit(db);
-    if( rc==SQLITE_OK ) rc = sqlite3Fts5ExprInit(pGlobal, db);
-    if( rc==SQLITE_OK ) rc = sqlite3Fts5AuxInit(&pGlobal->api);
-    if( rc==SQLITE_OK ) rc = sqlite3Fts5TokenizerInit(&pGlobal->api);
-    if( rc==SQLITE_OK ) rc = sqlite3Fts5VocabInit(pGlobal, db);
-    if( rc==SQLITE_OK ){
-      rc = sqlite3_create_function(
-          db, "fts5", 1, SQLITE_UTF8, p, fts5Fts5Func, 0, 0
-      );
-    }
-    if( rc==SQLITE_OK ){
-      rc = sqlite3_create_function(
-          db, "fts5_source_id", 0,
-          SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS,
-          p, fts5SourceIdFunc, 0, 0
-      );
-    }
-    if( rc==SQLITE_OK ){
-      rc = sqlite3_create_function(
-          db, "fts5_locale", 2,
-          SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_RESULT_SUBTYPE|SQLITE_SUBTYPE,
-          p, fts5LocaleFunc, 0, 0
-      );
-    }
-    if( rc==SQLITE_OK ){
-      rc = sqlite3_create_function(
-          db, "fts5_insttoken", 1,
-          SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_RESULT_SUBTYPE,
-          p, fts5InsttokenFunc, 0, 0
-      );
-    }
-  }
-
-  /* If SQLITE_FTS5_ENABLE_TEST_MI is defined, assume that the file
-  ** fts5_test_mi.c is compiled and linked into the executable. And call
-  ** its entry point to enable the matchinfo() demo.  */
-#ifdef SQLITE_FTS5_ENABLE_TEST_MI
-  if( rc==SQLITE_OK ){
-    extern int sqlite3Fts5TestRegisterMatchinfoAPI(fts5_api*);
-    rc = sqlite3Fts5TestRegisterMatchinfoAPI(&pGlobal->api);
-  }
-#endif
-
-  return rc;
-}
-
-/*
-** The following functions are used to register the module with SQLite. If
-** this module is being built as part of the SQLite core (SQLITE_CORE is
-** defined), then sqlite3_open() will call sqlite3Fts5Init() directly.
-**
-** Or, if this module is being built as a loadable extension,
-** sqlite3Fts5Init() is omitted and the two standard entry points
-** sqlite3_fts_init() and sqlite3_fts5_init() defined instead.
-*/
-#ifndef SQLITE_CORE
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-SQLITE_API int sqlite3_fts_init(
-  sqlite3 *db,
-  char **pzErrMsg,
-  const sqlite3_api_routines *pApi
-){
-  SQLITE_EXTENSION_INIT2(pApi);
-  (void)pzErrMsg;  /* Unused parameter */
-  return fts5Init(db);
-}
-
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-SQLITE_API int sqlite3_fts5_init(
-  sqlite3 *db,
-  char **pzErrMsg,
-  const sqlite3_api_routines *pApi
-){
-  SQLITE_EXTENSION_INIT2(pApi);
-  (void)pzErrMsg;  /* Unused parameter */
-  return fts5Init(db);
-}
-#else
-SQLITE_PRIVATE int sqlite3Fts5Init(sqlite3 *db){
-  return fts5Init(db);
-}
-#endif
-
-/*
-** 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.
-**
-******************************************************************************
-**
-*/
-
-
-
-/* #include "fts5Int.h" */
-
-/*
-** pSavedRow:
-**   SQL statement FTS5_STMT_LOOKUP2 is a copy of FTS5_STMT_LOOKUP, it
-**   does a by-rowid lookup to retrieve a single row from the %_content
-**   table or equivalent external-content table/view.
-**
-**   However, FTS5_STMT_LOOKUP2 is only used when retrieving the original
-**   values for a row being UPDATEd. In that case, the SQL statement is
-**   not reset and pSavedRow is set to point at it. This is so that the
-**   insert operation that follows the delete may access the original
-**   row values for any new values for which sqlite3_value_nochange() returns
-**   true. i.e. if the user executes:
-**
-**        CREATE VIRTUAL TABLE ft USING fts5(a, b, c, locale=1);
-**        ...
-**        UPDATE fts SET a=?, b=? WHERE rowid=?;
-**
-**   then the value passed to the xUpdate() method of this table as the
-**   new.c value is an sqlite3_value_nochange() value. So in this case it
-**   must be read from the saved row stored in Fts5Storage.pSavedRow.
-**
-**   This is necessary - using sqlite3_value_nochange() instead of just having
-**   SQLite pass the original value back via xUpdate() - so as not to discard
-**   any locale information associated with such values.
-**
-*/
-struct Fts5Storage {
-  Fts5Config *pConfig;
-  Fts5Index *pIndex;
-  int bTotalsValid;               /* True if nTotalRow/aTotalSize[] are valid */
-  i64 nTotalRow;                  /* Total number of rows in FTS table */
-  i64 *aTotalSize;                /* Total sizes of each column */
-  sqlite3_stmt *pSavedRow;
-  sqlite3_stmt *aStmt[12];
-};
-
-
-#if FTS5_STMT_SCAN_ASC!=0
-# error "FTS5_STMT_SCAN_ASC mismatch"
-#endif
-#if FTS5_STMT_SCAN_DESC!=1
-# error "FTS5_STMT_SCAN_DESC mismatch"
-#endif
-#if FTS5_STMT_LOOKUP!=2
-# error "FTS5_STMT_LOOKUP mismatch"
-#endif
-
-#define FTS5_STMT_LOOKUP2         3
-#define FTS5_STMT_INSERT_CONTENT  4
-#define FTS5_STMT_REPLACE_CONTENT 5
-#define FTS5_STMT_DELETE_CONTENT  6
-#define FTS5_STMT_REPLACE_DOCSIZE 7
-#define FTS5_STMT_DELETE_DOCSIZE  8
-#define FTS5_STMT_LOOKUP_DOCSIZE  9
-#define FTS5_STMT_REPLACE_CONFIG 10
-#define FTS5_STMT_SCAN           11
-
-/*
-** Prepare the two insert statements - Fts5Storage.pInsertContent and
-** Fts5Storage.pInsertDocsize - if they have not already been prepared.
-** Return SQLITE_OK if successful, or an SQLite error code if an error
-** occurs.
-*/
-static int fts5StorageGetStmt(
-  Fts5Storage *p,                 /* Storage handle */
-  int eStmt,                      /* FTS5_STMT_XXX constant */
-  sqlite3_stmt **ppStmt,          /* OUT: Prepared statement handle */
-  char **pzErrMsg                 /* OUT: Error message (if any) */
-){
-  int rc = SQLITE_OK;
-
-  /* If there is no %_docsize table, there should be no requests for
-  ** statements to operate on it.  */
-  assert( p->pConfig->bColumnsize || (
-        eStmt!=FTS5_STMT_REPLACE_DOCSIZE
-     && eStmt!=FTS5_STMT_DELETE_DOCSIZE
-     && eStmt!=FTS5_STMT_LOOKUP_DOCSIZE
-  ));
-
-  assert( eStmt>=0 && eStmt<ArraySize(p->aStmt) );
-  if( p->aStmt[eStmt]==0 ){
-    const char *azStmt[] = {
-      "SELECT %s FROM %s T WHERE T.%Q >= ? AND T.%Q <= ? ORDER BY T.%Q ASC",
-      "SELECT %s FROM %s T WHERE T.%Q <= ? AND T.%Q >= ? ORDER BY T.%Q DESC",
-      "SELECT %s FROM %s T WHERE T.%Q=?",               /* LOOKUP  */
-      "SELECT %s FROM %s T WHERE T.%Q=?",               /* LOOKUP2  */
-
-      "INSERT INTO %Q.'%q_content' VALUES(%s)",         /* INSERT_CONTENT  */
-      "REPLACE INTO %Q.'%q_content' VALUES(%s)",        /* REPLACE_CONTENT */
-      "DELETE FROM %Q.'%q_content' WHERE id=?",         /* DELETE_CONTENT  */
-      "REPLACE INTO %Q.'%q_docsize' VALUES(?,?%s)",     /* REPLACE_DOCSIZE  */
-      "DELETE FROM %Q.'%q_docsize' WHERE id=?",         /* DELETE_DOCSIZE  */
-
-      "SELECT sz%s FROM %Q.'%q_docsize' WHERE id=?",    /* LOOKUP_DOCSIZE  */
-
-      "REPLACE INTO %Q.'%q_config' VALUES(?,?)",        /* REPLACE_CONFIG */
-      "SELECT %s FROM %s AS T",                         /* SCAN */
-    };
-    Fts5Config *pC = p->pConfig;
-    char *zSql = 0;
-
-    assert( ArraySize(azStmt)==ArraySize(p->aStmt) );
-
-    switch( eStmt ){
-      case FTS5_STMT_SCAN:
-        zSql = sqlite3_mprintf(azStmt[eStmt],
-            pC->zContentExprlist, pC->zContent
-        );
-        break;
-
-      case FTS5_STMT_SCAN_ASC:
-      case FTS5_STMT_SCAN_DESC:
-        zSql = sqlite3_mprintf(azStmt[eStmt], pC->zContentExprlist,
-            pC->zContent, pC->zContentRowid, pC->zContentRowid,
-            pC->zContentRowid
-        );
-        break;
-
-      case FTS5_STMT_LOOKUP:
-      case FTS5_STMT_LOOKUP2:
-        zSql = sqlite3_mprintf(azStmt[eStmt],
-            pC->zContentExprlist, pC->zContent, pC->zContentRowid
-        );
-        break;
-
-      case FTS5_STMT_INSERT_CONTENT:
-      case FTS5_STMT_REPLACE_CONTENT: {
-        char *zBind = 0;
-        int i;
-
-        assert( pC->eContent==FTS5_CONTENT_NORMAL
-             || pC->eContent==FTS5_CONTENT_UNINDEXED
-        );
-
-        /* Add bindings for the "c*" columns - those that store the actual
-        ** table content. If eContent==NORMAL, then there is one binding
-        ** for each column. Or, if eContent==UNINDEXED, then there are only
-        ** bindings for the UNINDEXED columns. */
-        for(i=0; rc==SQLITE_OK && i<(pC->nCol+1); i++){
-          if( !i || pC->eContent==FTS5_CONTENT_NORMAL || pC->abUnindexed[i-1] ){
-            zBind = sqlite3Fts5Mprintf(&rc, "%z%s?%d", zBind, zBind?",":"",i+1);
-          }
-        }
-
-        /* Add bindings for any "l*" columns. Only non-UNINDEXED columns
-        ** require these.  */
-        if( pC->bLocale && pC->eContent==FTS5_CONTENT_NORMAL ){
-          for(i=0; rc==SQLITE_OK && i<pC->nCol; i++){
-            if( pC->abUnindexed[i]==0 ){
-              zBind = sqlite3Fts5Mprintf(&rc, "%z,?%d", zBind, pC->nCol+i+2);
-            }
-          }
-        }
-
-        zSql = sqlite3Fts5Mprintf(&rc, azStmt[eStmt], pC->zDb, pC->zName,zBind);
-        sqlite3_free(zBind);
-        break;
-      }
-
-      case FTS5_STMT_REPLACE_DOCSIZE:
-        zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName,
-          (pC->bContentlessDelete ? ",?" : "")
-        );
-        break;
-
-      case FTS5_STMT_LOOKUP_DOCSIZE:
-        zSql = sqlite3_mprintf(azStmt[eStmt],
-            (pC->bContentlessDelete ? ",origin" : ""),
-            pC->zDb, pC->zName
-        );
-        break;
-
-      default:
-        zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
-        break;
-    }
-
-    if( zSql==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      int f = SQLITE_PREPARE_PERSISTENT;
-      if( eStmt>FTS5_STMT_LOOKUP2 ) f |= SQLITE_PREPARE_NO_VTAB;
-      p->pConfig->bLock++;
-      rc = sqlite3_prepare_v3(pC->db, zSql, -1, f, &p->aStmt[eStmt], 0);
-      p->pConfig->bLock--;
-      sqlite3_free(zSql);
-      if( rc!=SQLITE_OK && pzErrMsg ){
-        *pzErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pC->db));
-      }
-      if( rc==SQLITE_ERROR && eStmt>FTS5_STMT_LOOKUP2 && eStmt<FTS5_STMT_SCAN ){
-        /* One of the internal tables - not the %_content table - is missing.
-        ** This counts as a corrupted table.  */
-       rc = SQLITE_CORRUPT;
-      }
-    }
-  }
-
-  *ppStmt = p->aStmt[eStmt];
-  sqlite3_reset(*ppStmt);
-  return rc;
-}
-
-
-static int fts5ExecPrintf(
-  sqlite3 *db,
-  char **pzErr,
-  const char *zFormat,
-  ...
-){
-  int rc;
-  va_list ap;                     /* ... printf arguments */
-  char *zSql;
-
-  va_start(ap, zFormat);
-  zSql = sqlite3_vmprintf(zFormat, ap);
-
-  if( zSql==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    rc = sqlite3_exec(db, zSql, 0, 0, pzErr);
-    sqlite3_free(zSql);
-  }
-
-  va_end(ap);
-  return rc;
-}
-
-/*
-** Drop all shadow tables. Return SQLITE_OK if successful or an SQLite error
-** code otherwise.
-*/
-static int sqlite3Fts5DropAll(Fts5Config *pConfig){
-  int rc = fts5ExecPrintf(pConfig->db, 0,
-      "DROP TABLE IF EXISTS %Q.'%q_data';"
-      "DROP TABLE IF EXISTS %Q.'%q_idx';"
-      "DROP TABLE IF EXISTS %Q.'%q_config';",
-      pConfig->zDb, pConfig->zName,
-      pConfig->zDb, pConfig->zName,
-      pConfig->zDb, pConfig->zName
-  );
-  if( rc==SQLITE_OK && pConfig->bColumnsize ){
-    rc = fts5ExecPrintf(pConfig->db, 0,
-        "DROP TABLE IF EXISTS %Q.'%q_docsize';",
-        pConfig->zDb, pConfig->zName
-    );
-  }
-  if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
-    rc = fts5ExecPrintf(pConfig->db, 0,
-        "DROP TABLE IF EXISTS %Q.'%q_content';",
-        pConfig->zDb, pConfig->zName
-    );
-  }
-  return rc;
-}
-
-static void fts5StorageRenameOne(
-  Fts5Config *pConfig,            /* Current FTS5 configuration */
-  int *pRc,                       /* IN/OUT: Error code */
-  const char *zTail,              /* Tail of table name e.g. "data", "config" */
-  const char *zName               /* New name of FTS5 table */
-){
-  if( *pRc==SQLITE_OK ){
-    *pRc = fts5ExecPrintf(pConfig->db, 0,
-        "ALTER TABLE %Q.'%q_%s' RENAME TO '%q_%s';",
-        pConfig->zDb, pConfig->zName, zTail, zName, zTail
-    );
-  }
-}
-
-static int sqlite3Fts5StorageRename(Fts5Storage *pStorage, const char *zName){
-  Fts5Config *pConfig = pStorage->pConfig;
-  int rc = sqlite3Fts5StorageSync(pStorage);
-
-  fts5StorageRenameOne(pConfig, &rc, "data", zName);
-  fts5StorageRenameOne(pConfig, &rc, "idx", zName);
-  fts5StorageRenameOne(pConfig, &rc, "config", zName);
-  if( pConfig->bColumnsize ){
-    fts5StorageRenameOne(pConfig, &rc, "docsize", zName);
-  }
-  if( pConfig->eContent==FTS5_CONTENT_NORMAL ){
-    fts5StorageRenameOne(pConfig, &rc, "content", zName);
-  }
-  return rc;
-}
-
-/*
-** Create the shadow table named zPost, with definition zDefn. Return
-** SQLITE_OK if successful, or an SQLite error code otherwise.
-*/
-static int sqlite3Fts5CreateTable(
-  Fts5Config *pConfig,            /* FTS5 configuration */
-  const char *zPost,              /* Shadow table to create (e.g. "content") */
-  const char *zDefn,              /* Columns etc. for shadow table */
-  int bWithout,                   /* True for without rowid */
-  char **pzErr                    /* OUT: Error message */
-){
-  int rc;
-  char *zErr = 0;
-
-  rc = fts5ExecPrintf(pConfig->db, &zErr, "CREATE TABLE %Q.'%q_%q'(%s)%s",
-      pConfig->zDb, pConfig->zName, zPost, zDefn,
-#ifndef SQLITE_FTS5_NO_WITHOUT_ROWID
-      bWithout?" WITHOUT ROWID":
-#endif
-      ""
-  );
-  if( zErr ){
-    *pzErr = sqlite3_mprintf(
-        "fts5: error creating shadow table %q_%s: %s",
-        pConfig->zName, zPost, zErr
-    );
-    sqlite3_free(zErr);
-  }
-
-  return rc;
-}
-
-/*
-** Open a new Fts5Index handle. If the bCreate argument is true, create
-** and initialize the underlying tables
-**
-** If successful, set *pp to point to the new object and return SQLITE_OK.
-** Otherwise, set *pp to NULL and return an SQLite error code.
-*/
-static int sqlite3Fts5StorageOpen(
-  Fts5Config *pConfig,
-  Fts5Index *pIndex,
-  int bCreate,
-  Fts5Storage **pp,
-  char **pzErr                    /* OUT: Error message */
-){
-  int rc = SQLITE_OK;
-  Fts5Storage *p;                 /* New object */
-  sqlite3_int64 nByte;            /* Bytes of space to allocate */
-
-  nByte = sizeof(Fts5Storage)               /* Fts5Storage object */
-        + pConfig->nCol * sizeof(i64);      /* Fts5Storage.aTotalSize[] */
-  *pp = p = (Fts5Storage*)sqlite3_malloc64(nByte);
-  if( !p ) return SQLITE_NOMEM;
-
-  memset(p, 0, (size_t)nByte);
-  p->aTotalSize = (i64*)&p[1];
-  p->pConfig = pConfig;
-  p->pIndex = pIndex;
-
-  if( bCreate ){
-    if( pConfig->eContent==FTS5_CONTENT_NORMAL
-     || pConfig->eContent==FTS5_CONTENT_UNINDEXED
-    ){
-      int nDefn = 32 + pConfig->nCol*10;
-      char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 20);
-      if( zDefn==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        int i;
-        int iOff;
-        sqlite3_snprintf(nDefn, zDefn, "id INTEGER PRIMARY KEY");
-        iOff = (int)strlen(zDefn);
-        for(i=0; i<pConfig->nCol; i++){
-          if( pConfig->eContent==FTS5_CONTENT_NORMAL
-           || pConfig->abUnindexed[i]
-          ){
-            sqlite3_snprintf(nDefn-iOff, &zDefn[iOff], ", c%d", i);
-            iOff += (int)strlen(&zDefn[iOff]);
-          }
-        }
-        if( pConfig->bLocale ){
-          for(i=0; i<pConfig->nCol; i++){
-            if( pConfig->abUnindexed[i]==0 ){
-              sqlite3_snprintf(nDefn-iOff, &zDefn[iOff], ", l%d", i);
-              iOff += (int)strlen(&zDefn[iOff]);
-            }
-          }
-        }
-        rc = sqlite3Fts5CreateTable(pConfig, "content", zDefn, 0, pzErr);
-      }
-      sqlite3_free(zDefn);
-    }
-
-    if( rc==SQLITE_OK && pConfig->bColumnsize ){
-      const char *zCols = "id INTEGER PRIMARY KEY, sz BLOB";
-      if( pConfig->bContentlessDelete ){
-        zCols = "id INTEGER PRIMARY KEY, sz BLOB, origin INTEGER";
-      }
-      rc = sqlite3Fts5CreateTable(pConfig, "docsize", zCols, 0, pzErr);
-    }
-    if( rc==SQLITE_OK ){
-      rc = sqlite3Fts5CreateTable(
-          pConfig, "config", "k PRIMARY KEY, v", 1, pzErr
-      );
-    }
-    if( rc==SQLITE_OK ){
-      rc = sqlite3Fts5StorageConfigValue(p, "version", 0, FTS5_CURRENT_VERSION);
-    }
-  }
-
-  if( rc ){
-    sqlite3Fts5StorageClose(p);
-    *pp = 0;
-  }
-  return rc;
-}
-
-/*
-** Close a handle opened by an earlier call to sqlite3Fts5StorageOpen().
-*/
-static int sqlite3Fts5StorageClose(Fts5Storage *p){
-  int rc = SQLITE_OK;
-  if( p ){
-    int i;
-
-    /* Finalize all SQL statements */
-    for(i=0; i<ArraySize(p->aStmt); i++){
-      sqlite3_finalize(p->aStmt[i]);
-    }
-
-    sqlite3_free(p);
-  }
-  return rc;
-}
-
-typedef struct Fts5InsertCtx Fts5InsertCtx;
-struct Fts5InsertCtx {
-  Fts5Storage *pStorage;
-  int iCol;
-  int szCol;                      /* Size of column value in tokens */
-};
-
-/*
-** Tokenization callback used when inserting tokens into the FTS index.
-*/
-static int fts5StorageInsertCallback(
-  void *pContext,                 /* Pointer to Fts5InsertCtx object */
-  int tflags,
-  const char *pToken,             /* Buffer containing token */
-  int nToken,                     /* Size of token in bytes */
-  int iUnused1,                   /* Start offset of token */
-  int iUnused2                    /* End offset of token */
-){
-  Fts5InsertCtx *pCtx = (Fts5InsertCtx*)pContext;
-  Fts5Index *pIdx = pCtx->pStorage->pIndex;
-  UNUSED_PARAM2(iUnused1, iUnused2);
-  if( nToken>FTS5_MAX_TOKEN_SIZE ) nToken = FTS5_MAX_TOKEN_SIZE;
-  if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
-    pCtx->szCol++;
-  }
-  return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
-}
-
-/*
-** This function is used as part of an UPDATE statement that modifies the
-** rowid of a row. In that case, this function is called first to set
-** Fts5Storage.pSavedRow to point to a statement that may be used to
-** access the original values of the row being deleted - iDel.
-**
-** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
-** It is not considered an error if row iDel does not exist. In this case
-** pSavedRow is not set and SQLITE_OK returned.
-*/
-static int sqlite3Fts5StorageFindDeleteRow(Fts5Storage *p, i64 iDel){
-  int rc = SQLITE_OK;
-  sqlite3_stmt *pSeek = 0;
-
-  assert( p->pSavedRow==0 );
-  rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP+1, &pSeek, 0);
-  if( rc==SQLITE_OK ){
-    sqlite3_bind_int64(pSeek, 1, iDel);
-    if( sqlite3_step(pSeek)!=SQLITE_ROW ){
-      rc = sqlite3_reset(pSeek);
-    }else{
-      p->pSavedRow = pSeek;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** If a row with rowid iDel is present in the %_content table, add the
-** delete-markers to the FTS index necessary to delete it. Do not actually
-** remove the %_content row at this time though.
-**
-** If parameter bSaveRow is true, then Fts5Storage.pSavedRow is left
-** pointing to a statement (FTS5_STMT_LOOKUP2) that may be used to access
-** the original values of the row being deleted. This is used by UPDATE
-** statements.
-*/
-static int fts5StorageDeleteFromIndex(
-  Fts5Storage *p,
-  i64 iDel,
-  sqlite3_value **apVal,
-  int bSaveRow                    /* True to set pSavedRow */
-){
-  Fts5Config *pConfig = p->pConfig;
-  sqlite3_stmt *pSeek = 0;        /* SELECT to read row iDel from %_data */
-  int rc = SQLITE_OK;             /* Return code */
-  int rc2;                        /* sqlite3_reset() return code */
-  int iCol;
-  Fts5InsertCtx ctx;
-
-  assert( bSaveRow==0 || apVal==0 );
-  assert( bSaveRow==0 || bSaveRow==1 );
-  assert( FTS5_STMT_LOOKUP2==FTS5_STMT_LOOKUP+1 );
-
-  if( apVal==0 ){
-    if( p->pSavedRow && bSaveRow ){
-      pSeek = p->pSavedRow;
-      p->pSavedRow = 0;
-    }else{
-      rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP+bSaveRow, &pSeek, 0);
-      if( rc!=SQLITE_OK ) return rc;
-      sqlite3_bind_int64(pSeek, 1, iDel);
-      if( sqlite3_step(pSeek)!=SQLITE_ROW ){
-        return sqlite3_reset(pSeek);
-      }
-    }
-  }
-
-  ctx.pStorage = p;
-  ctx.iCol = -1;
-  for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
-    if( pConfig->abUnindexed[iCol-1]==0 ){
-      sqlite3_value *pVal = 0;
-      sqlite3_value *pFree = 0;
-      const char *pText = 0;
-      int nText = 0;
-      const char *pLoc = 0;
-      int nLoc = 0;
-
-      assert( pSeek==0 || apVal==0 );
-      assert( pSeek!=0 || apVal!=0 );
-      if( pSeek ){
-        pVal = sqlite3_column_value(pSeek, iCol);
-      }else{
-        pVal = apVal[iCol-1];
-      }
-
-      if( pConfig->bLocale && sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
-        rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
-      }else{
-        if( sqlite3_value_type(pVal)!=SQLITE_TEXT ){
-          /* Make a copy of the value to work with. This is because the call
-          ** to sqlite3_value_text() below forces the type of the value to
-          ** SQLITE_TEXT, and we may need to use it again later. */
-          pFree = pVal = sqlite3_value_dup(pVal);
-          if( pVal==0 ){
-            rc = SQLITE_NOMEM;
-          }
-        }
-        if( rc==SQLITE_OK ){
-          pText = (const char*)sqlite3_value_text(pVal);
-          nText = sqlite3_value_bytes(pVal);
-          if( pConfig->bLocale && pSeek ){
-            pLoc = (const char*)sqlite3_column_text(pSeek, iCol+pConfig->nCol);
-            nLoc = sqlite3_column_bytes(pSeek, iCol + pConfig->nCol);
-          }
-        }
-      }
-
-      if( rc==SQLITE_OK ){
-        sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
-        ctx.szCol = 0;
-        rc = sqlite3Fts5Tokenize(pConfig, FTS5_TOKENIZE_DOCUMENT,
-            pText, nText, (void*)&ctx, fts5StorageInsertCallback
-        );
-        p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
-        if( rc==SQLITE_OK && p->aTotalSize[iCol-1]<0 ){
-          rc = FTS5_CORRUPT;
-        }
-        sqlite3Fts5ClearLocale(pConfig);
-      }
-      sqlite3_value_free(pFree);
-    }
-  }
-  if( rc==SQLITE_OK && p->nTotalRow<1 ){
-    rc = FTS5_CORRUPT;
-  }else{
-    p->nTotalRow--;
-  }
-
-  if( rc==SQLITE_OK && bSaveRow ){
-    assert( p->pSavedRow==0 );
-    p->pSavedRow = pSeek;
-  }else{
-    rc2 = sqlite3_reset(pSeek);
-    if( rc==SQLITE_OK ) rc = rc2;
-  }
-  return rc;
-}
-
-/*
-** Reset any saved statement pSavedRow. Zero pSavedRow as well. This
-** should be called by the xUpdate() method of the fts5 table before
-** returning from any operation that may have set Fts5Storage.pSavedRow.
-*/
-static void sqlite3Fts5StorageReleaseDeleteRow(Fts5Storage *pStorage){
-  assert( pStorage->pSavedRow==0
-       || pStorage->pSavedRow==pStorage->aStmt[FTS5_STMT_LOOKUP2]
-  );
-  sqlite3_reset(pStorage->pSavedRow);
-  pStorage->pSavedRow = 0;
-}
-
-/*
-** This function is called to process a DELETE on a contentless_delete=1
-** table. It adds the tombstone required to delete the entry with rowid
-** iDel. If successful, SQLITE_OK is returned. Or, if an error occurs,
-** an SQLite error code.
-*/
-static int fts5StorageContentlessDelete(Fts5Storage *p, i64 iDel){
-  i64 iOrigin = 0;
-  sqlite3_stmt *pLookup = 0;
-  int rc = SQLITE_OK;
-
-  assert( p->pConfig->bContentlessDelete );
-  assert( p->pConfig->eContent==FTS5_CONTENT_NONE
-       || p->pConfig->eContent==FTS5_CONTENT_UNINDEXED
-  );
-
-  /* Look up the origin of the document in the %_docsize table. Store
-  ** this in stack variable iOrigin.  */
-  rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP_DOCSIZE, &pLookup, 0);
-  if( rc==SQLITE_OK ){
-    sqlite3_bind_int64(pLookup, 1, iDel);
-    if( SQLITE_ROW==sqlite3_step(pLookup) ){
-      iOrigin = sqlite3_column_int64(pLookup, 1);
-    }
-    rc = sqlite3_reset(pLookup);
-  }
-
-  if( rc==SQLITE_OK && iOrigin!=0 ){
-    rc = sqlite3Fts5IndexContentlessDelete(p->pIndex, iOrigin, iDel);
-  }
-
-  return rc;
-}
-
-/*
-** Insert a record into the %_docsize table. Specifically, do:
-**
-**   INSERT OR REPLACE INTO %_docsize(id, sz) VALUES(iRowid, pBuf);
-**
-** If there is no %_docsize table (as happens if the columnsize=0 option
-** is specified when the FTS5 table is created), this function is a no-op.
-*/
-static int fts5StorageInsertDocsize(
-  Fts5Storage *p,                 /* Storage module to write to */
-  i64 iRowid,                     /* id value */
-  Fts5Buffer *pBuf                /* sz value */
-){
-  int rc = SQLITE_OK;
-  if( p->pConfig->bColumnsize ){
-    sqlite3_stmt *pReplace = 0;
-    rc = fts5StorageGetStmt(p, FTS5_STMT_REPLACE_DOCSIZE, &pReplace, 0);
-    if( rc==SQLITE_OK ){
-      sqlite3_bind_int64(pReplace, 1, iRowid);
-      if( p->pConfig->bContentlessDelete ){
-        i64 iOrigin = 0;
-        rc = sqlite3Fts5IndexGetOrigin(p->pIndex, &iOrigin);
-        sqlite3_bind_int64(pReplace, 3, iOrigin);
-      }
-    }
-    if( rc==SQLITE_OK ){
-      sqlite3_bind_blob(pReplace, 2, pBuf->p, pBuf->n, SQLITE_STATIC);
-      sqlite3_step(pReplace);
-      rc = sqlite3_reset(pReplace);
-      sqlite3_bind_null(pReplace, 2);
-    }
-  }
-  return rc;
-}
-
-/*
-** Load the contents of the "averages" record from disk into the
-** p->nTotalRow and p->aTotalSize[] variables. If successful, and if
-** argument bCache is true, set the p->bTotalsValid flag to indicate
-** that the contents of aTotalSize[] and nTotalRow are valid until
-** further notice.
-**
-** Return SQLITE_OK if successful, or an SQLite error code if an error
-** occurs.
-*/
-static int fts5StorageLoadTotals(Fts5Storage *p, int bCache){
-  int rc = SQLITE_OK;
-  if( p->bTotalsValid==0 ){
-    rc = sqlite3Fts5IndexGetAverages(p->pIndex, &p->nTotalRow, p->aTotalSize);
-    p->bTotalsValid = bCache;
-  }
-  return rc;
-}
-
-/*
-** Store the current contents of the p->nTotalRow and p->aTotalSize[]
-** variables in the "averages" record on disk.
-**
-** Return SQLITE_OK if successful, or an SQLite error code if an error
-** occurs.
-*/
-static int fts5StorageSaveTotals(Fts5Storage *p){
-  int nCol = p->pConfig->nCol;
-  int i;
-  Fts5Buffer buf;
-  int rc = SQLITE_OK;
-  memset(&buf, 0, sizeof(buf));
-
-  sqlite3Fts5BufferAppendVarint(&rc, &buf, p->nTotalRow);
-  for(i=0; i<nCol; i++){
-    sqlite3Fts5BufferAppendVarint(&rc, &buf, p->aTotalSize[i]);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5IndexSetAverages(p->pIndex, buf.p, buf.n);
-  }
-  sqlite3_free(buf.p);
-
-  return rc;
-}
-
-/*
-** Remove a row from the FTS table.
-*/
-static int sqlite3Fts5StorageDelete(
-  Fts5Storage *p,                 /* Storage object */
-  i64 iDel,                       /* Rowid to delete from table */
-  sqlite3_value **apVal,          /* Optional - values to remove from index */
-  int bSaveRow                    /* If true, set pSavedRow for deleted row */
-){
-  Fts5Config *pConfig = p->pConfig;
-  int rc;
-  sqlite3_stmt *pDel = 0;
-
-  assert( pConfig->eContent!=FTS5_CONTENT_NORMAL || apVal==0 );
-  rc = fts5StorageLoadTotals(p, 1);
-
-  /* Delete the index records */
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5IndexBeginWrite(p->pIndex, 1, iDel);
-  }
-
-  if( rc==SQLITE_OK ){
-    if( p->pConfig->bContentlessDelete ){
-      rc = fts5StorageContentlessDelete(p, iDel);
-      if( rc==SQLITE_OK
-       && bSaveRow
-       && p->pConfig->eContent==FTS5_CONTENT_UNINDEXED
-      ){
-        rc = sqlite3Fts5StorageFindDeleteRow(p, iDel);
-      }
-    }else{
-      rc = fts5StorageDeleteFromIndex(p, iDel, apVal, bSaveRow);
-    }
-  }
-
-  /* Delete the %_docsize record */
-  if( rc==SQLITE_OK && pConfig->bColumnsize ){
-    rc = fts5StorageGetStmt(p, FTS5_STMT_DELETE_DOCSIZE, &pDel, 0);
-    if( rc==SQLITE_OK ){
-      sqlite3_bind_int64(pDel, 1, iDel);
-      sqlite3_step(pDel);
-      rc = sqlite3_reset(pDel);
-    }
-  }
-
-  /* Delete the %_content record */
-  if( pConfig->eContent==FTS5_CONTENT_NORMAL
-   || pConfig->eContent==FTS5_CONTENT_UNINDEXED
-  ){
-    if( rc==SQLITE_OK ){
-      rc = fts5StorageGetStmt(p, FTS5_STMT_DELETE_CONTENT, &pDel, 0);
-    }
-    if( rc==SQLITE_OK ){
-      sqlite3_bind_int64(pDel, 1, iDel);
-      sqlite3_step(pDel);
-      rc = sqlite3_reset(pDel);
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Delete all entries in the FTS5 index.
-*/
-static int sqlite3Fts5StorageDeleteAll(Fts5Storage *p){
-  Fts5Config *pConfig = p->pConfig;
-  int rc;
-
-  p->bTotalsValid = 0;
-
-  /* Delete the contents of the %_data and %_docsize tables. */
-  rc = fts5ExecPrintf(pConfig->db, 0,
-      "DELETE FROM %Q.'%q_data';"
-      "DELETE FROM %Q.'%q_idx';",
-      pConfig->zDb, pConfig->zName,
-      pConfig->zDb, pConfig->zName
-  );
-  if( rc==SQLITE_OK && pConfig->bColumnsize ){
-    rc = fts5ExecPrintf(pConfig->db, 0,
-        "DELETE FROM %Q.'%q_docsize';", pConfig->zDb, pConfig->zName
-    );
-  }
-
-  if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_UNINDEXED ){
-    rc = fts5ExecPrintf(pConfig->db, 0,
-        "DELETE FROM %Q.'%q_content';", pConfig->zDb, pConfig->zName
-    );
-  }
-
-  /* Reinitialize the %_data table. This call creates the initial structure
-  ** and averages records.  */
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5IndexReinit(p->pIndex);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5StorageConfigValue(p, "version", 0, FTS5_CURRENT_VERSION);
-  }
-  return rc;
-}
-
-static int sqlite3Fts5StorageRebuild(Fts5Storage *p){
-  Fts5Buffer buf = {0,0,0};
-  Fts5Config *pConfig = p->pConfig;
-  sqlite3_stmt *pScan = 0;
-  Fts5InsertCtx ctx;
-  int rc, rc2;
-
-  memset(&ctx, 0, sizeof(Fts5InsertCtx));
-  ctx.pStorage = p;
-  rc = sqlite3Fts5StorageDeleteAll(p);
-  if( rc==SQLITE_OK ){
-    rc = fts5StorageLoadTotals(p, 1);
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = fts5StorageGetStmt(p, FTS5_STMT_SCAN, &pScan, pConfig->pzErrmsg);
-  }
-
-  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pScan) ){
-    i64 iRowid = sqlite3_column_int64(pScan, 0);
-
-    sqlite3Fts5BufferZero(&buf);
-    rc = sqlite3Fts5IndexBeginWrite(p->pIndex, 0, iRowid);
-    for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
-      ctx.szCol = 0;
-      if( pConfig->abUnindexed[ctx.iCol]==0 ){
-        int nText = 0;            /* Size of pText in bytes */
-        const char *pText = 0;    /* Pointer to buffer containing text value */
-        int nLoc = 0;             /* Size of pLoc in bytes */
-        const char *pLoc = 0;     /* Pointer to buffer containing text value */
-
-        sqlite3_value *pVal = sqlite3_column_value(pScan, ctx.iCol+1);
-        if( pConfig->eContent==FTS5_CONTENT_EXTERNAL
-         && sqlite3Fts5IsLocaleValue(pConfig, pVal)
-        ){
-          rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
-        }else{
-          pText = (const char*)sqlite3_value_text(pVal);
-          nText = sqlite3_value_bytes(pVal);
-          if( pConfig->bLocale ){
-            int iCol = ctx.iCol + 1 + pConfig->nCol;
-            pLoc = (const char*)sqlite3_column_text(pScan, iCol);
-            nLoc = sqlite3_column_bytes(pScan, iCol);
-          }
-        }
-
-        if( rc==SQLITE_OK ){
-          sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
-          rc = sqlite3Fts5Tokenize(pConfig,
-              FTS5_TOKENIZE_DOCUMENT,
-              pText, nText,
-              (void*)&ctx,
-              fts5StorageInsertCallback
-          );
-          sqlite3Fts5ClearLocale(pConfig);
-        }
-      }
-      sqlite3Fts5BufferAppendVarint(&rc, &buf, ctx.szCol);
-      p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
-    }
-    p->nTotalRow++;
-
-    if( rc==SQLITE_OK ){
-      rc = fts5StorageInsertDocsize(p, iRowid, &buf);
-    }
-  }
-  sqlite3_free(buf.p);
-  rc2 = sqlite3_reset(pScan);
-  if( rc==SQLITE_OK ) rc = rc2;
-
-  /* Write the averages record */
-  if( rc==SQLITE_OK ){
-    rc = fts5StorageSaveTotals(p);
-  }
-  return rc;
-}
-
-static int sqlite3Fts5StorageOptimize(Fts5Storage *p){
-  return sqlite3Fts5IndexOptimize(p->pIndex);
-}
-
-static int sqlite3Fts5StorageMerge(Fts5Storage *p, int nMerge){
-  return sqlite3Fts5IndexMerge(p->pIndex, nMerge);
-}
-
-static int sqlite3Fts5StorageReset(Fts5Storage *p){
-  return sqlite3Fts5IndexReset(p->pIndex);
-}
-
-/*
-** Allocate a new rowid. This is used for "external content" tables when
-** a NULL value is inserted into the rowid column. The new rowid is allocated
-** by inserting a dummy row into the %_docsize table. The dummy will be
-** overwritten later.
-**
-** If the %_docsize table does not exist, SQLITE_MISMATCH is returned. In
-** this case the user is required to provide a rowid explicitly.
-*/
-static int fts5StorageNewRowid(Fts5Storage *p, i64 *piRowid){
-  int rc = SQLITE_MISMATCH;
-  if( p->pConfig->bColumnsize ){
-    sqlite3_stmt *pReplace = 0;
-    rc = fts5StorageGetStmt(p, FTS5_STMT_REPLACE_DOCSIZE, &pReplace, 0);
-    if( rc==SQLITE_OK ){
-      sqlite3_bind_null(pReplace, 1);
-      sqlite3_bind_null(pReplace, 2);
-      sqlite3_step(pReplace);
-      rc = sqlite3_reset(pReplace);
-    }
-    if( rc==SQLITE_OK ){
-      *piRowid = sqlite3_last_insert_rowid(p->pConfig->db);
-    }
-  }
-  return rc;
-}
-
-/*
-** Insert a new row into the FTS content table.
-*/
-static int sqlite3Fts5StorageContentInsert(
-  Fts5Storage *p,
-  int bReplace,                   /* True to use REPLACE instead of INSERT */
-  sqlite3_value **apVal,
-  i64 *piRowid
-){
-  Fts5Config *pConfig = p->pConfig;
-  int rc = SQLITE_OK;
-
-  /* Insert the new row into the %_content table. */
-  if( pConfig->eContent!=FTS5_CONTENT_NORMAL
-   && pConfig->eContent!=FTS5_CONTENT_UNINDEXED
-  ){
-    if( sqlite3_value_type(apVal[1])==SQLITE_INTEGER ){
-      *piRowid = sqlite3_value_int64(apVal[1]);
-    }else{
-      rc = fts5StorageNewRowid(p, piRowid);
-    }
-  }else{
-    sqlite3_stmt *pInsert = 0;    /* Statement to write %_content table */
-    int i;                        /* Counter variable */
-
-    assert( FTS5_STMT_INSERT_CONTENT+1==FTS5_STMT_REPLACE_CONTENT );
-    assert( bReplace==0 || bReplace==1 );
-    rc = fts5StorageGetStmt(p, FTS5_STMT_INSERT_CONTENT+bReplace, &pInsert, 0);
-    if( pInsert ) sqlite3_clear_bindings(pInsert);
-
-    /* Bind the rowid value */
-    sqlite3_bind_value(pInsert, 1, apVal[1]);
-
-    /* Loop through values for user-defined columns. i=2 is the leftmost
-    ** user-defined column. As is column 1 of pSavedRow.  */
-    for(i=2; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
-      int bUnindexed = pConfig->abUnindexed[i-2];
-      if( pConfig->eContent==FTS5_CONTENT_NORMAL || bUnindexed ){
-        sqlite3_value *pVal = apVal[i];
-
-        if( sqlite3_value_nochange(pVal) && p->pSavedRow ){
-          /* This is an UPDATE statement, and user-defined column (i-2) was not
-          ** modified.  Retrieve the value from Fts5Storage.pSavedRow.  */
-          pVal = sqlite3_column_value(p->pSavedRow, i-1);
-          if( pConfig->bLocale && bUnindexed==0 ){
-            sqlite3_bind_value(pInsert, pConfig->nCol + i,
-                sqlite3_column_value(p->pSavedRow, pConfig->nCol + i - 1)
-            );
-          }
-        }else if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
-          const char *pText = 0;
-          const char *pLoc = 0;
-          int nText = 0;
-          int nLoc = 0;
-          assert( pConfig->bLocale );
-
-          rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
-          if( rc==SQLITE_OK ){
-            sqlite3_bind_text(pInsert, i, pText, nText, SQLITE_TRANSIENT);
-            if( bUnindexed==0 ){
-              int iLoc = pConfig->nCol + i;
-              sqlite3_bind_text(pInsert, iLoc, pLoc, nLoc, SQLITE_TRANSIENT);
-            }
-          }
-
-          continue;
-        }
-
-        rc = sqlite3_bind_value(pInsert, i, pVal);
-      }
-    }
-    if( rc==SQLITE_OK ){
-      sqlite3_step(pInsert);
-      rc = sqlite3_reset(pInsert);
-    }
-    *piRowid = sqlite3_last_insert_rowid(pConfig->db);
-  }
-
-  return rc;
-}
-
-/*
-** Insert new entries into the FTS index and %_docsize table.
-*/
-static int sqlite3Fts5StorageIndexInsert(
-  Fts5Storage *p,
-  sqlite3_value **apVal,
-  i64 iRowid
-){
-  Fts5Config *pConfig = p->pConfig;
-  int rc = SQLITE_OK;             /* Return code */
-  Fts5InsertCtx ctx;              /* Tokenization callback context object */
-  Fts5Buffer buf;                 /* Buffer used to build up %_docsize blob */
-
-  memset(&buf, 0, sizeof(Fts5Buffer));
-  ctx.pStorage = p;
-  rc = fts5StorageLoadTotals(p, 1);
-
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5IndexBeginWrite(p->pIndex, 0, iRowid);
-  }
-  for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
-    ctx.szCol = 0;
-    if( pConfig->abUnindexed[ctx.iCol]==0 ){
-      int nText = 0;              /* Size of pText in bytes */
-      const char *pText = 0;      /* Pointer to buffer containing text value */
-      int nLoc = 0;               /* Size of pText in bytes */
-      const char *pLoc = 0;       /* Pointer to buffer containing text value */
-
-      sqlite3_value *pVal = apVal[ctx.iCol+2];
-      if( p->pSavedRow && sqlite3_value_nochange(pVal) ){
-        pVal = sqlite3_column_value(p->pSavedRow, ctx.iCol+1);
-        if( pConfig->eContent==FTS5_CONTENT_NORMAL && pConfig->bLocale ){
-          int iCol = ctx.iCol + 1 + pConfig->nCol;
-          pLoc = (const char*)sqlite3_column_text(p->pSavedRow, iCol);
-          nLoc = sqlite3_column_bytes(p->pSavedRow, iCol);
-        }
-      }else{
-        pVal = apVal[ctx.iCol+2];
-      }
-
-      if( pConfig->bLocale && sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
-        rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
-      }else{
-        pText = (const char*)sqlite3_value_text(pVal);
-        nText = sqlite3_value_bytes(pVal);
-      }
-
-      if( rc==SQLITE_OK ){
-        sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
-        rc = sqlite3Fts5Tokenize(pConfig,
-            FTS5_TOKENIZE_DOCUMENT, pText, nText, (void*)&ctx,
-            fts5StorageInsertCallback
-        );
-        sqlite3Fts5ClearLocale(pConfig);
-      }
-    }
-    sqlite3Fts5BufferAppendVarint(&rc, &buf, ctx.szCol);
-    p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
-  }
-  p->nTotalRow++;
-
-  /* Write the %_docsize record */
-  if( rc==SQLITE_OK ){
-    rc = fts5StorageInsertDocsize(p, iRowid, &buf);
-  }
-  sqlite3_free(buf.p);
-
-  return rc;
-}
-
-static int fts5StorageCount(Fts5Storage *p, const char *zSuffix, i64 *pnRow){
-  Fts5Config *pConfig = p->pConfig;
-  char *zSql;
-  int rc;
-
-  zSql = sqlite3_mprintf("SELECT count(*) FROM %Q.'%q_%s'",
-      pConfig->zDb, pConfig->zName, zSuffix
-  );
-  if( zSql==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    sqlite3_stmt *pCnt = 0;
-    rc = sqlite3_prepare_v2(pConfig->db, zSql, -1, &pCnt, 0);
-    if( rc==SQLITE_OK ){
-      if( SQLITE_ROW==sqlite3_step(pCnt) ){
-        *pnRow = sqlite3_column_int64(pCnt, 0);
-      }
-      rc = sqlite3_finalize(pCnt);
-    }
-  }
-
-  sqlite3_free(zSql);
-  return rc;
-}
-
-/*
-** Context object used by sqlite3Fts5StorageIntegrity().
-*/
-typedef struct Fts5IntegrityCtx Fts5IntegrityCtx;
-struct Fts5IntegrityCtx {
-  i64 iRowid;
-  int iCol;
-  int szCol;
-  u64 cksum;
-  Fts5Termset *pTermset;
-  Fts5Config *pConfig;
-};
-
-
-/*
-** Tokenization callback used by integrity check.
-*/
-static int fts5StorageIntegrityCallback(
-  void *pContext,                 /* Pointer to Fts5IntegrityCtx object */
-  int tflags,
-  const char *pToken,             /* Buffer containing token */
-  int nToken,                     /* Size of token in bytes */
-  int iUnused1,                   /* Start offset of token */
-  int iUnused2                    /* End offset of token */
-){
-  Fts5IntegrityCtx *pCtx = (Fts5IntegrityCtx*)pContext;
-  Fts5Termset *pTermset = pCtx->pTermset;
-  int bPresent;
-  int ii;
-  int rc = SQLITE_OK;
-  int iPos;
-  int iCol;
-
-  UNUSED_PARAM2(iUnused1, iUnused2);
-  if( nToken>FTS5_MAX_TOKEN_SIZE ) nToken = FTS5_MAX_TOKEN_SIZE;
-
-  if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
-    pCtx->szCol++;
-  }
-
-  switch( pCtx->pConfig->eDetail ){
-    case FTS5_DETAIL_FULL:
-      iPos = pCtx->szCol-1;
-      iCol = pCtx->iCol;
-      break;
-
-    case FTS5_DETAIL_COLUMNS:
-      iPos = pCtx->iCol;
-      iCol = 0;
-      break;
-
-    default:
-      assert( pCtx->pConfig->eDetail==FTS5_DETAIL_NONE );
-      iPos = 0;
-      iCol = 0;
-      break;
-  }
-
-  rc = sqlite3Fts5TermsetAdd(pTermset, 0, pToken, nToken, &bPresent);
-  if( rc==SQLITE_OK && bPresent==0 ){
-    pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
-        pCtx->iRowid, iCol, iPos, 0, pToken, nToken
-    );
-  }
-
-  for(ii=0; rc==SQLITE_OK && ii<pCtx->pConfig->nPrefix; ii++){
-    const int nChar = pCtx->pConfig->aPrefix[ii];
-    int nByte = sqlite3Fts5IndexCharlenToBytelen(pToken, nToken, nChar);
-    if( nByte ){
-      rc = sqlite3Fts5TermsetAdd(pTermset, ii+1, pToken, nByte, &bPresent);
-      if( bPresent==0 ){
-        pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
-            pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
-        );
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Check that the contents of the FTS index match that of the %_content
-** table. Return SQLITE_OK if they do, or SQLITE_CORRUPT if not. Return
-** some other SQLite error code if an error occurs while attempting to
-** determine this.
-*/
-static int sqlite3Fts5StorageIntegrity(Fts5Storage *p, int iArg){
-  Fts5Config *pConfig = p->pConfig;
-  int rc = SQLITE_OK;             /* Return code */
-  int *aColSize;                  /* Array of size pConfig->nCol */
-  i64 *aTotalSize;                /* Array of size pConfig->nCol */
-  Fts5IntegrityCtx ctx;
-  sqlite3_stmt *pScan;
-  int bUseCksum;
-
-  memset(&ctx, 0, sizeof(Fts5IntegrityCtx));
-  ctx.pConfig = p->pConfig;
-  aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64)));
-  if( !aTotalSize ) return SQLITE_NOMEM;
-  aColSize = (int*)&aTotalSize[pConfig->nCol];
-  memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
-
-  bUseCksum = (pConfig->eContent==FTS5_CONTENT_NORMAL
-           || (pConfig->eContent==FTS5_CONTENT_EXTERNAL && iArg)
-  );
-  if( bUseCksum ){
-    /* Generate the expected index checksum based on the contents of the
-    ** %_content table. This block stores the checksum in ctx.cksum. */
-    rc = fts5StorageGetStmt(p, FTS5_STMT_SCAN, &pScan, 0);
-    if( rc==SQLITE_OK ){
-      int rc2;
-      while( SQLITE_ROW==sqlite3_step(pScan) ){
-        int i;
-        ctx.iRowid = sqlite3_column_int64(pScan, 0);
-        ctx.szCol = 0;
-        if( pConfig->bColumnsize ){
-          rc = sqlite3Fts5StorageDocsize(p, ctx.iRowid, aColSize);
-        }
-        if( rc==SQLITE_OK && pConfig->eDetail==FTS5_DETAIL_NONE ){
-          rc = sqlite3Fts5TermsetNew(&ctx.pTermset);
-        }
-        for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
-          if( pConfig->abUnindexed[i]==0 ){
-            const char *pText = 0;
-            int nText = 0;
-            const char *pLoc = 0;
-            int nLoc = 0;
-            sqlite3_value *pVal = sqlite3_column_value(pScan, i+1);
-
-            if( pConfig->eContent==FTS5_CONTENT_EXTERNAL
-             && sqlite3Fts5IsLocaleValue(pConfig, pVal)
-            ){
-              rc = sqlite3Fts5DecodeLocaleValue(
-                  pVal, &pText, &nText, &pLoc, &nLoc
-              );
-            }else{
-              if( pConfig->eContent==FTS5_CONTENT_NORMAL && pConfig->bLocale ){
-                int iCol = i + 1 + pConfig->nCol;
-                pLoc = (const char*)sqlite3_column_text(pScan, iCol);
-                nLoc = sqlite3_column_bytes(pScan, iCol);
-              }
-              pText = (const char*)sqlite3_value_text(pVal);
-              nText = sqlite3_value_bytes(pVal);
-            }
-
-            ctx.iCol = i;
-            ctx.szCol = 0;
-
-            if( rc==SQLITE_OK && pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
-              rc = sqlite3Fts5TermsetNew(&ctx.pTermset);
-            }
-
-            if( rc==SQLITE_OK ){
-              sqlite3Fts5SetLocale(pConfig, pLoc, nLoc);
-              rc = sqlite3Fts5Tokenize(pConfig,
-                  FTS5_TOKENIZE_DOCUMENT,
-                  pText, nText,
-                  (void*)&ctx,
-                  fts5StorageIntegrityCallback
-              );
-              sqlite3Fts5ClearLocale(pConfig);
-            }
-
-            /* If this is not a columnsize=0 database, check that the number
-            ** of tokens in the value matches the aColSize[] value read from
-            ** the %_docsize table.  */
-            if( rc==SQLITE_OK
-             && pConfig->bColumnsize
-             && ctx.szCol!=aColSize[i]
-            ){
-              rc = FTS5_CORRUPT;
-            }
-            aTotalSize[i] += ctx.szCol;
-            if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
-              sqlite3Fts5TermsetFree(ctx.pTermset);
-              ctx.pTermset = 0;
-            }
-          }
-        }
-        sqlite3Fts5TermsetFree(ctx.pTermset);
-        ctx.pTermset = 0;
-
-        if( rc!=SQLITE_OK ) break;
-      }
-      rc2 = sqlite3_reset(pScan);
-      if( rc==SQLITE_OK ) rc = rc2;
-    }
-
-    /* Test that the "totals" (sometimes called "averages") record looks Ok */
-    if( rc==SQLITE_OK ){
-      int i;
-      rc = fts5StorageLoadTotals(p, 0);
-      for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
-        if( p->aTotalSize[i]!=aTotalSize[i] ) rc = FTS5_CORRUPT;
-      }
-    }
-
-    /* Check that the %_docsize and %_content tables contain the expected
-    ** number of rows.  */
-    if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){
-      i64 nRow = 0;
-      rc = fts5StorageCount(p, "content", &nRow);
-      if( rc==SQLITE_OK && nRow!=p->nTotalRow ) rc = FTS5_CORRUPT;
-    }
-    if( rc==SQLITE_OK && pConfig->bColumnsize ){
-      i64 nRow = 0;
-      rc = fts5StorageCount(p, "docsize", &nRow);
-      if( rc==SQLITE_OK && nRow!=p->nTotalRow ) rc = FTS5_CORRUPT;
-    }
-  }
-
-  /* Pass the expected checksum down to the FTS index module. It will
-  ** verify, amongst other things, that it matches the checksum generated by
-  ** inspecting the index itself.  */
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5IndexIntegrityCheck(p->pIndex, ctx.cksum, bUseCksum);
-  }
-
-  sqlite3_free(aTotalSize);
-  return rc;
-}
-
-/*
-** Obtain an SQLite statement handle that may be used to read data from the
-** %_content table.
-*/
-static int sqlite3Fts5StorageStmt(
-  Fts5Storage *p,
-  int eStmt,
-  sqlite3_stmt **pp,
-  char **pzErrMsg
-){
-  int rc;
-  assert( eStmt==FTS5_STMT_SCAN_ASC
-       || eStmt==FTS5_STMT_SCAN_DESC
-       || eStmt==FTS5_STMT_LOOKUP
-  );
-  rc = fts5StorageGetStmt(p, eStmt, pp, pzErrMsg);
-  if( rc==SQLITE_OK ){
-    assert( p->aStmt[eStmt]==*pp );
-    p->aStmt[eStmt] = 0;
-  }
-  return rc;
-}
-
-/*
-** Release an SQLite statement handle obtained via an earlier call to
-** sqlite3Fts5StorageStmt(). The eStmt parameter passed to this function
-** must match that passed to the sqlite3Fts5StorageStmt() call.
-*/
-static void sqlite3Fts5StorageStmtRelease(
-  Fts5Storage *p,
-  int eStmt,
-  sqlite3_stmt *pStmt
-){
-  assert( eStmt==FTS5_STMT_SCAN_ASC
-       || eStmt==FTS5_STMT_SCAN_DESC
-       || eStmt==FTS5_STMT_LOOKUP
-  );
-  if( p->aStmt[eStmt]==0 ){
-    sqlite3_reset(pStmt);
-    p->aStmt[eStmt] = pStmt;
-  }else{
-    sqlite3_finalize(pStmt);
-  }
-}
-
-static int fts5StorageDecodeSizeArray(
-  int *aCol, int nCol,            /* Array to populate */
-  const u8 *aBlob, int nBlob      /* Record to read varints from */
-){
-  int i;
-  int iOff = 0;
-  for(i=0; i<nCol; i++){
-    if( iOff>=nBlob ) return 1;
-    iOff += fts5GetVarint32(&aBlob[iOff], aCol[i]);
-  }
-  return (iOff!=nBlob);
-}
-
-/*
-** Argument aCol points to an array of integers containing one entry for
-** each table column. This function reads the %_docsize record for the
-** specified rowid and populates aCol[] with the results.
-**
-** An SQLite error code is returned if an error occurs, or SQLITE_OK
-** otherwise.
-*/
-static int sqlite3Fts5StorageDocsize(Fts5Storage *p, i64 iRowid, int *aCol){
-  int nCol = p->pConfig->nCol;    /* Number of user columns in table */
-  sqlite3_stmt *pLookup = 0;      /* Statement to query %_docsize */
-  int rc;                         /* Return Code */
-
-  assert( p->pConfig->bColumnsize );
-  rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP_DOCSIZE, &pLookup, 0);
-  if( pLookup ){
-    int bCorrupt = 1;
-    assert( rc==SQLITE_OK );
-    sqlite3_bind_int64(pLookup, 1, iRowid);
-    if( SQLITE_ROW==sqlite3_step(pLookup) ){
-      const u8 *aBlob = sqlite3_column_blob(pLookup, 0);
-      int nBlob = sqlite3_column_bytes(pLookup, 0);
-      if( 0==fts5StorageDecodeSizeArray(aCol, nCol, aBlob, nBlob) ){
-        bCorrupt = 0;
-      }
-    }
-    rc = sqlite3_reset(pLookup);
-    if( bCorrupt && rc==SQLITE_OK ){
-      rc = FTS5_CORRUPT;
-    }
-  }else{
-    assert( rc!=SQLITE_OK );
-  }
-
-  return rc;
-}
-
-static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnToken){
-  int rc = fts5StorageLoadTotals(p, 0);
-  if( rc==SQLITE_OK ){
-    *pnToken = 0;
-    if( iCol<0 ){
-      int i;
-      for(i=0; i<p->pConfig->nCol; i++){
-        *pnToken += p->aTotalSize[i];
-      }
-    }else if( iCol<p->pConfig->nCol ){
-      *pnToken = p->aTotalSize[iCol];
-    }else{
-      rc = SQLITE_RANGE;
-    }
-  }
-  return rc;
-}
-
-static int sqlite3Fts5StorageRowCount(Fts5Storage *p, i64 *pnRow){
-  int rc = fts5StorageLoadTotals(p, 0);
-  if( rc==SQLITE_OK ){
-    /* nTotalRow being zero does not necessarily indicate a corrupt
-    ** database - it might be that the FTS5 table really does contain zero
-    ** rows. However this function is only called from the xRowCount() API,
-    ** and there is no way for that API to be invoked if the table contains
-    ** no rows. Hence the FTS5_CORRUPT return.  */
-    *pnRow = p->nTotalRow;
-    if( p->nTotalRow<=0 ) rc = FTS5_CORRUPT;
-  }
-  return rc;
-}
-
-/*
-** Flush any data currently held in-memory to disk.
-*/
-static int sqlite3Fts5StorageSync(Fts5Storage *p){
-  int rc = SQLITE_OK;
-  i64 iLastRowid = sqlite3_last_insert_rowid(p->pConfig->db);
-  if( p->bTotalsValid ){
-    rc = fts5StorageSaveTotals(p);
-    if( rc==SQLITE_OK ){
-      p->bTotalsValid = 0;
-    }
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5IndexSync(p->pIndex);
-  }
-  sqlite3_set_last_insert_rowid(p->pConfig->db, iLastRowid);
-  return rc;
-}
-
-static int sqlite3Fts5StorageRollback(Fts5Storage *p){
-  p->bTotalsValid = 0;
-  return sqlite3Fts5IndexRollback(p->pIndex);
-}
-
-static int sqlite3Fts5StorageConfigValue(
-  Fts5Storage *p,
-  const char *z,
-  sqlite3_value *pVal,
-  int iVal
-){
-  sqlite3_stmt *pReplace = 0;
-  int rc = fts5StorageGetStmt(p, FTS5_STMT_REPLACE_CONFIG, &pReplace, 0);
-  if( rc==SQLITE_OK ){
-    sqlite3_bind_text(pReplace, 1, z, -1, SQLITE_STATIC);
-    if( pVal ){
-      sqlite3_bind_value(pReplace, 2, pVal);
-    }else{
-      sqlite3_bind_int(pReplace, 2, iVal);
-    }
-    sqlite3_step(pReplace);
-    rc = sqlite3_reset(pReplace);
-    sqlite3_bind_null(pReplace, 1);
-  }
-  if( rc==SQLITE_OK && pVal ){
-    int iNew = p->pConfig->iCookie + 1;
-    rc = sqlite3Fts5IndexSetCookie(p->pIndex, iNew);
-    if( rc==SQLITE_OK ){
-      p->pConfig->iCookie = iNew;
-    }
-  }
-  return rc;
-}
-
-/*
-** 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.
-**
-******************************************************************************
-*/
-
-
-/* #include "fts5Int.h" */
-
-/**************************************************************************
-** Start of ascii tokenizer implementation.
-*/
-
-/*
-** For tokenizers with no "unicode" modifier, the set of token characters
-** is the same as the set of ASCII range alphanumeric characters.
-*/
-static unsigned char aAsciiTokenChar[128] = {
-  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,   /* 0x00..0x0F */
-  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,   /* 0x10..0x1F */
-  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,   /* 0x20..0x2F */
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 0, 0, 0, 0, 0, 0,   /* 0x30..0x3F */
-  0, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   /* 0x40..0x4F */
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 0, 0, 0, 0, 0,   /* 0x50..0x5F */
-  0, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   /* 0x60..0x6F */
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 0, 0, 0, 0, 0,   /* 0x70..0x7F */
-};
-
-typedef struct AsciiTokenizer AsciiTokenizer;
-struct AsciiTokenizer {
-  unsigned char aTokenChar[128];
-};
-
-static void fts5AsciiAddExceptions(
-  AsciiTokenizer *p,
-  const char *zArg,
-  int bTokenChars
-){
-  int i;
-  for(i=0; zArg[i]; i++){
-    if( (zArg[i] & 0x80)==0 ){
-      p->aTokenChar[(int)zArg[i]] = (unsigned char)bTokenChars;
-    }
-  }
-}
-
-/*
-** Delete a "ascii" tokenizer.
-*/
-static void fts5AsciiDelete(Fts5Tokenizer *p){
-  sqlite3_free(p);
-}
-
-/*
-** Create an "ascii" tokenizer.
-*/
-static int fts5AsciiCreate(
-  void *pUnused,
-  const char **azArg, int nArg,
-  Fts5Tokenizer **ppOut
-){
-  int rc = SQLITE_OK;
-  AsciiTokenizer *p = 0;
-  UNUSED_PARAM(pUnused);
-  if( nArg%2 ){
-    rc = SQLITE_ERROR;
-  }else{
-    p = sqlite3_malloc64(sizeof(AsciiTokenizer));
-    if( p==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      int i;
-      memset(p, 0, sizeof(AsciiTokenizer));
-      memcpy(p->aTokenChar, aAsciiTokenChar, sizeof(aAsciiTokenChar));
-      for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
-        const char *zArg = azArg[i+1];
-        if( 0==sqlite3_stricmp(azArg[i], "tokenchars") ){
-          fts5AsciiAddExceptions(p, zArg, 1);
-        }else
-        if( 0==sqlite3_stricmp(azArg[i], "separators") ){
-          fts5AsciiAddExceptions(p, zArg, 0);
-        }else{
-          rc = SQLITE_ERROR;
-        }
-      }
-      if( rc!=SQLITE_OK ){
-        fts5AsciiDelete((Fts5Tokenizer*)p);
-        p = 0;
-      }
-    }
-  }
-
-  *ppOut = (Fts5Tokenizer*)p;
-  return rc;
-}
-
-
-static void asciiFold(char *aOut, const char *aIn, int nByte){
-  int i;
-  for(i=0; i<nByte; i++){
-    char c = aIn[i];
-    if( c>='A' && c<='Z' ) c += 32;
-    aOut[i] = c;
-  }
-}
-
-/*
-** Tokenize some text using the ascii tokenizer.
-*/
-static int fts5AsciiTokenize(
-  Fts5Tokenizer *pTokenizer,
-  void *pCtx,
-  int iUnused,
-  const char *pText, int nText,
-  int (*xToken)(void*, int, const char*, int nToken, int iStart, int iEnd)
-){
-  AsciiTokenizer *p = (AsciiTokenizer*)pTokenizer;
-  int rc = SQLITE_OK;
-  int ie;
-  int is = 0;
-
-  char aFold[64];
-  int nFold = sizeof(aFold);
-  char *pFold = aFold;
-  unsigned char *a = p->aTokenChar;
-
-  UNUSED_PARAM(iUnused);
-
-  while( is<nText && rc==SQLITE_OK ){
-    int nByte;
-
-    /* Skip any leading divider characters. */
-    while( is<nText && ((pText[is]&0x80)==0 && a[(int)pText[is]]==0) ){
-      is++;
-    }
-    if( is==nText ) break;
-
-    /* Count the token characters */
-    ie = is+1;
-    while( ie<nText && ((pText[ie]&0x80) || a[(int)pText[ie]] ) ){
-      ie++;
-    }
-
-    /* Fold to lower case */
-    nByte = ie-is;
-    if( nByte>nFold ){
-      if( pFold!=aFold ) sqlite3_free(pFold);
-      pFold = sqlite3_malloc64((sqlite3_int64)nByte*2);
-      if( pFold==0 ){
-        rc = SQLITE_NOMEM;
-        break;
-      }
-      nFold = nByte*2;
-    }
-    asciiFold(pFold, &pText[is], nByte);
-
-    /* Invoke the token callback */
-    rc = xToken(pCtx, 0, pFold, nByte, is, ie);
-    is = ie+1;
-  }
-
-  if( pFold!=aFold ) sqlite3_free(pFold);
-  if( rc==SQLITE_DONE ) rc = SQLITE_OK;
-  return rc;
-}
-
-/**************************************************************************
-** Start of unicode61 tokenizer implementation.
-*/
-
-
-/*
-** 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++ = (unsigned char)(c&0xFF);                 \
-  }                                                    \
-  else if( c<0x00800 ){                                \
-    *zOut++ = 0xC0 + (unsigned char)((c>>6)&0x1F);     \
-    *zOut++ = 0x80 + (unsigned char)(c & 0x3F);        \
-  }                                                    \
-  else if( c<0x10000 ){                                \
-    *zOut++ = 0xE0 + (unsigned char)((c>>12)&0x0F);    \
-    *zOut++ = 0x80 + (unsigned char)((c>>6) & 0x3F);   \
-    *zOut++ = 0x80 + (unsigned char)(c & 0x3F);        \
-  }else{                                               \
-    *zOut++ = 0xF0 + (unsigned char)((c>>18) & 0x07);  \
-    *zOut++ = 0x80 + (unsigned char)((c>>12) & 0x3F);  \
-    *zOut++ = 0x80 + (unsigned char)((c>>6) & 0x3F);   \
-    *zOut++ = 0x80 + (unsigned char)(c & 0x3F);        \
-  }                                                    \
-}
-
-#endif /* ifndef SQLITE_AMALGAMATION */
-
-#define FTS5_SKIP_UTF8(zIn) {                               \
-  if( ((unsigned char)(*(zIn++)))>=0xc0 ){                              \
-    while( (((unsigned char)*zIn) & 0xc0)==0x80 ){ zIn++; }             \
-  }                                                    \
-}
-
-typedef struct Unicode61Tokenizer Unicode61Tokenizer;
-struct Unicode61Tokenizer {
-  unsigned char aTokenChar[128];  /* ASCII range token characters */
-  char *aFold;                    /* Buffer to fold text into */
-  int nFold;                      /* Size of aFold[] in bytes */
-  int eRemoveDiacritic;           /* True if remove_diacritics=1 is set */
-  int nException;
-  int *aiException;
-
-  unsigned char aCategory[32];    /* True for token char categories */
-};
-
-/* Values for eRemoveDiacritic (must match internals of fts5_unicode2.c) */
-#define FTS5_REMOVE_DIACRITICS_NONE    0
-#define FTS5_REMOVE_DIACRITICS_SIMPLE  1
-#define FTS5_REMOVE_DIACRITICS_COMPLEX 2
-
-static int fts5UnicodeAddExceptions(
-  Unicode61Tokenizer *p,          /* Tokenizer object */
-  const char *z,                  /* Characters to treat as exceptions */
-  int bTokenChars                 /* 1 for 'tokenchars', 0 for 'separators' */
-){
-  int rc = SQLITE_OK;
-  int n = (int)strlen(z);
-  int *aNew;
-
-  if( n>0 ){
-    aNew = (int*)sqlite3_realloc64(p->aiException,
-                                   (n+p->nException)*sizeof(int));
-    if( aNew ){
-      int nNew = p->nException;
-      const unsigned char *zCsr = (const unsigned char*)z;
-      const unsigned char *zTerm = (const unsigned char*)&z[n];
-      while( zCsr<zTerm ){
-        u32 iCode;
-        int bToken;
-        READ_UTF8(zCsr, zTerm, iCode);
-        if( iCode<128 ){
-          p->aTokenChar[iCode] = (unsigned char)bTokenChars;
-        }else{
-          bToken = p->aCategory[sqlite3Fts5UnicodeCategory(iCode)];
-          assert( (bToken==0 || bToken==1) );
-          assert( (bTokenChars==0 || bTokenChars==1) );
-          if( bToken!=bTokenChars && sqlite3Fts5UnicodeIsdiacritic(iCode)==0 ){
-            int i;
-            for(i=0; i<nNew; i++){
-              if( (u32)aNew[i]>iCode ) break;
-            }
-            memmove(&aNew[i+1], &aNew[i], (nNew-i)*sizeof(int));
-            aNew[i] = iCode;
-            nNew++;
-          }
-        }
-      }
-      p->aiException = aNew;
-      p->nException = nNew;
-    }else{
-      rc = SQLITE_NOMEM;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Return true if the p->aiException[] array contains the value iCode.
-*/
-static int fts5UnicodeIsException(Unicode61Tokenizer *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;
-}
-
-/*
-** Delete a "unicode61" tokenizer.
-*/
-static void fts5UnicodeDelete(Fts5Tokenizer *pTok){
-  if( pTok ){
-    Unicode61Tokenizer *p = (Unicode61Tokenizer*)pTok;
-    sqlite3_free(p->aiException);
-    sqlite3_free(p->aFold);
-    sqlite3_free(p);
-  }
-  return;
-}
-
-static int unicodeSetCategories(Unicode61Tokenizer *p, const char *zCat){
-  const char *z = zCat;
-
-  while( *z ){
-    while( *z==' ' || *z=='\t' ) z++;
-    if( *z && sqlite3Fts5UnicodeCatParse(z, p->aCategory) ){
-      return SQLITE_ERROR;
-    }
-    while( *z!=' ' && *z!='\t' && *z!='\0' ) z++;
-  }
-
-  sqlite3Fts5UnicodeAscii(p->aCategory, p->aTokenChar);
-  return SQLITE_OK;
-}
-
-/*
-** Create a "unicode61" tokenizer.
-*/
-static int fts5UnicodeCreate(
-  void *pUnused,
-  const char **azArg, int nArg,
-  Fts5Tokenizer **ppOut
-){
-  int rc = SQLITE_OK;             /* Return code */
-  Unicode61Tokenizer *p = 0;      /* New tokenizer object */
-
-  UNUSED_PARAM(pUnused);
-
-  if( nArg%2 ){
-    rc = SQLITE_ERROR;
-  }else{
-    p = (Unicode61Tokenizer*)sqlite3_malloc64(sizeof(Unicode61Tokenizer));
-    if( p ){
-      const char *zCat = "L* N* Co";
-      int i;
-      memset(p, 0, sizeof(Unicode61Tokenizer));
-
-      p->eRemoveDiacritic = FTS5_REMOVE_DIACRITICS_SIMPLE;
-      p->nFold = 64;
-      p->aFold = sqlite3_malloc64(p->nFold * sizeof(char));
-      if( p->aFold==0 ){
-        rc = SQLITE_NOMEM;
-      }
-
-      /* Search for a "categories" argument */
-      for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
-        if( 0==sqlite3_stricmp(azArg[i], "categories") ){
-          zCat = azArg[i+1];
-        }
-      }
-      if( rc==SQLITE_OK ){
-        rc = unicodeSetCategories(p, zCat);
-      }
-
-      for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
-        const char *zArg = azArg[i+1];
-        if( 0==sqlite3_stricmp(azArg[i], "remove_diacritics") ){
-          if( (zArg[0]!='0' && zArg[0]!='1' && zArg[0]!='2') || zArg[1] ){
-            rc = SQLITE_ERROR;
-          }else{
-            p->eRemoveDiacritic = (zArg[0] - '0');
-            assert( p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_NONE
-                 || p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_SIMPLE
-                 || p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_COMPLEX
-            );
-          }
-        }else
-        if( 0==sqlite3_stricmp(azArg[i], "tokenchars") ){
-          rc = fts5UnicodeAddExceptions(p, zArg, 1);
-        }else
-        if( 0==sqlite3_stricmp(azArg[i], "separators") ){
-          rc = fts5UnicodeAddExceptions(p, zArg, 0);
-        }else
-        if( 0==sqlite3_stricmp(azArg[i], "categories") ){
-          /* no-op */
-        }else{
-          rc = SQLITE_ERROR;
-        }
-      }
-    }else{
-      rc = SQLITE_NOMEM;
-    }
-    if( rc!=SQLITE_OK ){
-      fts5UnicodeDelete((Fts5Tokenizer*)p);
-      p = 0;
-    }
-    *ppOut = (Fts5Tokenizer*)p;
-  }
-  return rc;
-}
-
-/*
-** Return true if, for the purposes of tokenizing with the tokenizer
-** passed as the first argument, codepoint iCode is considered a token
-** character (not a separator).
-*/
-static int fts5UnicodeIsAlnum(Unicode61Tokenizer *p, int iCode){
-  return (
-    p->aCategory[sqlite3Fts5UnicodeCategory((u32)iCode)]
-    ^ fts5UnicodeIsException(p, iCode)
-  );
-}
-
-static int fts5UnicodeTokenize(
-  Fts5Tokenizer *pTokenizer,
-  void *pCtx,
-  int iUnused,
-  const char *pText, int nText,
-  int (*xToken)(void*, int, const char*, int nToken, int iStart, int iEnd)
-){
-  Unicode61Tokenizer *p = (Unicode61Tokenizer*)pTokenizer;
-  int rc = SQLITE_OK;
-  unsigned char *a = p->aTokenChar;
-
-  unsigned char *zTerm = (unsigned char*)&pText[nText];
-  unsigned char *zCsr = (unsigned char *)pText;
-
-  /* Output buffer */
-  char *aFold = p->aFold;
-  int nFold = p->nFold;
-  const char *pEnd = &aFold[nFold-6];
-
-  UNUSED_PARAM(iUnused);
-
-  /* Each iteration of this loop gobbles up a contiguous run of separators,
-  ** then the next token.  */
-  while( rc==SQLITE_OK ){
-    u32 iCode;                    /* non-ASCII codepoint read from input */
-    char *zOut = aFold;
-    int is;
-    int ie;
-
-    /* Skip any separator characters. */
-    while( 1 ){
-      if( zCsr>=zTerm ) goto tokenize_done;
-      if( *zCsr & 0x80 ) {
-        /* A character outside of the ascii range. Skip past it if it is
-        ** a separator character. Or break out of the loop if it is not. */
-        is = zCsr - (unsigned char*)pText;
-        READ_UTF8(zCsr, zTerm, iCode);
-        if( fts5UnicodeIsAlnum(p, iCode) ){
-          goto non_ascii_tokenchar;
-        }
-      }else{
-        if( a[*zCsr] ){
-          is = zCsr - (unsigned char*)pText;
-          goto ascii_tokenchar;
-        }
-        zCsr++;
-      }
-    }
-
-    /* Run through the tokenchars. Fold them into the output buffer along
-    ** the way.  */
-    while( zCsr<zTerm ){
-
-      /* Grow the output buffer so that there is sufficient space to fit the
-      ** largest possible utf-8 character.  */
-      if( zOut>pEnd ){
-        aFold = sqlite3_malloc64((sqlite3_int64)nFold*2);
-        if( aFold==0 ){
-          rc = SQLITE_NOMEM;
-          goto tokenize_done;
-        }
-        zOut = &aFold[zOut - p->aFold];
-        memcpy(aFold, p->aFold, nFold);
-        sqlite3_free(p->aFold);
-        p->aFold = aFold;
-        p->nFold = nFold = nFold*2;
-        pEnd = &aFold[nFold-6];
-      }
-
-      if( *zCsr & 0x80 ){
-        /* An non-ascii-range character. Fold it into the output buffer if
-        ** it is a token character, or break out of the loop if it is not. */
-        READ_UTF8(zCsr, zTerm, iCode);
-        if( fts5UnicodeIsAlnum(p,iCode)||sqlite3Fts5UnicodeIsdiacritic(iCode) ){
- non_ascii_tokenchar:
-          iCode = sqlite3Fts5UnicodeFold(iCode, p->eRemoveDiacritic);
-          if( iCode ) WRITE_UTF8(zOut, iCode);
-        }else{
-          break;
-        }
-      }else if( a[*zCsr]==0 ){
-        /* An ascii-range separator character. End of token. */
-        break;
-      }else{
- ascii_tokenchar:
-        if( *zCsr>='A' && *zCsr<='Z' ){
-          *zOut++ = *zCsr + 32;
-        }else{
-          *zOut++ = *zCsr;
-        }
-        zCsr++;
-      }
-      ie = zCsr - (unsigned char*)pText;
-    }
-
-    /* Invoke the token callback */
-    rc = xToken(pCtx, 0, aFold, zOut-aFold, is, ie);
-  }
-
- tokenize_done:
-  if( rc==SQLITE_DONE ) rc = SQLITE_OK;
-  return rc;
-}
-
-/**************************************************************************
-** Start of porter stemmer implementation.
-*/
-
-/* Any tokens larger than this (in bytes) are passed through without
-** stemming. */
-#define FTS5_PORTER_MAX_TOKEN 64
-
-typedef struct PorterTokenizer PorterTokenizer;
-struct PorterTokenizer {
-  fts5_tokenizer_v2 tokenizer_v2; /* Parent tokenizer module */
-  Fts5Tokenizer *pTokenizer;      /* Parent tokenizer instance */
-  char aBuf[FTS5_PORTER_MAX_TOKEN + 64];
-};
-
-/*
-** Delete a "porter" tokenizer.
-*/
-static void fts5PorterDelete(Fts5Tokenizer *pTok){
-  if( pTok ){
-    PorterTokenizer *p = (PorterTokenizer*)pTok;
-    if( p->pTokenizer ){
-      p->tokenizer_v2.xDelete(p->pTokenizer);
-    }
-    sqlite3_free(p);
-  }
-}
-
-/*
-** Create a "porter" tokenizer.
-*/
-static int fts5PorterCreate(
-  void *pCtx,
-  const char **azArg, int nArg,
-  Fts5Tokenizer **ppOut
-){
-  fts5_api *pApi = (fts5_api*)pCtx;
-  int rc = SQLITE_OK;
-  PorterTokenizer *pRet;
-  void *pUserdata = 0;
-  const char *zBase = "unicode61";
-  fts5_tokenizer_v2 *pV2 = 0;
-
-  if( nArg>0 ){
-    zBase = azArg[0];
-  }
-
-  pRet = (PorterTokenizer*)sqlite3_malloc64(sizeof(PorterTokenizer));
-  if( pRet ){
-    memset(pRet, 0, sizeof(PorterTokenizer));
-    rc = pApi->xFindTokenizer_v2(pApi, zBase, &pUserdata, &pV2);
-  }else{
-    rc = SQLITE_NOMEM;
-  }
-  if( rc==SQLITE_OK ){
-    int nArg2 = (nArg>0 ? nArg-1 : 0);
-    const char **az2 = (nArg2 ? &azArg[1] : 0);
-    memcpy(&pRet->tokenizer_v2, pV2, sizeof(fts5_tokenizer_v2));
-    rc = pRet->tokenizer_v2.xCreate(pUserdata, az2, nArg2, &pRet->pTokenizer);
-  }
-
-  if( rc!=SQLITE_OK ){
-    fts5PorterDelete((Fts5Tokenizer*)pRet);
-    pRet = 0;
-  }
-  *ppOut = (Fts5Tokenizer*)pRet;
-  return rc;
-}
-
-typedef struct PorterContext PorterContext;
-struct PorterContext {
-  void *pCtx;
-  int (*xToken)(void*, int, const char*, int, int, int);
-  char *aBuf;
-};
-
-typedef struct PorterRule PorterRule;
-struct PorterRule {
-  const char *zSuffix;
-  int nSuffix;
-  int (*xCond)(char *zStem, int nStem);
-  const char *zOutput;
-  int nOutput;
-};
-
-#if 0
-static int fts5PorterApply(char *aBuf, int *pnBuf, PorterRule *aRule){
-  int ret = -1;
-  int nBuf = *pnBuf;
-  PorterRule *p;
-
-  for(p=aRule; p->zSuffix; p++){
-    assert( strlen(p->zSuffix)==p->nSuffix );
-    assert( strlen(p->zOutput)==p->nOutput );
-    if( nBuf<p->nSuffix ) continue;
-    if( 0==memcmp(&aBuf[nBuf - p->nSuffix], p->zSuffix, p->nSuffix) ) break;
-  }
-
-  if( p->zSuffix ){
-    int nStem = nBuf - p->nSuffix;
-    if( p->xCond==0 || p->xCond(aBuf, nStem) ){
-      memcpy(&aBuf[nStem], p->zOutput, p->nOutput);
-      *pnBuf = nStem + p->nOutput;
-      ret = p - aRule;
-    }
-  }
-
-  return ret;
-}
-#endif
-
-static int fts5PorterIsVowel(char c, int bYIsVowel){
-  return (
-      c=='a' || c=='e' || c=='i' || c=='o' || c=='u' || (bYIsVowel && c=='y')
-  );
-}
-
-static int fts5PorterGobbleVC(char *zStem, int nStem, int bPrevCons){
-  int i;
-  int bCons = bPrevCons;
-
-  /* Scan for a vowel */
-  for(i=0; i<nStem; i++){
-    if( 0==(bCons = !fts5PorterIsVowel(zStem[i], bCons)) ) break;
-  }
-
-  /* Scan for a consonent */
-  for(i++; i<nStem; i++){
-    if( (bCons = !fts5PorterIsVowel(zStem[i], bCons)) ) return i+1;
-  }
-  return 0;
-}
-
-/* porter rule condition: (m > 0) */
-static int fts5Porter_MGt0(char *zStem, int nStem){
-  return !!fts5PorterGobbleVC(zStem, nStem, 0);
-}
-
-/* porter rule condition: (m > 1) */
-static int fts5Porter_MGt1(char *zStem, int nStem){
-  int n;
-  n = fts5PorterGobbleVC(zStem, nStem, 0);
-  if( n && fts5PorterGobbleVC(&zStem[n], nStem-n, 1) ){
-    return 1;
-  }
-  return 0;
-}
-
-/* porter rule condition: (m = 1) */
-static int fts5Porter_MEq1(char *zStem, int nStem){
-  int n;
-  n = fts5PorterGobbleVC(zStem, nStem, 0);
-  if( n && 0==fts5PorterGobbleVC(&zStem[n], nStem-n, 1) ){
-    return 1;
-  }
-  return 0;
-}
-
-/* porter rule condition: (*o) */
-static int fts5Porter_Ostar(char *zStem, int nStem){
-  if( zStem[nStem-1]=='w' || zStem[nStem-1]=='x' || zStem[nStem-1]=='y' ){
-    return 0;
-  }else{
-    int i;
-    int mask = 0;
-    int bCons = 0;
-    for(i=0; i<nStem; i++){
-      bCons = !fts5PorterIsVowel(zStem[i], bCons);
-      assert( bCons==0 || bCons==1 );
-      mask = (mask << 1) + bCons;
-    }
-    return ((mask & 0x0007)==0x0005);
-  }
-}
-
-/* porter rule condition: (m > 1 and (*S or *T)) */
-static int fts5Porter_MGt1_and_S_or_T(char *zStem, int nStem){
-  assert( nStem>0 );
-  return (zStem[nStem-1]=='s' || zStem[nStem-1]=='t')
-      && fts5Porter_MGt1(zStem, nStem);
-}
-
-/* porter rule condition: (*v*) */
-static int fts5Porter_Vowel(char *zStem, int nStem){
-  int i;
-  for(i=0; i<nStem; i++){
-    if( fts5PorterIsVowel(zStem[i], i>0) ){
-      return 1;
-    }
-  }
-  return 0;
-}
-
-
-/**************************************************************************
-***************************************************************************
-** GENERATED CODE STARTS HERE (mkportersteps.tcl)
-*/
-
-static int fts5PorterStep4(char *aBuf, int *pnBuf){
-  int ret = 0;
-  int nBuf = *pnBuf;
-  switch( aBuf[nBuf-2] ){
-
-    case 'a':
-      if( nBuf>2 && 0==memcmp("al", &aBuf[nBuf-2], 2) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-2) ){
-          *pnBuf = nBuf - 2;
-        }
-      }
-      break;
-
-    case 'c':
-      if( nBuf>4 && 0==memcmp("ance", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-4) ){
-          *pnBuf = nBuf - 4;
-        }
-      }else if( nBuf>4 && 0==memcmp("ence", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-4) ){
-          *pnBuf = nBuf - 4;
-        }
-      }
-      break;
-
-    case 'e':
-      if( nBuf>2 && 0==memcmp("er", &aBuf[nBuf-2], 2) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-2) ){
-          *pnBuf = nBuf - 2;
-        }
-      }
-      break;
-
-    case 'i':
-      if( nBuf>2 && 0==memcmp("ic", &aBuf[nBuf-2], 2) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-2) ){
-          *pnBuf = nBuf - 2;
-        }
-      }
-      break;
-
-    case 'l':
-      if( nBuf>4 && 0==memcmp("able", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-4) ){
-          *pnBuf = nBuf - 4;
-        }
-      }else if( nBuf>4 && 0==memcmp("ible", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-4) ){
-          *pnBuf = nBuf - 4;
-        }
-      }
-      break;
-
-    case 'n':
-      if( nBuf>3 && 0==memcmp("ant", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }else if( nBuf>5 && 0==memcmp("ement", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-5) ){
-          *pnBuf = nBuf - 5;
-        }
-      }else if( nBuf>4 && 0==memcmp("ment", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-4) ){
-          *pnBuf = nBuf - 4;
-        }
-      }else if( nBuf>3 && 0==memcmp("ent", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }
-      break;
-
-    case 'o':
-      if( nBuf>3 && 0==memcmp("ion", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt1_and_S_or_T(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }else if( nBuf>2 && 0==memcmp("ou", &aBuf[nBuf-2], 2) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-2) ){
-          *pnBuf = nBuf - 2;
-        }
-      }
-      break;
-
-    case 's':
-      if( nBuf>3 && 0==memcmp("ism", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }
-      break;
-
-    case 't':
-      if( nBuf>3 && 0==memcmp("ate", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }else if( nBuf>3 && 0==memcmp("iti", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }
-      break;
-
-    case 'u':
-      if( nBuf>3 && 0==memcmp("ous", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }
-      break;
-
-    case 'v':
-      if( nBuf>3 && 0==memcmp("ive", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }
-      break;
-
-    case 'z':
-      if( nBuf>3 && 0==memcmp("ize", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt1(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }
-      break;
-
-  }
-  return ret;
-}
-
-
-static int fts5PorterStep1B2(char *aBuf, int *pnBuf){
-  int ret = 0;
-  int nBuf = *pnBuf;
-  switch( aBuf[nBuf-2] ){
-
-    case 'a':
-      if( nBuf>2 && 0==memcmp("at", &aBuf[nBuf-2], 2) ){
-        memcpy(&aBuf[nBuf-2], "ate", 3);
-        *pnBuf = nBuf - 2 + 3;
-        ret = 1;
-      }
-      break;
-
-    case 'b':
-      if( nBuf>2 && 0==memcmp("bl", &aBuf[nBuf-2], 2) ){
-        memcpy(&aBuf[nBuf-2], "ble", 3);
-        *pnBuf = nBuf - 2 + 3;
-        ret = 1;
-      }
-      break;
-
-    case 'i':
-      if( nBuf>2 && 0==memcmp("iz", &aBuf[nBuf-2], 2) ){
-        memcpy(&aBuf[nBuf-2], "ize", 3);
-        *pnBuf = nBuf - 2 + 3;
-        ret = 1;
-      }
-      break;
-
-  }
-  return ret;
-}
-
-
-static int fts5PorterStep2(char *aBuf, int *pnBuf){
-  int ret = 0;
-  int nBuf = *pnBuf;
-  switch( aBuf[nBuf-2] ){
-
-    case 'a':
-      if( nBuf>7 && 0==memcmp("ational", &aBuf[nBuf-7], 7) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-7) ){
-          memcpy(&aBuf[nBuf-7], "ate", 3);
-          *pnBuf = nBuf - 7 + 3;
-        }
-      }else if( nBuf>6 && 0==memcmp("tional", &aBuf[nBuf-6], 6) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-6) ){
-          memcpy(&aBuf[nBuf-6], "tion", 4);
-          *pnBuf = nBuf - 6 + 4;
-        }
-      }
-      break;
-
-    case 'c':
-      if( nBuf>4 && 0==memcmp("enci", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-4) ){
-          memcpy(&aBuf[nBuf-4], "ence", 4);
-          *pnBuf = nBuf - 4 + 4;
-        }
-      }else if( nBuf>4 && 0==memcmp("anci", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-4) ){
-          memcpy(&aBuf[nBuf-4], "ance", 4);
-          *pnBuf = nBuf - 4 + 4;
-        }
-      }
-      break;
-
-    case 'e':
-      if( nBuf>4 && 0==memcmp("izer", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-4) ){
-          memcpy(&aBuf[nBuf-4], "ize", 3);
-          *pnBuf = nBuf - 4 + 3;
-        }
-      }
-      break;
-
-    case 'g':
-      if( nBuf>4 && 0==memcmp("logi", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-4) ){
-          memcpy(&aBuf[nBuf-4], "log", 3);
-          *pnBuf = nBuf - 4 + 3;
-        }
-      }
-      break;
-
-    case 'l':
-      if( nBuf>3 && 0==memcmp("bli", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-3) ){
-          memcpy(&aBuf[nBuf-3], "ble", 3);
-          *pnBuf = nBuf - 3 + 3;
-        }
-      }else if( nBuf>4 && 0==memcmp("alli", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-4) ){
-          memcpy(&aBuf[nBuf-4], "al", 2);
-          *pnBuf = nBuf - 4 + 2;
-        }
-      }else if( nBuf>5 && 0==memcmp("entli", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          memcpy(&aBuf[nBuf-5], "ent", 3);
-          *pnBuf = nBuf - 5 + 3;
-        }
-      }else if( nBuf>3 && 0==memcmp("eli", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-3) ){
-          memcpy(&aBuf[nBuf-3], "e", 1);
-          *pnBuf = nBuf - 3 + 1;
-        }
-      }else if( nBuf>5 && 0==memcmp("ousli", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          memcpy(&aBuf[nBuf-5], "ous", 3);
-          *pnBuf = nBuf - 5 + 3;
-        }
-      }
-      break;
-
-    case 'o':
-      if( nBuf>7 && 0==memcmp("ization", &aBuf[nBuf-7], 7) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-7) ){
-          memcpy(&aBuf[nBuf-7], "ize", 3);
-          *pnBuf = nBuf - 7 + 3;
-        }
-      }else if( nBuf>5 && 0==memcmp("ation", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          memcpy(&aBuf[nBuf-5], "ate", 3);
-          *pnBuf = nBuf - 5 + 3;
-        }
-      }else if( nBuf>4 && 0==memcmp("ator", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-4) ){
-          memcpy(&aBuf[nBuf-4], "ate", 3);
-          *pnBuf = nBuf - 4 + 3;
-        }
-      }
-      break;
-
-    case 's':
-      if( nBuf>5 && 0==memcmp("alism", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          memcpy(&aBuf[nBuf-5], "al", 2);
-          *pnBuf = nBuf - 5 + 2;
-        }
-      }else if( nBuf>7 && 0==memcmp("iveness", &aBuf[nBuf-7], 7) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-7) ){
-          memcpy(&aBuf[nBuf-7], "ive", 3);
-          *pnBuf = nBuf - 7 + 3;
-        }
-      }else if( nBuf>7 && 0==memcmp("fulness", &aBuf[nBuf-7], 7) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-7) ){
-          memcpy(&aBuf[nBuf-7], "ful", 3);
-          *pnBuf = nBuf - 7 + 3;
-        }
-      }else if( nBuf>7 && 0==memcmp("ousness", &aBuf[nBuf-7], 7) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-7) ){
-          memcpy(&aBuf[nBuf-7], "ous", 3);
-          *pnBuf = nBuf - 7 + 3;
-        }
-      }
-      break;
-
-    case 't':
-      if( nBuf>5 && 0==memcmp("aliti", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          memcpy(&aBuf[nBuf-5], "al", 2);
-          *pnBuf = nBuf - 5 + 2;
-        }
-      }else if( nBuf>5 && 0==memcmp("iviti", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          memcpy(&aBuf[nBuf-5], "ive", 3);
-          *pnBuf = nBuf - 5 + 3;
-        }
-      }else if( nBuf>6 && 0==memcmp("biliti", &aBuf[nBuf-6], 6) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-6) ){
-          memcpy(&aBuf[nBuf-6], "ble", 3);
-          *pnBuf = nBuf - 6 + 3;
-        }
-      }
-      break;
-
-  }
-  return ret;
-}
-
-
-static int fts5PorterStep3(char *aBuf, int *pnBuf){
-  int ret = 0;
-  int nBuf = *pnBuf;
-  switch( aBuf[nBuf-2] ){
-
-    case 'a':
-      if( nBuf>4 && 0==memcmp("ical", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-4) ){
-          memcpy(&aBuf[nBuf-4], "ic", 2);
-          *pnBuf = nBuf - 4 + 2;
-        }
-      }
-      break;
-
-    case 's':
-      if( nBuf>4 && 0==memcmp("ness", &aBuf[nBuf-4], 4) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-4) ){
-          *pnBuf = nBuf - 4;
-        }
-      }
-      break;
-
-    case 't':
-      if( nBuf>5 && 0==memcmp("icate", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          memcpy(&aBuf[nBuf-5], "ic", 2);
-          *pnBuf = nBuf - 5 + 2;
-        }
-      }else if( nBuf>5 && 0==memcmp("iciti", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          memcpy(&aBuf[nBuf-5], "ic", 2);
-          *pnBuf = nBuf - 5 + 2;
-        }
-      }
-      break;
-
-    case 'u':
-      if( nBuf>3 && 0==memcmp("ful", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-        }
-      }
-      break;
-
-    case 'v':
-      if( nBuf>5 && 0==memcmp("ative", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          *pnBuf = nBuf - 5;
-        }
-      }
-      break;
-
-    case 'z':
-      if( nBuf>5 && 0==memcmp("alize", &aBuf[nBuf-5], 5) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-5) ){
-          memcpy(&aBuf[nBuf-5], "al", 2);
-          *pnBuf = nBuf - 5 + 2;
-        }
-      }
-      break;
-
-  }
-  return ret;
-}
-
-
-static int fts5PorterStep1B(char *aBuf, int *pnBuf){
-  int ret = 0;
-  int nBuf = *pnBuf;
-  switch( aBuf[nBuf-2] ){
-
-    case 'e':
-      if( nBuf>3 && 0==memcmp("eed", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_MGt0(aBuf, nBuf-3) ){
-          memcpy(&aBuf[nBuf-3], "ee", 2);
-          *pnBuf = nBuf - 3 + 2;
-        }
-      }else if( nBuf>2 && 0==memcmp("ed", &aBuf[nBuf-2], 2) ){
-        if( fts5Porter_Vowel(aBuf, nBuf-2) ){
-          *pnBuf = nBuf - 2;
-          ret = 1;
-        }
-      }
-      break;
-
-    case 'n':
-      if( nBuf>3 && 0==memcmp("ing", &aBuf[nBuf-3], 3) ){
-        if( fts5Porter_Vowel(aBuf, nBuf-3) ){
-          *pnBuf = nBuf - 3;
-          ret = 1;
-        }
-      }
-      break;
-
-  }
-  return ret;
-}
-
-/*
-** GENERATED CODE ENDS HERE (mkportersteps.tcl)
-***************************************************************************
-**************************************************************************/
-
-static void fts5PorterStep1A(char *aBuf, int *pnBuf){
-  int nBuf = *pnBuf;
-  if( aBuf[nBuf-1]=='s' ){
-    if( aBuf[nBuf-2]=='e' ){
-      if( (nBuf>4 && aBuf[nBuf-4]=='s' && aBuf[nBuf-3]=='s')
-       || (nBuf>3 && aBuf[nBuf-3]=='i' )
-      ){
-        *pnBuf = nBuf-2;
-      }else{
-        *pnBuf = nBuf-1;
-      }
-    }
-    else if( aBuf[nBuf-2]!='s' ){
-      *pnBuf = nBuf-1;
-    }
-  }
-}
-
-static int fts5PorterCb(
-  void *pCtx,
-  int tflags,
-  const char *pToken,
-  int nToken,
-  int iStart,
-  int iEnd
-){
-  PorterContext *p = (PorterContext*)pCtx;
-
-  char *aBuf;
-  int nBuf;
-
-  if( nToken>FTS5_PORTER_MAX_TOKEN || nToken<3 ) goto pass_through;
-  aBuf = p->aBuf;
-  nBuf = nToken;
-  memcpy(aBuf, pToken, nBuf);
-
-  /* Step 1. */
-  fts5PorterStep1A(aBuf, &nBuf);
-  if( fts5PorterStep1B(aBuf, &nBuf) ){
-    if( fts5PorterStep1B2(aBuf, &nBuf)==0 ){
-      char c = aBuf[nBuf-1];
-      if( fts5PorterIsVowel(c, 0)==0
-       && c!='l' && c!='s' && c!='z' && c==aBuf[nBuf-2]
-      ){
-        nBuf--;
-      }else if( fts5Porter_MEq1(aBuf, nBuf) && fts5Porter_Ostar(aBuf, nBuf) ){
-        aBuf[nBuf++] = 'e';
-      }
-    }
-  }
-
-  /* Step 1C. */
-  if( aBuf[nBuf-1]=='y' && fts5Porter_Vowel(aBuf, nBuf-1) ){
-    aBuf[nBuf-1] = 'i';
-  }
-
-  /* Steps 2 through 4. */
-  fts5PorterStep2(aBuf, &nBuf);
-  fts5PorterStep3(aBuf, &nBuf);
-  fts5PorterStep4(aBuf, &nBuf);
-
-  /* Step 5a. */
-  assert( nBuf>0 );
-  if( aBuf[nBuf-1]=='e' ){
-    if( fts5Porter_MGt1(aBuf, nBuf-1)
-     || (fts5Porter_MEq1(aBuf, nBuf-1) && !fts5Porter_Ostar(aBuf, nBuf-1))
-    ){
-      nBuf--;
-    }
-  }
-
-  /* Step 5b. */
-  if( nBuf>1 && aBuf[nBuf-1]=='l'
-   && aBuf[nBuf-2]=='l' && fts5Porter_MGt1(aBuf, nBuf-1)
-  ){
-    nBuf--;
-  }
-
-  return p->xToken(p->pCtx, tflags, aBuf, nBuf, iStart, iEnd);
-
- pass_through:
-  return p->xToken(p->pCtx, tflags, pToken, nToken, iStart, iEnd);
-}
-
-/*
-** Tokenize using the porter tokenizer.
-*/
-static int fts5PorterTokenize(
-  Fts5Tokenizer *pTokenizer,
-  void *pCtx,
-  int flags,
-  const char *pText, int nText,
-  const char *pLoc, int nLoc,
-  int (*xToken)(void*, int, const char*, int nToken, int iStart, int iEnd)
-){
-  PorterTokenizer *p = (PorterTokenizer*)pTokenizer;
-  PorterContext sCtx;
-  sCtx.xToken = xToken;
-  sCtx.pCtx = pCtx;
-  sCtx.aBuf = p->aBuf;
-  return p->tokenizer_v2.xTokenize(
-      p->pTokenizer, (void*)&sCtx, flags, pText, nText, pLoc, nLoc, fts5PorterCb
-  );
-}
-
-/**************************************************************************
-** Start of trigram implementation.
-*/
-typedef struct TrigramTokenizer TrigramTokenizer;
-struct TrigramTokenizer {
-  int bFold;                      /* True to fold to lower-case */
-  int iFoldParam;                 /* Parameter to pass to Fts5UnicodeFold() */
-};
-
-/*
-** Free a trigram tokenizer.
-*/
-static void fts5TriDelete(Fts5Tokenizer *p){
-  sqlite3_free(p);
-}
-
-/*
-** Allocate a trigram tokenizer.
-*/
-static int fts5TriCreate(
-  void *pUnused,
-  const char **azArg,
-  int nArg,
-  Fts5Tokenizer **ppOut
-){
-  int rc = SQLITE_OK;
-  TrigramTokenizer *pNew = 0;
-  UNUSED_PARAM(pUnused);
-  if( nArg%2 ){
-    rc = SQLITE_ERROR;
-  }else{
-    int i;
-    pNew = (TrigramTokenizer*)sqlite3_malloc64(sizeof(*pNew));
-    if( pNew==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      pNew->bFold = 1;
-      pNew->iFoldParam = 0;
-
-      for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
-        const char *zArg = azArg[i+1];
-        if( 0==sqlite3_stricmp(azArg[i], "case_sensitive") ){
-          if( (zArg[0]!='0' && zArg[0]!='1') || zArg[1] ){
-            rc = SQLITE_ERROR;
-          }else{
-            pNew->bFold = (zArg[0]=='0');
-          }
-        }else if( 0==sqlite3_stricmp(azArg[i], "remove_diacritics") ){
-          if( (zArg[0]!='0' && zArg[0]!='1' && zArg[0]!='2') || zArg[1] ){
-            rc = SQLITE_ERROR;
-          }else{
-            pNew->iFoldParam = (zArg[0]!='0') ? 2 : 0;
-          }
-        }else{
-          rc = SQLITE_ERROR;
-        }
-      }
-
-      if( pNew->iFoldParam!=0 && pNew->bFold==0 ){
-        rc = SQLITE_ERROR;
-      }
-
-      if( rc!=SQLITE_OK ){
-        fts5TriDelete((Fts5Tokenizer*)pNew);
-        pNew = 0;
-      }
-    }
-  }
-  *ppOut = (Fts5Tokenizer*)pNew;
-  return rc;
-}
-
-/*
-** Trigram tokenizer tokenize routine.
-*/
-static int fts5TriTokenize(
-  Fts5Tokenizer *pTok,
-  void *pCtx,
-  int unusedFlags,
-  const char *pText, int nText,
-  int (*xToken)(void*, int, const char*, int, int, int)
-){
-  TrigramTokenizer *p = (TrigramTokenizer*)pTok;
-  int rc = SQLITE_OK;
-  char aBuf[32];
-  char *zOut = aBuf;
-  int ii;
-  const unsigned char *zIn = (const unsigned char*)pText;
-  const unsigned char *zEof = (zIn ? &zIn[nText] : 0);
-  u32 iCode = 0;
-  int aStart[3];                  /* Input offset of each character in aBuf[] */
-
-  UNUSED_PARAM(unusedFlags);
-
-  /* Populate aBuf[] with the characters for the first trigram. */
-  for(ii=0; ii<3; ii++){
-    do {
-      aStart[ii] = zIn - (const unsigned char*)pText;
-      if( zIn>=zEof ) return SQLITE_OK;
-      READ_UTF8(zIn, zEof, iCode);
-      if( p->bFold ) iCode = sqlite3Fts5UnicodeFold(iCode, p->iFoldParam);
-    }while( iCode==0 );
-    WRITE_UTF8(zOut, iCode);
-  }
-
-  /* At the start of each iteration of this loop:
-  **
-  **  aBuf:      Contains 3 characters. The 3 characters of the next trigram.
-  **  zOut:      Points to the byte following the last character in aBuf.
-  **  aStart[3]: Contains the byte offset in the input text corresponding
-  **             to the start of each of the three characters in the buffer.
-  */
-  assert( zIn<=zEof );
-  while( 1 ){
-    int iNext;                    /* Start of character following current tri */
-    const char *z1;
-
-    /* Read characters from the input up until the first non-diacritic */
-    do {
-      iNext = zIn - (const unsigned char*)pText;
-      if( zIn>=zEof ){
-        iCode = 0;
-        break;
-      }
-      READ_UTF8(zIn, zEof, iCode);
-      if( p->bFold ) iCode = sqlite3Fts5UnicodeFold(iCode, p->iFoldParam);
-    }while( iCode==0 );
-
-    /* Pass the current trigram back to fts5 */
-    rc = xToken(pCtx, 0, aBuf, zOut-aBuf, aStart[0], iNext);
-    if( iCode==0 || rc!=SQLITE_OK ) break;
-
-    /* Remove the first character from buffer aBuf[]. Append the character
-    ** with codepoint iCode.  */
-    z1 = aBuf;
-    FTS5_SKIP_UTF8(z1);
-    memmove(aBuf, z1, zOut - z1);
-    zOut -= (z1 - aBuf);
-    WRITE_UTF8(zOut, iCode);
-
-    /* Update the aStart[] array */
-    aStart[0] = aStart[1];
-    aStart[1] = aStart[2];
-    aStart[2] = iNext;
-  }
-
-  return rc;
-}
-
-/*
-** Argument xCreate is a pointer to a constructor function for a tokenizer.
-** pTok is a tokenizer previously created using the same method. This function
-** returns one of FTS5_PATTERN_NONE, FTS5_PATTERN_LIKE or FTS5_PATTERN_GLOB
-** indicating the style of pattern matching that the tokenizer can support.
-** In practice, this is:
-**
-**     "trigram" tokenizer, case_sensitive=1 - FTS5_PATTERN_GLOB
-**     "trigram" tokenizer, case_sensitive=0 (the default) - FTS5_PATTERN_LIKE
-**     all other tokenizers - FTS5_PATTERN_NONE
-*/
-static int sqlite3Fts5TokenizerPattern(
-    int (*xCreate)(void*, const char**, int, Fts5Tokenizer**),
-    Fts5Tokenizer *pTok
-){
-  if( xCreate==fts5TriCreate ){
-    TrigramTokenizer *p = (TrigramTokenizer*)pTok;
-    if( p->iFoldParam==0 ){
-      return p->bFold ? FTS5_PATTERN_LIKE : FTS5_PATTERN_GLOB;
-    }
-  }
-  return FTS5_PATTERN_NONE;
-}
-
-/*
-** Return true if the tokenizer described by p->azArg[] is the trigram
-** tokenizer. This tokenizer needs to be loaded before xBestIndex is
-** called for the first time in order to correctly handle LIKE/GLOB.
-*/
-static int sqlite3Fts5TokenizerPreload(Fts5TokenizerConfig *p){
-  return (p->nArg>=1 && 0==sqlite3_stricmp(p->azArg[0], "trigram"));
-}
-
-
-/*
-** Register all built-in tokenizers with FTS5.
-*/
-static int sqlite3Fts5TokenizerInit(fts5_api *pApi){
-  struct BuiltinTokenizer {
-    const char *zName;
-    fts5_tokenizer x;
-  } aBuiltin[] = {
-    { "unicode61", {fts5UnicodeCreate, fts5UnicodeDelete, fts5UnicodeTokenize}},
-    { "ascii",     {fts5AsciiCreate, fts5AsciiDelete, fts5AsciiTokenize }},
-    { "trigram",   {fts5TriCreate, fts5TriDelete, fts5TriTokenize}},
-  };
-
-  int rc = SQLITE_OK;             /* Return code */
-  int i;                          /* To iterate through builtin functions */
-
-  for(i=0; rc==SQLITE_OK && i<ArraySize(aBuiltin); i++){
-    rc = pApi->xCreateTokenizer(pApi,
-        aBuiltin[i].zName,
-        (void*)pApi,
-        &aBuiltin[i].x,
-        0
-    );
-  }
-  if( rc==SQLITE_OK ){
-    fts5_tokenizer_v2 sPorter = {
-      2,
-      fts5PorterCreate,
-      fts5PorterDelete,
-      fts5PorterTokenize
-    };
-    rc = pApi->xCreateTokenizer_v2(pApi,
-        "porter",
-        (void*)pApi,
-        &sPorter,
-        0
-    );
-  }
-  return rc;
-}
-
-/*
-** 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.
-*/
-
-
-/* #include <assert.h> */
-
-
-
-/*
-** 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 fts5_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.
-*/
-static int sqlite3Fts5UnicodeIsdiacritic(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.
-*/
-static int sqlite3Fts5UnicodeFold(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 = fts5_remove_diacritic(ret, eRemoveDiacritic==2);
-    }
-  }
-
-  else if( c>=66560 && c<66600 ){
-    ret = c + 40;
-  }
-
-  return ret;
-}
-
-
-static int sqlite3Fts5UnicodeCatParse(const char *zCat, u8 *aArray){
-  aArray[0] = 1;
-  switch( zCat[0] ){
-    case 'C':
-          switch( zCat[1] ){
-            case 'c': aArray[1] = 1; break;
-            case 'f': aArray[2] = 1; break;
-            case 'n': aArray[3] = 1; break;
-            case 's': aArray[4] = 1; break;
-            case 'o': aArray[31] = 1; break;
-            case '*':
-              aArray[1] = 1;
-              aArray[2] = 1;
-              aArray[3] = 1;
-              aArray[4] = 1;
-              aArray[31] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'L':
-          switch( zCat[1] ){
-            case 'l': aArray[5] = 1; break;
-            case 'm': aArray[6] = 1; break;
-            case 'o': aArray[7] = 1; break;
-            case 't': aArray[8] = 1; break;
-            case 'u': aArray[9] = 1; break;
-            case 'C': aArray[30] = 1; break;
-            case '*':
-              aArray[5] = 1;
-              aArray[6] = 1;
-              aArray[7] = 1;
-              aArray[8] = 1;
-              aArray[9] = 1;
-              aArray[30] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'M':
-          switch( zCat[1] ){
-            case 'c': aArray[10] = 1; break;
-            case 'e': aArray[11] = 1; break;
-            case 'n': aArray[12] = 1; break;
-            case '*':
-              aArray[10] = 1;
-              aArray[11] = 1;
-              aArray[12] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'N':
-          switch( zCat[1] ){
-            case 'd': aArray[13] = 1; break;
-            case 'l': aArray[14] = 1; break;
-            case 'o': aArray[15] = 1; break;
-            case '*':
-              aArray[13] = 1;
-              aArray[14] = 1;
-              aArray[15] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'P':
-          switch( zCat[1] ){
-            case 'c': aArray[16] = 1; break;
-            case 'd': aArray[17] = 1; break;
-            case 'e': aArray[18] = 1; break;
-            case 'f': aArray[19] = 1; break;
-            case 'i': aArray[20] = 1; break;
-            case 'o': aArray[21] = 1; break;
-            case 's': aArray[22] = 1; break;
-            case '*':
-              aArray[16] = 1;
-              aArray[17] = 1;
-              aArray[18] = 1;
-              aArray[19] = 1;
-              aArray[20] = 1;
-              aArray[21] = 1;
-              aArray[22] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'S':
-          switch( zCat[1] ){
-            case 'c': aArray[23] = 1; break;
-            case 'k': aArray[24] = 1; break;
-            case 'm': aArray[25] = 1; break;
-            case 'o': aArray[26] = 1; break;
-            case '*':
-              aArray[23] = 1;
-              aArray[24] = 1;
-              aArray[25] = 1;
-              aArray[26] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'Z':
-          switch( zCat[1] ){
-            case 'l': aArray[27] = 1; break;
-            case 'p': aArray[28] = 1; break;
-            case 's': aArray[29] = 1; break;
-            case '*':
-              aArray[27] = 1;
-              aArray[28] = 1;
-              aArray[29] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-
-    default:
-      return 1;
-  }
-  return 0;
-}
-
-static u16 aFts5UnicodeBlock[] = {
-    0,     1471,  1753,  1760,  1760,  1760,  1760,  1760,  1760,  1760,
-    1760,  1760,  1760,  1760,  1760,  1763,  1765,
-  };
-static u16 aFts5UnicodeMap[] = {
-    0,     32,    33,    36,    37,    40,    41,    42,    43,    44,
-    45,    46,    48,    58,    60,    63,    65,    91,    92,    93,
-    94,    95,    96,    97,    123,   124,   125,   126,   127,   160,
-    161,   162,   166,   167,   168,   169,   170,   171,   172,   173,
-    174,   175,   176,   177,   178,   180,   181,   182,   184,   185,
-    186,   187,   188,   191,   192,   215,   216,   223,   247,   248,
-    256,   312,   313,   329,   330,   377,   383,   385,   387,   388,
-    391,   394,   396,   398,   402,   403,   405,   406,   409,   412,
-    414,   415,   417,   418,   423,   427,   428,   431,   434,   436,
-    437,   440,   442,   443,   444,   446,   448,   452,   453,   454,
-    455,   456,   457,   458,   459,   460,   461,   477,   478,   496,
-    497,   498,   499,   500,   503,   505,   506,   564,   570,   572,
-    573,   575,   577,   580,   583,   584,   592,   660,   661,   688,
-    706,   710,   722,   736,   741,   748,   749,   750,   751,   768,
-    880,   884,   885,   886,   890,   891,   894,   900,   902,   903,
-    904,   908,   910,   912,   913,   931,   940,   975,   977,   978,
-    981,   984,   1008,  1012,  1014,  1015,  1018,  1020,  1021,  1072,
-    1120,  1154,  1155,  1160,  1162,  1217,  1231,  1232,  1329,  1369,
-    1370,  1377,  1417,  1418,  1423,  1425,  1470,  1471,  1472,  1473,
-    1475,  1476,  1478,  1479,  1488,  1520,  1523,  1536,  1542,  1545,
-    1547,  1548,  1550,  1552,  1563,  1566,  1568,  1600,  1601,  1611,
-    1632,  1642,  1646,  1648,  1649,  1748,  1749,  1750,  1757,  1758,
-    1759,  1765,  1767,  1769,  1770,  1774,  1776,  1786,  1789,  1791,
-    1792,  1807,  1808,  1809,  1810,  1840,  1869,  1958,  1969,  1984,
-    1994,  2027,  2036,  2038,  2039,  2042,  2048,  2070,  2074,  2075,
-    2084,  2085,  2088,  2089,  2096,  2112,  2137,  2142,  2208,  2210,
-    2276,  2304,  2307,  2308,  2362,  2363,  2364,  2365,  2366,  2369,
-    2377,  2381,  2382,  2384,  2385,  2392,  2402,  2404,  2406,  2416,
-    2417,  2418,  2425,  2433,  2434,  2437,  2447,  2451,  2474,  2482,
-    2486,  2492,  2493,  2494,  2497,  2503,  2507,  2509,  2510,  2519,
-    2524,  2527,  2530,  2534,  2544,  2546,  2548,  2554,  2555,  2561,
-    2563,  2565,  2575,  2579,  2602,  2610,  2613,  2616,  2620,  2622,
-    2625,  2631,  2635,  2641,  2649,  2654,  2662,  2672,  2674,  2677,
-    2689,  2691,  2693,  2703,  2707,  2730,  2738,  2741,  2748,  2749,
-    2750,  2753,  2759,  2761,  2763,  2765,  2768,  2784,  2786,  2790,
-    2800,  2801,  2817,  2818,  2821,  2831,  2835,  2858,  2866,  2869,
-    2876,  2877,  2878,  2879,  2880,  2881,  2887,  2891,  2893,  2902,
-    2903,  2908,  2911,  2914,  2918,  2928,  2929,  2930,  2946,  2947,
-    2949,  2958,  2962,  2969,  2972,  2974,  2979,  2984,  2990,  3006,
-    3008,  3009,  3014,  3018,  3021,  3024,  3031,  3046,  3056,  3059,
-    3065,  3066,  3073,  3077,  3086,  3090,  3114,  3125,  3133,  3134,
-    3137,  3142,  3146,  3157,  3160,  3168,  3170,  3174,  3192,  3199,
-    3202,  3205,  3214,  3218,  3242,  3253,  3260,  3261,  3262,  3263,
-    3264,  3270,  3271,  3274,  3276,  3285,  3294,  3296,  3298,  3302,
-    3313,  3330,  3333,  3342,  3346,  3389,  3390,  3393,  3398,  3402,
-    3405,  3406,  3415,  3424,  3426,  3430,  3440,  3449,  3450,  3458,
-    3461,  3482,  3507,  3517,  3520,  3530,  3535,  3538,  3542,  3544,
-    3570,  3572,  3585,  3633,  3634,  3636,  3647,  3648,  3654,  3655,
-    3663,  3664,  3674,  3713,  3716,  3719,  3722,  3725,  3732,  3737,
-    3745,  3749,  3751,  3754,  3757,  3761,  3762,  3764,  3771,  3773,
-    3776,  3782,  3784,  3792,  3804,  3840,  3841,  3844,  3859,  3860,
-    3861,  3864,  3866,  3872,  3882,  3892,  3893,  3894,  3895,  3896,
-    3897,  3898,  3899,  3900,  3901,  3902,  3904,  3913,  3953,  3967,
-    3968,  3973,  3974,  3976,  3981,  3993,  4030,  4038,  4039,  4046,
-    4048,  4053,  4057,  4096,  4139,  4141,  4145,  4146,  4152,  4153,
-    4155,  4157,  4159,  4160,  4170,  4176,  4182,  4184,  4186,  4190,
-    4193,  4194,  4197,  4199,  4206,  4209,  4213,  4226,  4227,  4229,
-    4231,  4237,  4238,  4239,  4240,  4250,  4253,  4254,  4256,  4295,
-    4301,  4304,  4347,  4348,  4349,  4682,  4688,  4696,  4698,  4704,
-    4746,  4752,  4786,  4792,  4800,  4802,  4808,  4824,  4882,  4888,
-    4957,  4960,  4969,  4992,  5008,  5024,  5120,  5121,  5741,  5743,
-    5760,  5761,  5787,  5788,  5792,  5867,  5870,  5888,  5902,  5906,
-    5920,  5938,  5941,  5952,  5970,  5984,  5998,  6002,  6016,  6068,
-    6070,  6071,  6078,  6086,  6087,  6089,  6100,  6103,  6104,  6107,
-    6108,  6109,  6112,  6128,  6144,  6150,  6151,  6155,  6158,  6160,
-    6176,  6211,  6212,  6272,  6313,  6314,  6320,  6400,  6432,  6435,
-    6439,  6441,  6448,  6450,  6451,  6457,  6464,  6468,  6470,  6480,
-    6512,  6528,  6576,  6593,  6600,  6608,  6618,  6622,  6656,  6679,
-    6681,  6686,  6688,  6741,  6742,  6743,  6744,  6752,  6753,  6754,
-    6755,  6757,  6765,  6771,  6783,  6784,  6800,  6816,  6823,  6824,
-    6912,  6916,  6917,  6964,  6965,  6966,  6971,  6972,  6973,  6978,
-    6979,  6981,  6992,  7002,  7009,  7019,  7028,  7040,  7042,  7043,
-    7073,  7074,  7078,  7080,  7082,  7083,  7084,  7086,  7088,  7098,
-    7142,  7143,  7144,  7146,  7149,  7150,  7151,  7154,  7164,  7168,
-    7204,  7212,  7220,  7222,  7227,  7232,  7245,  7248,  7258,  7288,
-    7294,  7360,  7376,  7379,  7380,  7393,  7394,  7401,  7405,  7406,
-    7410,  7412,  7413,  7424,  7468,  7531,  7544,  7545,  7579,  7616,
-    7676,  7680,  7830,  7838,  7936,  7944,  7952,  7960,  7968,  7976,
-    7984,  7992,  8000,  8008,  8016,  8025,  8027,  8029,  8031,  8033,
-    8040,  8048,  8064,  8072,  8080,  8088,  8096,  8104,  8112,  8118,
-    8120,  8124,  8125,  8126,  8127,  8130,  8134,  8136,  8140,  8141,
-    8144,  8150,  8152,  8157,  8160,  8168,  8173,  8178,  8182,  8184,
-    8188,  8189,  8192,  8203,  8208,  8214,  8216,  8217,  8218,  8219,
-    8221,  8222,  8223,  8224,  8232,  8233,  8234,  8239,  8240,  8249,
-    8250,  8251,  8255,  8257,  8260,  8261,  8262,  8263,  8274,  8275,
-    8276,  8277,  8287,  8288,  8298,  8304,  8305,  8308,  8314,  8317,
-    8318,  8319,  8320,  8330,  8333,  8334,  8336,  8352,  8400,  8413,
-    8417,  8418,  8421,  8448,  8450,  8451,  8455,  8456,  8458,  8459,
-    8462,  8464,  8467,  8468,  8469,  8470,  8472,  8473,  8478,  8484,
-    8485,  8486,  8487,  8488,  8489,  8490,  8494,  8495,  8496,  8500,
-    8501,  8505,  8506,  8508,  8510,  8512,  8517,  8519,  8522,  8523,
-    8524,  8526,  8527,  8528,  8544,  8579,  8581,  8585,  8592,  8597,
-    8602,  8604,  8608,  8609,  8611,  8612,  8614,  8615,  8622,  8623,
-    8654,  8656,  8658,  8659,  8660,  8661,  8692,  8960,  8968,  8972,
-    8992,  8994,  9001,  9002,  9003,  9084,  9085,  9115,  9140,  9180,
-    9186,  9216,  9280,  9312,  9372,  9450,  9472,  9655,  9656,  9665,
-    9666,  9720,  9728,  9839,  9840,  9985,  10088, 10089, 10090, 10091,
-    10092, 10093, 10094, 10095, 10096, 10097, 10098, 10099, 10100, 10101,
-    10102, 10132, 10176, 10181, 10182, 10183, 10214, 10215, 10216, 10217,
-    10218, 10219, 10220, 10221, 10222, 10223, 10224, 10240, 10496, 10627,
-    10628, 10629, 10630, 10631, 10632, 10633, 10634, 10635, 10636, 10637,
-    10638, 10639, 10640, 10641, 10642, 10643, 10644, 10645, 10646, 10647,
-    10648, 10649, 10712, 10713, 10714, 10715, 10716, 10748, 10749, 10750,
-    11008, 11056, 11077, 11079, 11088, 11264, 11312, 11360, 11363, 11365,
-    11367, 11374, 11377, 11378, 11380, 11381, 11383, 11388, 11390, 11393,
-    11394, 11492, 11493, 11499, 11503, 11506, 11513, 11517, 11518, 11520,
-    11559, 11565, 11568, 11631, 11632, 11647, 11648, 11680, 11688, 11696,
-    11704, 11712, 11720, 11728, 11736, 11744, 11776, 11778, 11779, 11780,
-    11781, 11782, 11785, 11786, 11787, 11788, 11789, 11790, 11799, 11800,
-    11802, 11803, 11804, 11805, 11806, 11808, 11809, 11810, 11811, 11812,
-    11813, 11814, 11815, 11816, 11817, 11818, 11823, 11824, 11834, 11904,
-    11931, 12032, 12272, 12288, 12289, 12292, 12293, 12294, 12295, 12296,
-    12297, 12298, 12299, 12300, 12301, 12302, 12303, 12304, 12305, 12306,
-    12308, 12309, 12310, 12311, 12312, 12313, 12314, 12315, 12316, 12317,
-    12318, 12320, 12321, 12330, 12334, 12336, 12337, 12342, 12344, 12347,
-    12348, 12349, 12350, 12353, 12441, 12443, 12445, 12447, 12448, 12449,
-    12539, 12540, 12543, 12549, 12593, 12688, 12690, 12694, 12704, 12736,
-    12784, 12800, 12832, 12842, 12872, 12880, 12881, 12896, 12928, 12938,
-    12977, 12992, 13056, 13312, 19893, 19904, 19968, 40908, 40960, 40981,
-    40982, 42128, 42192, 42232, 42238, 42240, 42508, 42509, 42512, 42528,
-    42538, 42560, 42606, 42607, 42608, 42611, 42612, 42622, 42623, 42624,
-    42655, 42656, 42726, 42736, 42738, 42752, 42775, 42784, 42786, 42800,
-    42802, 42864, 42865, 42873, 42878, 42888, 42889, 42891, 42896, 42912,
-    43000, 43002, 43003, 43010, 43011, 43014, 43015, 43019, 43020, 43043,
-    43045, 43047, 43048, 43056, 43062, 43064, 43065, 43072, 43124, 43136,
-    43138, 43188, 43204, 43214, 43216, 43232, 43250, 43256, 43259, 43264,
-    43274, 43302, 43310, 43312, 43335, 43346, 43359, 43360, 43392, 43395,
-    43396, 43443, 43444, 43446, 43450, 43452, 43453, 43457, 43471, 43472,
-    43486, 43520, 43561, 43567, 43569, 43571, 43573, 43584, 43587, 43588,
-    43596, 43597, 43600, 43612, 43616, 43632, 43633, 43639, 43642, 43643,
-    43648, 43696, 43697, 43698, 43701, 43703, 43705, 43710, 43712, 43713,
-    43714, 43739, 43741, 43742, 43744, 43755, 43756, 43758, 43760, 43762,
-    43763, 43765, 43766, 43777, 43785, 43793, 43808, 43816, 43968, 44003,
-    44005, 44006, 44008, 44009, 44011, 44012, 44013, 44016, 44032, 55203,
-    55216, 55243, 55296, 56191, 56319, 57343, 57344, 63743, 63744, 64112,
-    64256, 64275, 64285, 64286, 64287, 64297, 64298, 64312, 64318, 64320,
-    64323, 64326, 64434, 64467, 64830, 64831, 64848, 64914, 65008, 65020,
-    65021, 65024, 65040, 65047, 65048, 65049, 65056, 65072, 65073, 65075,
-    65077, 65078, 65079, 65080, 65081, 65082, 65083, 65084, 65085, 65086,
-    65087, 65088, 65089, 65090, 65091, 65092, 65093, 65095, 65096, 65097,
-    65101, 65104, 65108, 65112, 65113, 65114, 65115, 65116, 65117, 65118,
-    65119, 65122, 65123, 65124, 65128, 65129, 65130, 65136, 65142, 65279,
-    65281, 65284, 65285, 65288, 65289, 65290, 65291, 65292, 65293, 65294,
-    65296, 65306, 65308, 65311, 65313, 65339, 65340, 65341, 65342, 65343,
-    65344, 65345, 65371, 65372, 65373, 65374, 65375, 65376, 65377, 65378,
-    65379, 65380, 65382, 65392, 65393, 65438, 65440, 65474, 65482, 65490,
-    65498, 65504, 65506, 65507, 65508, 65509, 65512, 65513, 65517, 65529,
-    65532, 0,     13,    40,    60,    63,    80,    128,   256,   263,
-    311,   320,   373,   377,   394,   400,   464,   509,   640,   672,
-    768,   800,   816,   833,   834,   842,   896,   927,   928,   968,
-    976,   977,   1024,  1064,  1104,  1184,  2048,  2056,  2058,  2103,
-    2108,  2111,  2135,  2136,  2304,  2326,  2335,  2336,  2367,  2432,
-    2494,  2560,  2561,  2565,  2572,  2576,  2581,  2585,  2616,  2623,
-    2624,  2640,  2656,  2685,  2687,  2816,  2873,  2880,  2904,  2912,
-    2936,  3072,  3680,  4096,  4097,  4098,  4099,  4152,  4167,  4178,
-    4198,  4224,  4226,  4227,  4272,  4275,  4279,  4281,  4283,  4285,
-    4286,  4304,  4336,  4352,  4355,  4391,  4396,  4397,  4406,  4416,
-    4480,  4482,  4483,  4531,  4534,  4543,  4545,  4549,  4560,  5760,
-    5803,  5804,  5805,  5806,  5808,  5814,  5815,  5824,  8192,  9216,
-    9328,  12288, 26624, 28416, 28496, 28497, 28559, 28563, 45056, 53248,
-    53504, 53545, 53605, 53607, 53610, 53613, 53619, 53627, 53635, 53637,
-    53644, 53674, 53678, 53760, 53826, 53829, 54016, 54112, 54272, 54298,
-    54324, 54350, 54358, 54376, 54402, 54428, 54430, 54434, 54437, 54441,
-    54446, 54454, 54459, 54461, 54469, 54480, 54506, 54532, 54535, 54541,
-    54550, 54558, 54584, 54587, 54592, 54598, 54602, 54610, 54636, 54662,
-    54688, 54714, 54740, 54766, 54792, 54818, 54844, 54870, 54896, 54922,
-    54952, 54977, 54978, 55003, 55004, 55010, 55035, 55036, 55061, 55062,
-    55068, 55093, 55094, 55119, 55120, 55126, 55151, 55152, 55177, 55178,
-    55184, 55209, 55210, 55235, 55236, 55242, 55246, 60928, 60933, 60961,
-    60964, 60967, 60969, 60980, 60985, 60987, 60994, 60999, 61001, 61003,
-    61005, 61009, 61012, 61015, 61017, 61019, 61021, 61023, 61025, 61028,
-    61031, 61036, 61044, 61049, 61054, 61056, 61067, 61089, 61093, 61099,
-    61168, 61440, 61488, 61600, 61617, 61633, 61649, 61696, 61712, 61744,
-    61808, 61926, 61968, 62016, 62032, 62208, 62256, 62263, 62336, 62368,
-    62406, 62432, 62464, 62528, 62530, 62713, 62720, 62784, 62800, 62971,
-    63045, 63104, 63232, 0,     42710, 42752, 46900, 46912, 47133, 63488,
-    1,     32,    256,   0,     65533,
-  };
-static u16 aFts5UnicodeData[] = {
-    1025,  61,    117,   55,    117,   54,    50,    53,    57,    53,
-    49,    85,    333,   85,    121,   85,    841,   54,    53,    50,
-    56,    48,    56,    837,   54,    57,    50,    57,    1057,  61,
-    53,    151,   58,    53,    56,    58,    39,    52,    57,    34,
-    58,    56,    58,    57,    79,    56,    37,    85,    56,    47,
-    39,    51,    111,   53,    745,   57,    233,   773,   57,    261,
-    1822,  37,    542,   37,    1534,  222,   69,    73,    37,    126,
-    126,   73,    69,    137,   37,    73,    37,    105,   101,   73,
-    37,    73,    37,    190,   158,   37,    126,   126,   73,    37,
-    126,   94,    37,    39,    94,    69,    135,   41,    40,    37,
-    41,    40,    37,    41,    40,    37,    542,   37,    606,   37,
-    41,    40,    37,    126,   73,    37,    1886,  197,   73,    37,
-    73,    69,    126,   105,   37,    286,   2181,  39,    869,   582,
-    152,   390,   472,   166,   248,   38,    56,    38,    568,   3596,
-    158,   38,    56,    94,    38,    101,   53,    88,    41,    53,
-    105,   41,    73,    37,    553,   297,   1125,  94,    37,    105,
-    101,   798,   133,   94,    57,    126,   94,    37,    1641,  1541,
-    1118,  58,    172,   75,    1790,  478,   37,    2846,  1225,  38,
-    213,   1253,  53,    49,    55,    1452,  49,    44,    53,    76,
-    53,    76,    53,    44,    871,   103,   85,    162,   121,   85,
-    55,    85,    90,    364,   53,    85,    1031,  38,    327,   684,
-    333,   149,   71,    44,    3175,  53,    39,    236,   34,    58,
-    204,   70,    76,    58,    140,   71,    333,   103,   90,    39,
-    469,   34,    39,    44,    967,   876,   2855,  364,   39,    333,
-    1063,  300,   70,    58,    117,   38,    711,   140,   38,    300,
-    38,    108,   38,    172,   501,   807,   108,   53,    39,    359,
-    876,   108,   42,    1735,  44,    42,    44,    39,    106,   268,
-    138,   44,    74,    39,    236,   327,   76,    85,    333,   53,
-    38,    199,   231,   44,    74,    263,   71,    711,   231,   39,
-    135,   44,    39,    106,   140,   74,    74,    44,    39,    42,
-    71,    103,   76,    333,   71,    87,    207,   58,    55,    76,
-    42,    199,   71,    711,   231,   71,    71,    71,    44,    106,
-    76,    76,    108,   44,    135,   39,    333,   76,    103,   44,
-    76,    42,    295,   103,   711,   231,   71,    167,   44,    39,
-    106,   172,   76,    42,    74,    44,    39,    71,    76,    333,
-    53,    55,    44,    74,    263,   71,    711,   231,   71,    167,
-    44,    39,    42,    44,    42,    140,   74,    74,    44,    44,
-    42,    71,    103,   76,    333,   58,    39,    207,   44,    39,
-    199,   103,   135,   71,    39,    71,    71,    103,   391,   74,
-    44,    74,    106,   106,   44,    39,    42,    333,   111,   218,
-    55,    58,    106,   263,   103,   743,   327,   167,   39,    108,
-    138,   108,   140,   76,    71,    71,    76,    333,   239,   58,
-    74,    263,   103,   743,   327,   167,   44,    39,    42,    44,
-    170,   44,    74,    74,    76,    74,    39,    71,    76,    333,
-    71,    74,    263,   103,   1319,  39,    106,   140,   106,   106,
-    44,    39,    42,    71,    76,    333,   207,   58,    199,   74,
-    583,   775,   295,   39,    231,   44,    106,   108,   44,    266,
-    74,    53,    1543,  44,    71,    236,   55,    199,   38,    268,
-    53,    333,   85,    71,    39,    71,    39,    39,    135,   231,
-    103,   39,    39,    71,    135,   44,    71,    204,   76,    39,
-    167,   38,    204,   333,   135,   39,    122,   501,   58,    53,
-    122,   76,    218,   333,   335,   58,    44,    58,    44,    58,
-    44,    54,    50,    54,    50,    74,    263,   1159,  460,   42,
-    172,   53,    76,    167,   364,   1164,  282,   44,    218,   90,
-    181,   154,   85,    1383,  74,    140,   42,    204,   42,    76,
-    74,    76,    39,    333,   213,   199,   74,    76,    135,   108,
-    39,    106,   71,    234,   103,   140,   423,   44,    74,    76,
-    202,   44,    39,    42,    333,   106,   44,    90,    1225,  41,
-    41,    1383,  53,    38,    10631, 135,   231,   39,    135,   1319,
-    135,   1063,  135,   231,   39,    135,   487,   1831,  135,   2151,
-    108,   309,   655,   519,   346,   2727,  49,    19847, 85,    551,
-    61,    839,   54,    50,    2407,  117,   110,   423,   135,   108,
-    583,   108,   85,    583,   76,    423,   103,   76,    1671,  76,
-    42,    236,   266,   44,    74,    364,   117,   38,    117,   55,
-    39,    44,    333,   335,   213,   49,    149,   108,   61,    333,
-    1127,  38,    1671,  1319,  44,    39,    2247,  935,   108,   138,
-    76,    106,   74,    44,    202,   108,   58,    85,    333,   967,
-    167,   1415,  554,   231,   74,    333,   47,    1114,  743,   76,
-    106,   85,    1703,  42,    44,    42,    236,   44,    42,    44,
-    74,    268,   202,   332,   44,    333,   333,   245,   38,    213,
-    140,   42,    1511,  44,    42,    172,   42,    44,    170,   44,
-    74,    231,   333,   245,   346,   300,   314,   76,    42,    967,
-    42,    140,   74,    76,    42,    44,    74,    71,    333,   1415,
-    44,    42,    76,    106,   44,    42,    108,   74,    149,   1159,
-    266,   268,   74,    76,    181,   333,   103,   333,   967,   198,
-    85,    277,   108,   53,    428,   42,    236,   135,   44,    135,
-    74,    44,    71,    1413,  2022,  421,   38,    1093,  1190,  1260,
-    140,   4830,  261,   3166,  261,   265,   197,   201,   261,   265,
-    261,   265,   197,   201,   261,   41,    41,    41,    94,    229,
-    265,   453,   261,   264,   261,   264,   261,   264,   165,   69,
-    137,   40,    56,    37,    120,   101,   69,    137,   40,    120,
-    133,   69,    137,   120,   261,   169,   120,   101,   69,    137,
-    40,    88,    381,   162,   209,   85,    52,    51,    54,    84,
-    51,    54,    52,    277,   59,    60,    162,   61,    309,   52,
-    51,    149,   80,    117,   57,    54,    50,    373,   57,    53,
-    48,    341,   61,    162,   194,   47,    38,    207,   121,   54,
-    50,    38,    335,   121,   54,    50,    422,   855,   428,   139,
-    44,    107,   396,   90,    41,    154,   41,    90,    37,    105,
-    69,    105,   37,    58,    41,    90,    57,    169,   218,   41,
-    58,    41,    58,    41,    58,    137,   58,    37,    137,   37,
-    135,   37,    90,    69,    73,    185,   94,    101,   58,    57,
-    90,    37,    58,    527,   1134,  94,    142,   47,    185,   186,
-    89,    154,   57,    90,    57,    90,    57,    250,   57,    1018,
-    89,    90,    57,    58,    57,    1018,  8601,  282,   153,   666,
-    89,    250,   54,    50,    2618,  57,    986,   825,   1306,  217,
-    602,   1274,  378,   1935,  2522,  719,   5882,  57,    314,   57,
-    1754,  281,   3578,  57,    4634,  3322,  54,    50,    54,    50,
-    54,    50,    54,    50,    54,    50,    54,    50,    54,    50,
-    975,   1434,  185,   54,    50,    1017,  54,    50,    54,    50,
-    54,    50,    54,    50,    54,    50,    537,   8218,  4217,  54,
-    50,    54,    50,    54,    50,    54,    50,    54,    50,    54,
-    50,    54,    50,    54,    50,    54,    50,    54,    50,    54,
-    50,    2041,  54,    50,    54,    50,    1049,  54,    50,    8281,
-    1562,  697,   90,    217,   346,   1513,  1509,  126,   73,    69,
-    254,   105,   37,    94,    37,    94,    165,   70,    105,   37,
-    3166,  37,    218,   158,   108,   94,    149,   47,    85,    1221,
-    37,    37,    1799,  38,    53,    44,    743,   231,   231,   231,
-    231,   231,   231,   231,   231,   1036,  85,    52,    51,    52,
-    51,    117,   52,    51,    53,    52,    51,    309,   49,    85,
-    49,    53,    52,    51,    85,    52,    51,    54,    50,    54,
-    50,    54,    50,    54,    50,    181,   38,    341,   81,    858,
-    2874,  6874,  410,   61,    117,   58,    38,    39,    46,    54,
-    50,    54,    50,    54,    50,    54,    50,    54,    50,    90,
-    54,    50,    54,    50,    54,    50,    54,    50,    49,    54,
-    82,    58,    302,   140,   74,    49,    166,   90,    110,   38,
-    39,    53,    90,    2759,  76,    88,    70,    39,    49,    2887,
-    53,    102,   39,    1319,  3015,  90,    143,   346,   871,   1178,
-    519,   1018,  335,   986,   271,   58,    495,   1050,  335,   1274,
-    495,   2042,  8218,  39,    39,    2074,  39,    39,    679,   38,
-    36583, 1786,  1287,  198,   85,    8583,  38,    117,   519,   333,
-    71,    1502,  39,    44,    107,   53,    332,   53,    38,    798,
-    44,    2247,  334,   76,    213,   760,   294,   88,    478,   69,
-    2014,  38,    261,   190,   350,   38,    88,    158,   158,   382,
-    70,    37,    231,   44,    103,   44,    135,   44,    743,   74,
-    76,    42,    154,   207,   90,    55,    58,    1671,  149,   74,
-    1607,  522,   44,    85,    333,   588,   199,   117,   39,    333,
-    903,   268,   85,    743,   364,   74,    53,    935,   108,   42,
-    1511,  44,    74,    140,   74,    44,    138,   437,   38,    333,
-    85,    1319,  204,   74,    76,    74,    76,    103,   44,    263,
-    44,    42,    333,   149,   519,   38,    199,   122,   39,    42,
-    1543,  44,    39,    108,   71,    76,    167,   76,    39,    44,
-    39,    71,    38,    85,    359,   42,    76,    74,    85,    39,
-    70,    42,    44,    199,   199,   199,   231,   231,   1127,  74,
-    44,    74,    44,    74,    53,    42,    44,    333,   39,    39,
-    743,   1575,  36,    68,    68,    36,    63,    63,    11719, 3399,
-    229,   165,   39,    44,    327,   57,    423,   167,   39,    71,
-    71,    3463,  536,   11623, 54,    50,    2055,  1735,  391,   55,
-    58,    524,   245,   54,    50,    53,    236,   53,    81,    80,
-    54,    50,    54,    50,    54,    50,    54,    50,    54,    50,
-    54,    50,    54,    50,    54,    50,    85,    54,    50,    149,
-    112,   117,   149,   49,    54,    50,    54,    50,    54,    50,
-    117,   57,    49,    121,   53,    55,    85,    167,   4327,  34,
-    117,   55,    117,   54,    50,    53,    57,    53,    49,    85,
-    333,   85,    121,   85,    841,   54,    53,    50,    56,    48,
-    56,    837,   54,    57,    50,    57,    54,    50,    53,    54,
-    50,    85,    327,   38,    1447,  70,    999,   199,   199,   199,
-    103,   87,    57,    56,    58,    87,    58,    153,   90,    98,
-    90,    391,   839,   615,   71,    487,   455,   3943,  117,   1455,
-    314,   1710,  143,   570,   47,    410,   1466,  44,    935,   1575,
-    999,   143,   551,   46,    263,   46,    967,   53,    1159,  263,
-    53,    174,   1289,  1285,  2503,  333,   199,   39,    1415,  71,
-    39,    743,   53,    271,   711,   207,   53,    839,   53,    1799,
-    71,    39,    108,   76,    140,   135,   103,   871,   108,   44,
-    271,   309,   935,   79,    53,    1735,  245,   711,   271,   615,
-    271,   2343,  1007,  42,    44,    42,    1703,  492,   245,   655,
-    333,   76,    42,    1447,  106,   140,   74,    76,    85,    34,
-    149,   807,   333,   108,   1159,  172,   42,    268,   333,   149,
-    76,    42,    1543,  106,   300,   74,    135,   149,   333,   1383,
-    44,    42,    44,    74,    204,   42,    44,    333,   28135, 3182,
-    149,   34279, 18215, 2215,  39,    1482,  140,   422,   71,    7898,
-    1274,  1946,  74,    108,   122,   202,   258,   268,   90,    236,
-    986,   140,   1562,  2138,  108,   58,    2810,  591,   841,   837,
-    841,   229,   581,   841,   837,   41,    73,    41,    73,    137,
-    265,   133,   37,    229,   357,   841,   837,   73,    137,   265,
-    233,   837,   73,    137,   169,   41,    233,   837,   841,   837,
-    841,   837,   841,   837,   841,   837,   841,   837,   841,   901,
-    809,   57,    805,   57,    197,   809,   57,    805,   57,    197,
-    809,   57,    805,   57,    197,   809,   57,    805,   57,    197,
-    809,   57,    805,   57,    197,   94,    1613,  135,   871,   71,
-    39,    39,    327,   135,   39,    39,    39,    39,    39,    39,
-    103,   71,    39,    39,    39,    39,    39,    39,    71,    39,
-    135,   231,   135,   135,   39,    327,   551,   103,   167,   551,
-    89,    1434,  3226,  506,   474,   506,   506,   367,   1018,  1946,
-    1402,  954,   1402,  314,   90,    1082,  218,   2266,  666,   1210,
-    186,   570,   2042,  58,    5850,  154,   2010,  154,   794,   2266,
-    378,   2266,  3738,  39,    39,    39,    39,    39,    39,    17351,
-    34,    3074,  7692,  63,    63,
-  };
-
-static int sqlite3Fts5UnicodeCategory(u32 iCode) {
-  int iRes = -1;
-  int iHi;
-  int iLo;
-  int ret;
-  u16 iKey;
-
-  if( iCode>=(1<<20) ){
-    return 0;
-  }
-  iLo = aFts5UnicodeBlock[(iCode>>16)];
-  iHi = aFts5UnicodeBlock[1+(iCode>>16)];
-  iKey = (iCode & 0xFFFF);
-  while( iHi>iLo ){
-    int iTest = (iHi + iLo) / 2;
-    assert( iTest>=iLo && iTest<iHi );
-    if( iKey>=aFts5UnicodeMap[iTest] ){
-      iRes = iTest;
-      iLo = iTest+1;
-    }else{
-      iHi = iTest;
-    }
-  }
-
-  if( iRes<0 ) return 0;
-  if( iKey>=(aFts5UnicodeMap[iRes]+(aFts5UnicodeData[iRes]>>5)) ) return 0;
-  ret = aFts5UnicodeData[iRes] & 0x1F;
-  if( ret!=30 ) return ret;
-  return ((iKey - aFts5UnicodeMap[iRes]) & 0x01) ? 5 : 9;
-}
-
-static void sqlite3Fts5UnicodeAscii(u8 *aArray, u8 *aAscii){
-  int i = 0;
-  int iTbl = 0;
-  while( i<128 ){
-    int bToken = aArray[ aFts5UnicodeData[iTbl] & 0x1F ];
-    int n = (aFts5UnicodeData[iTbl] >> 5) + i;
-    for(; i<128 && i<n; i++){
-      aAscii[i] = (u8)bToken;
-    }
-    iTbl++;
-  }
-  aAscii[0] = 0;                  /* 0x00 is never a token character */
-}
-
-/*
-** 2015 May 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.
-**
-******************************************************************************
-**
-** Routines for varint serialization and deserialization.
-*/
-
-
-/* #include "fts5Int.h" */
-
-/*
-** This is a copy of the sqlite3GetVarint32() routine from the SQLite core.
-** Except, this version does handle the single byte case that the core
-** version depends on being handled before its function is called.
-*/
-static int sqlite3Fts5GetVarint32(const unsigned char *p, u32 *v){
-  u32 a,b;
-
-  /* The 1-byte case. Overwhelmingly the most common. */
-  a = *p;
-  /* a: p0 (unmasked) */
-  if (!(a&0x80))
-  {
-    /* Values between 0 and 127 */
-    *v = a;
-    return 1;
-  }
-
-  /* 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.
-  */
-  {
-    u64 v64;
-    u8 n;
-    p -= 2;
-    n = sqlite3Fts5GetVarint(p, &v64);
-    *v = ((u32)v64) & 0x7FFFFFFF;
-    assert( n>3 && n<=9 );
-    return n;
-  }
-}
-
-
-/*
-** 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.
-*/
-static u8 sqlite3Fts5GetVarint(const unsigned char *p, u64 *v){
-  u32 a,b,s;
-
-  a = *p;
-  /* a: p0 (unmasked) */
-  if (!(a&0x80))
-  {
-    *v = a;
-    return 1;
-  }
-
-  p++;
-  b = *p;
-  /* b: p1 (unmasked) */
-  if (!(b&0x80))
-  {
-    a &= 0x7f;
-    a = a<<7;
-    a |= b;
-    *v = a;
-    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)) );
-
-  p++;
-  a = a<<14;
-  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 in calc'ing 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;
-}
-
-/*
-** 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
-*/
-
-#ifdef SQLITE_NOINLINE
-# define FTS5_NOINLINE SQLITE_NOINLINE
-#else
-# define FTS5_NOINLINE
-#endif
-
-/*
-** 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 FTS5_NOINLINE fts5PutVarint64(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;
-}
-
-static int sqlite3Fts5PutVarint(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 fts5PutVarint64(p,v);
-}
-
-
-static int sqlite3Fts5GetVarintLen(u32 iVal){
-#if 0
-  if( iVal<(1 << 7 ) ) return 1;
-#endif
-  assert( iVal>=(1 << 7) );
-  if( iVal<(1 << 14) ) return 2;
-  if( iVal<(1 << 21) ) return 3;
-  if( iVal<(1 << 28) ) return 4;
-  return 5;
-}
-
-/*
-** 2015 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.
-**
-******************************************************************************
-**
-** This is an SQLite virtual table module implementing direct access to an
-** existing FTS5 index. The module may create several different types of
-** tables:
-**
-** col:
-**     CREATE TABLE vocab(term, col, doc, cnt, PRIMARY KEY(term, col));
-**
-**   One row for each term/column combination. The value of $doc is set to
-**   the number of fts5 rows that contain at least one instance of term
-**   $term within column $col. Field $cnt is set to the total number of
-**   instances of term $term in column $col (in any row of the fts5 table).
-**
-** row:
-**     CREATE TABLE vocab(term, doc, cnt, PRIMARY KEY(term));
-**
-**   One row for each term in the database. The value of $doc is set to
-**   the number of fts5 rows that contain at least one instance of term
-**   $term. Field $cnt is set to the total number of instances of term
-**   $term in the database.
-**
-** instance:
-**     CREATE TABLE vocab(term, doc, col, offset, PRIMARY KEY(<all-fields>));
-**
-**   One row for each term instance in the database.
-*/
-
-
-/* #include "fts5Int.h" */
-
-
-typedef struct Fts5VocabTable Fts5VocabTable;
-typedef struct Fts5VocabCursor Fts5VocabCursor;
-
-struct Fts5VocabTable {
-  sqlite3_vtab base;
-  char *zFts5Tbl;                 /* Name of fts5 table */
-  char *zFts5Db;                  /* Db containing fts5 table */
-  sqlite3 *db;                    /* Database handle */
-  Fts5Global *pGlobal;            /* FTS5 global object for this database */
-  int eType;                      /* FTS5_VOCAB_COL, ROW or INSTANCE */
-  unsigned bBusy;                 /* True if busy */
-};
-
-struct Fts5VocabCursor {
-  sqlite3_vtab_cursor base;
-  sqlite3_stmt *pStmt;            /* Statement holding lock on pIndex */
-  Fts5Table *pFts5;               /* Associated FTS5 table */
-
-  int bEof;                       /* True if this cursor is at EOF */
-  Fts5IndexIter *pIter;           /* Term/rowid iterator object */
-  void *pStruct;                  /* From sqlite3Fts5StructureRef() */
-
-  int nLeTerm;                    /* Size of zLeTerm in bytes */
-  char *zLeTerm;                  /* (term <= $zLeTerm) paramater, or NULL */
-  int colUsed;                    /* Copy of sqlite3_index_info.colUsed */
-
-  /* These are used by 'col' tables only */
-  int iCol;
-  i64 *aCnt;
-  i64 *aDoc;
-
-  /* Output values used by all tables. */
-  i64 rowid;                      /* This table's current rowid value */
-  Fts5Buffer term;                /* Current value of 'term' column */
-
-  /* Output values Used by 'instance' tables only */
-  i64 iInstPos;
-  int iInstOff;
-};
-
-#define FTS5_VOCAB_COL      0
-#define FTS5_VOCAB_ROW      1
-#define FTS5_VOCAB_INSTANCE 2
-
-#define FTS5_VOCAB_COL_SCHEMA  "term, col, doc, cnt"
-#define FTS5_VOCAB_ROW_SCHEMA  "term, doc, cnt"
-#define FTS5_VOCAB_INST_SCHEMA "term, doc, col, offset"
-
-/*
-** Bits for the mask used as the idxNum value by xBestIndex/xFilter.
-*/
-#define FTS5_VOCAB_TERM_EQ 0x0100
-#define FTS5_VOCAB_TERM_GE 0x0200
-#define FTS5_VOCAB_TERM_LE 0x0400
-
-#define FTS5_VOCAB_COLUSED_MASK 0xFF
-
-
-/*
-** Translate a string containing an fts5vocab table type to an
-** FTS5_VOCAB_XXX constant. If successful, set *peType to the output
-** value and return SQLITE_OK. Otherwise, set *pzErr to an error message
-** and return SQLITE_ERROR.
-*/
-static int fts5VocabTableType(const char *zType, char **pzErr, int *peType){
-  int rc = SQLITE_OK;
-  char *zCopy = sqlite3Fts5Strndup(&rc, zType, -1);
-  if( rc==SQLITE_OK ){
-    sqlite3Fts5Dequote(zCopy);
-    if( sqlite3_stricmp(zCopy, "col")==0 ){
-      *peType = FTS5_VOCAB_COL;
-    }else
-
-    if( sqlite3_stricmp(zCopy, "row")==0 ){
-      *peType = FTS5_VOCAB_ROW;
-    }else
-    if( sqlite3_stricmp(zCopy, "instance")==0 ){
-      *peType = FTS5_VOCAB_INSTANCE;
-    }else
-    {
-      *pzErr = sqlite3_mprintf("fts5vocab: unknown table type: %Q", zCopy);
-      rc = SQLITE_ERROR;
-    }
-    sqlite3_free(zCopy);
-  }
-
-  return rc;
-}
-
-
-/*
-** The xDisconnect() virtual table method.
-*/
-static int fts5VocabDisconnectMethod(sqlite3_vtab *pVtab){
-  Fts5VocabTable *pTab = (Fts5VocabTable*)pVtab;
-  sqlite3_free(pTab);
-  return SQLITE_OK;
-}
-
-/*
-** The xDestroy() virtual table method.
-*/
-static int fts5VocabDestroyMethod(sqlite3_vtab *pVtab){
-  Fts5VocabTable *pTab = (Fts5VocabTable*)pVtab;
-  sqlite3_free(pTab);
-  return SQLITE_OK;
-}
-
-/*
-** This function is the implementation of both the xConnect and xCreate
-** methods of the FTS3 virtual table.
-**
-** The argv[] array contains the following:
-**
-**   argv[0]   -> module name  ("fts5vocab")
-**   argv[1]   -> database name
-**   argv[2]   -> table name
-**
-** then:
-**
-**   argv[3]   -> name of fts5 table
-**   argv[4]   -> type of fts5vocab table
-**
-** or, for tables in the TEMP schema only.
-**
-**   argv[3]   -> name of fts5 tables database
-**   argv[4]   -> name of fts5 table
-**   argv[5]   -> type of fts5vocab table
-*/
-static int fts5VocabInitVtab(
-  sqlite3 *db,                    /* The SQLite database connection */
-  void *pAux,                     /* Pointer to Fts5Global object */
-  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 */
-){
-  const char *azSchema[] = {
-    "CREATE TABlE vocab(" FTS5_VOCAB_COL_SCHEMA  ")",
-    "CREATE TABlE vocab(" FTS5_VOCAB_ROW_SCHEMA  ")",
-    "CREATE TABlE vocab(" FTS5_VOCAB_INST_SCHEMA ")"
-  };
-
-  Fts5VocabTable *pRet = 0;
-  int rc = SQLITE_OK;             /* Return code */
-  int bDb;
-
-  bDb = (argc==6 && strlen(argv[1])==4 && memcmp("temp", argv[1], 4)==0);
-
-  if( argc!=5 && bDb==0 ){
-    *pzErr = sqlite3_mprintf("wrong number of vtable arguments");
-    rc = SQLITE_ERROR;
-  }else{
-    i64 nByte;                      /* Bytes of space to allocate */
-    const char *zDb = bDb ? argv[3] : argv[1];
-    const char *zTab = bDb ? argv[4] : argv[3];
-    const char *zType = bDb ? argv[5] : argv[4];
-    i64 nDb = strlen(zDb)+1;
-    i64 nTab = strlen(zTab)+1;
-    int eType = 0;
-
-    rc = fts5VocabTableType(zType, pzErr, &eType);
-    if( rc==SQLITE_OK ){
-      assert( eType>=0 && eType<ArraySize(azSchema) );
-      rc = sqlite3_declare_vtab(db, azSchema[eType]);
-    }
-
-    nByte = sizeof(Fts5VocabTable) + nDb + nTab;
-    pRet = sqlite3Fts5MallocZero(&rc, nByte);
-    if( pRet ){
-      pRet->pGlobal = (Fts5Global*)pAux;
-      pRet->eType = eType;
-      pRet->db = db;
-      pRet->zFts5Tbl = (char*)&pRet[1];
-      pRet->zFts5Db = &pRet->zFts5Tbl[nTab];
-      memcpy(pRet->zFts5Tbl, zTab, nTab);
-      memcpy(pRet->zFts5Db, zDb, nDb);
-      sqlite3Fts5Dequote(pRet->zFts5Tbl);
-      sqlite3Fts5Dequote(pRet->zFts5Db);
-    }
-  }
-
-  *ppVTab = (sqlite3_vtab*)pRet;
-  return rc;
-}
-
-
-/*
-** The xConnect() and xCreate() methods for the virtual table. All the
-** work is done in function fts5VocabInitVtab().
-*/
-static int fts5VocabConnectMethod(
-  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 fts5VocabInitVtab(db, pAux, argc, argv, ppVtab, pzErr);
-}
-static int fts5VocabCreateMethod(
-  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 fts5VocabInitVtab(db, pAux, argc, argv, ppVtab, pzErr);
-}
-
-/*
-** Implementation of the xBestIndex method.
-**
-** Only constraints of the form:
-**
-**     term <= ?
-**     term == ?
-**     term >= ?
-**
-** are interpreted. Less-than and less-than-or-equal are treated
-** identically, as are greater-than and greater-than-or-equal.
-*/
-static int fts5VocabBestIndexMethod(
-  sqlite3_vtab *pUnused,
-  sqlite3_index_info *pInfo
-){
-  int i;
-  int iTermEq = -1;
-  int iTermGe = -1;
-  int iTermLe = -1;
-  int idxNum = (int)pInfo->colUsed;
-  int nArg = 0;
-
-  UNUSED_PARAM(pUnused);
-
-  assert( (pInfo->colUsed & FTS5_VOCAB_COLUSED_MASK)==pInfo->colUsed );
-
-  for(i=0; i<pInfo->nConstraint; i++){
-    struct sqlite3_index_constraint *p = &pInfo->aConstraint[i];
-    if( p->usable==0 ) continue;
-    if( p->iColumn==0 ){          /* term column */
-      if( p->op==SQLITE_INDEX_CONSTRAINT_EQ ) iTermEq = i;
-      if( p->op==SQLITE_INDEX_CONSTRAINT_LE ) iTermLe = i;
-      if( p->op==SQLITE_INDEX_CONSTRAINT_LT ) iTermLe = i;
-      if( p->op==SQLITE_INDEX_CONSTRAINT_GE ) iTermGe = i;
-      if( p->op==SQLITE_INDEX_CONSTRAINT_GT ) iTermGe = i;
-    }
-  }
-
-  if( iTermEq>=0 ){
-    idxNum |= FTS5_VOCAB_TERM_EQ;
-    pInfo->aConstraintUsage[iTermEq].argvIndex = ++nArg;
-    pInfo->estimatedCost = 100;
-  }else{
-    pInfo->estimatedCost = 1000000;
-    if( iTermGe>=0 ){
-      idxNum |= FTS5_VOCAB_TERM_GE;
-      pInfo->aConstraintUsage[iTermGe].argvIndex = ++nArg;
-      pInfo->estimatedCost = pInfo->estimatedCost / 2;
-    }
-    if( iTermLe>=0 ){
-      idxNum |= FTS5_VOCAB_TERM_LE;
-      pInfo->aConstraintUsage[iTermLe].argvIndex = ++nArg;
-      pInfo->estimatedCost = pInfo->estimatedCost / 2;
-    }
-  }
-
-  /* This virtual table always delivers results in ascending order of
-  ** the "term" column (column 0). So if the user has requested this
-  ** specifically - "ORDER BY term" or "ORDER BY term ASC" - set the
-  ** sqlite3_index_info.orderByConsumed flag to tell the core the results
-  ** are already in sorted order.  */
-  if( pInfo->nOrderBy==1
-   && pInfo->aOrderBy[0].iColumn==0
-   && pInfo->aOrderBy[0].desc==0
-  ){
-    pInfo->orderByConsumed = 1;
-  }
-
-  pInfo->idxNum = idxNum;
-  return SQLITE_OK;
-}
-
-/*
-** Implementation of xOpen method.
-*/
-static int fts5VocabOpenMethod(
-  sqlite3_vtab *pVTab,
-  sqlite3_vtab_cursor **ppCsr
-){
-  Fts5VocabTable *pTab = (Fts5VocabTable*)pVTab;
-  Fts5Table *pFts5 = 0;
-  Fts5VocabCursor *pCsr = 0;
-  int rc = SQLITE_OK;
-  sqlite3_stmt *pStmt = 0;
-  char *zSql = 0;
-
-  if( pTab->bBusy ){
-    pVTab->zErrMsg = sqlite3_mprintf(
-       "recursive definition for %s.%s", pTab->zFts5Db, pTab->zFts5Tbl
-    );
-    return SQLITE_ERROR;
-  }
-  zSql = sqlite3Fts5Mprintf(&rc,
-      "SELECT t.%Q FROM %Q.%Q AS t WHERE t.%Q MATCH '*id'",
-      pTab->zFts5Tbl, pTab->zFts5Db, pTab->zFts5Tbl, pTab->zFts5Tbl
-  );
-  if( zSql ){
-    rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0);
-  }
-  sqlite3_free(zSql);
-  assert( rc==SQLITE_OK || pStmt==0 );
-  if( rc==SQLITE_ERROR ) rc = SQLITE_OK;
-
-  pTab->bBusy = 1;
-  if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
-    i64 iId = sqlite3_column_int64(pStmt, 0);
-    pFts5 = sqlite3Fts5TableFromCsrid(pTab->pGlobal, iId);
-  }
-  pTab->bBusy = 0;
-
-  if( rc==SQLITE_OK ){
-    if( pFts5==0 ){
-      rc = sqlite3_finalize(pStmt);
-      pStmt = 0;
-      if( rc==SQLITE_OK ){
-        pVTab->zErrMsg = sqlite3_mprintf(
-            "no such fts5 table: %s.%s", pTab->zFts5Db, pTab->zFts5Tbl
-        );
-        rc = SQLITE_ERROR;
-      }
-    }else{
-      rc = sqlite3Fts5FlushToDisk(pFts5);
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    i64 nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor);
-    pCsr = (Fts5VocabCursor*)sqlite3Fts5MallocZero(&rc, nByte);
-  }
-
-  if( pCsr ){
-    pCsr->pFts5 = pFts5;
-    pCsr->pStmt = pStmt;
-    pCsr->aCnt = (i64*)&pCsr[1];
-    pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
-  }else{
-    sqlite3_finalize(pStmt);
-  }
-
-  *ppCsr = (sqlite3_vtab_cursor*)pCsr;
-  return rc;
-}
-
-/*
-** Restore cursor pCsr to the state it was in immediately after being
-** created by the xOpen() method.
-*/
-static void fts5VocabResetCursor(Fts5VocabCursor *pCsr){
-  int nCol = pCsr->pFts5->pConfig->nCol;
-  pCsr->rowid = 0;
-  sqlite3Fts5IterClose(pCsr->pIter);
-  sqlite3Fts5StructureRelease(pCsr->pStruct);
-  pCsr->pStruct = 0;
-  pCsr->pIter = 0;
-  sqlite3_free(pCsr->zLeTerm);
-  pCsr->nLeTerm = -1;
-  pCsr->zLeTerm = 0;
-  pCsr->bEof = 0;
-  pCsr->iCol = 0;
-  pCsr->iInstPos = 0;
-  pCsr->iInstOff = 0;
-  pCsr->colUsed = 0;
-  memset(pCsr->aCnt, 0, sizeof(i64)*nCol);
-  memset(pCsr->aDoc, 0, sizeof(i64)*nCol);
-}
-
-/*
-** Close the cursor.  For additional information see the documentation
-** on the xClose method of the virtual table interface.
-*/
-static int fts5VocabCloseMethod(sqlite3_vtab_cursor *pCursor){
-  Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
-  fts5VocabResetCursor(pCsr);
-  sqlite3Fts5BufferFree(&pCsr->term);
-  sqlite3_finalize(pCsr->pStmt);
-  sqlite3_free(pCsr);
-  return SQLITE_OK;
-}
-
-static int fts5VocabInstanceNewTerm(Fts5VocabCursor *pCsr){
-  int rc = SQLITE_OK;
-
-  if( sqlite3Fts5IterEof(pCsr->pIter) ){
-    pCsr->bEof = 1;
-  }else{
-    const char *zTerm;
-    int nTerm;
-    zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
-    if( pCsr->nLeTerm>=0 ){
-      int nCmp = MIN(nTerm, pCsr->nLeTerm);
-      int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
-      if( bCmp<0 || (bCmp==0 && pCsr->nLeTerm<nTerm) ){
-        pCsr->bEof = 1;
-      }
-    }
-
-    sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
-  }
-  return rc;
-}
-
-static int fts5VocabInstanceNext(Fts5VocabCursor *pCsr){
-  int eDetail = pCsr->pFts5->pConfig->eDetail;
-  int rc = SQLITE_OK;
-  Fts5IndexIter *pIter = pCsr->pIter;
-  i64 *pp = &pCsr->iInstPos;
-  int *po = &pCsr->iInstOff;
-
-  assert( sqlite3Fts5IterEof(pIter)==0 );
-  assert( pCsr->bEof==0 );
-  while( eDetail==FTS5_DETAIL_NONE
-      || sqlite3Fts5PoslistNext64(pIter->pData, pIter->nData, po, pp)
-  ){
-    pCsr->iInstPos = 0;
-    pCsr->iInstOff = 0;
-
-    rc = sqlite3Fts5IterNextScan(pCsr->pIter);
-    if( rc==SQLITE_OK ){
-      rc = fts5VocabInstanceNewTerm(pCsr);
-      if( pCsr->bEof || eDetail==FTS5_DETAIL_NONE ) break;
-    }
-    if( rc ){
-      pCsr->bEof = 1;
-      break;
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Advance the cursor to the next row in the table.
-*/
-static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
-  Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
-  Fts5VocabTable *pTab = (Fts5VocabTable*)pCursor->pVtab;
-  int nCol = pCsr->pFts5->pConfig->nCol;
-  int rc;
-
-  rc = sqlite3Fts5StructureTest(pCsr->pFts5->pIndex, pCsr->pStruct);
-  if( rc!=SQLITE_OK ) return rc;
-  pCsr->rowid++;
-
-  if( pTab->eType==FTS5_VOCAB_INSTANCE ){
-    return fts5VocabInstanceNext(pCsr);
-  }
-
-  if( pTab->eType==FTS5_VOCAB_COL ){
-    for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
-      if( pCsr->aDoc[pCsr->iCol] ) break;
-    }
-  }
-
-  if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
-    if( sqlite3Fts5IterEof(pCsr->pIter) ){
-      pCsr->bEof = 1;
-    }else{
-      const char *zTerm;
-      int nTerm;
-
-      zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
-      assert( nTerm>=0 );
-      if( pCsr->nLeTerm>=0 ){
-        int nCmp = MIN(nTerm, pCsr->nLeTerm);
-        int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
-        if( bCmp<0 || (bCmp==0 && pCsr->nLeTerm<nTerm) ){
-          pCsr->bEof = 1;
-          return SQLITE_OK;
-        }
-      }
-
-      sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
-      memset(pCsr->aCnt, 0, nCol * sizeof(i64));
-      memset(pCsr->aDoc, 0, nCol * sizeof(i64));
-      pCsr->iCol = 0;
-
-      assert( pTab->eType==FTS5_VOCAB_COL || pTab->eType==FTS5_VOCAB_ROW );
-      while( rc==SQLITE_OK ){
-        int eDetail = pCsr->pFts5->pConfig->eDetail;
-        const u8 *pPos; int nPos;   /* Position list */
-        i64 iPos = 0;               /* 64-bit position read from poslist */
-        int iOff = 0;               /* Current offset within position list */
-
-        pPos = pCsr->pIter->pData;
-        nPos = pCsr->pIter->nData;
-
-        switch( pTab->eType ){
-          case FTS5_VOCAB_ROW:
-            /* Do not bother counting the number of instances if the "cnt"
-            ** column is not being read (according to colUsed).  */
-            if( eDetail==FTS5_DETAIL_FULL && (pCsr->colUsed & 0x04) ){
-              while( iPos<nPos ){
-                u32 ii;
-                fts5FastGetVarint32(pPos, iPos, ii);
-                if( ii==1 ){
-                  /* New column in the position list */
-                  fts5FastGetVarint32(pPos, iPos, ii);
-                }else{
-                  /* An instance - increment pCsr->aCnt[] */
-                  pCsr->aCnt[0]++;
-                }
-              }
-            }
-            pCsr->aDoc[0]++;
-            break;
-
-          case FTS5_VOCAB_COL:
-            if( eDetail==FTS5_DETAIL_FULL ){
-              int iCol = -1;
-              while( 0==sqlite3Fts5PoslistNext64(pPos, nPos, &iOff, &iPos) ){
-                int ii = FTS5_POS2COLUMN(iPos);
-                if( iCol!=ii ){
-                  if( ii>=nCol ){
-                    rc = FTS5_CORRUPT;
-                    break;
-                  }
-                  pCsr->aDoc[ii]++;
-                  iCol = ii;
-                }
-                pCsr->aCnt[ii]++;
-              }
-            }else if( eDetail==FTS5_DETAIL_COLUMNS ){
-              while( 0==sqlite3Fts5PoslistNext64(pPos, nPos, &iOff,&iPos) ){
-                assert_nc( iPos>=0 && iPos<nCol );
-                if( iPos>=nCol ){
-                  rc = FTS5_CORRUPT;
-                  break;
-                }
-                pCsr->aDoc[iPos]++;
-              }
-            }else{
-              assert( eDetail==FTS5_DETAIL_NONE );
-              pCsr->aDoc[0]++;
-            }
-            break;
-
-          default:
-            assert( pTab->eType==FTS5_VOCAB_INSTANCE );
-            break;
-        }
-
-        if( rc==SQLITE_OK ){
-          rc = sqlite3Fts5IterNextScan(pCsr->pIter);
-        }
-        if( pTab->eType==FTS5_VOCAB_INSTANCE ) break;
-
-        if( rc==SQLITE_OK ){
-          zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
-          if( nTerm!=pCsr->term.n
-          || (nTerm>0 && memcmp(zTerm, pCsr->term.p, nTerm))
-          ){
-            break;
-          }
-          if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
-        }
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
-    for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
-    if( pCsr->iCol==nCol ){
-      rc = FTS5_CORRUPT;
-    }
-  }
-  return rc;
-}
-
-/*
-** This is the xFilter implementation for the virtual table.
-*/
-static int fts5VocabFilterMethod(
-  sqlite3_vtab_cursor *pCursor,   /* The cursor used for this query */
-  int idxNum,                     /* Strategy index */
-  const char *zUnused,            /* Unused */
-  int nUnused,                    /* Number of elements in apVal */
-  sqlite3_value **apVal           /* Arguments for the indexing scheme */
-){
-  Fts5VocabTable *pTab = (Fts5VocabTable*)pCursor->pVtab;
-  Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
-  int eType = pTab->eType;
-  int rc = SQLITE_OK;
-
-  int iVal = 0;
-  int f = FTS5INDEX_QUERY_SCAN;
-  const char *zTerm = 0;
-  int nTerm = 0;
-
-  sqlite3_value *pEq = 0;
-  sqlite3_value *pGe = 0;
-  sqlite3_value *pLe = 0;
-
-  UNUSED_PARAM2(zUnused, nUnused);
-
-  fts5VocabResetCursor(pCsr);
-  if( idxNum & FTS5_VOCAB_TERM_EQ ) pEq = apVal[iVal++];
-  if( idxNum & FTS5_VOCAB_TERM_GE ) pGe = apVal[iVal++];
-  if( idxNum & FTS5_VOCAB_TERM_LE ) pLe = apVal[iVal++];
-  pCsr->colUsed = (idxNum & FTS5_VOCAB_COLUSED_MASK);
-
-  if( pEq ){
-    zTerm = (const char *)sqlite3_value_text(pEq);
-    nTerm = sqlite3_value_bytes(pEq);
-    f = FTS5INDEX_QUERY_NOTOKENDATA;
-  }else{
-    if( pGe ){
-      zTerm = (const char *)sqlite3_value_text(pGe);
-      nTerm = sqlite3_value_bytes(pGe);
-    }
-    if( pLe ){
-      const char *zCopy = (const char *)sqlite3_value_text(pLe);
-      if( zCopy==0 ) zCopy = "";
-      pCsr->nLeTerm = sqlite3_value_bytes(pLe);
-      pCsr->zLeTerm = sqlite3_malloc64((i64)pCsr->nLeTerm+1);
-      if( pCsr->zLeTerm==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        memcpy(pCsr->zLeTerm, zCopy, pCsr->nLeTerm+1);
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    Fts5Index *pIndex = pCsr->pFts5->pIndex;
-    rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
-    if( rc==SQLITE_OK ){
-      pCsr->pStruct = sqlite3Fts5StructureRef(pIndex);
-    }
-  }
-  if( rc==SQLITE_OK && eType==FTS5_VOCAB_INSTANCE ){
-    rc = fts5VocabInstanceNewTerm(pCsr);
-  }
-  if( rc==SQLITE_OK && !pCsr->bEof
-   && (eType!=FTS5_VOCAB_INSTANCE
-    || pCsr->pFts5->pConfig->eDetail!=FTS5_DETAIL_NONE)
-  ){
-    rc = fts5VocabNextMethod(pCursor);
-  }
-
-  return rc;
-}
-
-/*
-** 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 fts5VocabEofMethod(sqlite3_vtab_cursor *pCursor){
-  Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
-  return pCsr->bEof;
-}
-
-static int fts5VocabColumnMethod(
-  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 */
-){
-  Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
-  int eDetail = pCsr->pFts5->pConfig->eDetail;
-  int eType = ((Fts5VocabTable*)(pCursor->pVtab))->eType;
-  i64 iVal = 0;
-
-  if( iCol==0 ){
-    sqlite3_result_text(
-        pCtx, (const char*)pCsr->term.p, pCsr->term.n, SQLITE_TRANSIENT
-    );
-  }else if( eType==FTS5_VOCAB_COL ){
-    assert( iCol==1 || iCol==2 || iCol==3 );
-    if( iCol==1 ){
-      if( eDetail!=FTS5_DETAIL_NONE ){
-        const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
-        sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
-      }
-    }else if( iCol==2 ){
-      iVal = pCsr->aDoc[pCsr->iCol];
-    }else{
-      iVal = pCsr->aCnt[pCsr->iCol];
-    }
-  }else if( eType==FTS5_VOCAB_ROW ){
-    assert( iCol==1 || iCol==2 );
-    if( iCol==1 ){
-      iVal = pCsr->aDoc[0];
-    }else{
-      iVal = pCsr->aCnt[0];
-    }
-  }else{
-    assert( eType==FTS5_VOCAB_INSTANCE );
-    switch( iCol ){
-      case 1:
-        sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);
-        break;
-      case 2: {
-        int ii = -1;
-        if( eDetail==FTS5_DETAIL_FULL ){
-          ii = FTS5_POS2COLUMN(pCsr->iInstPos);
-        }else if( eDetail==FTS5_DETAIL_COLUMNS ){
-          ii = (int)pCsr->iInstPos;
-        }
-        if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){
-          const char *z = pCsr->pFts5->pConfig->azCol[ii];
-          sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
-        }
-        break;
-      }
-      default: {
-        assert( iCol==3 );
-        if( eDetail==FTS5_DETAIL_FULL ){
-          int ii = FTS5_POS2OFFSET(pCsr->iInstPos);
-          sqlite3_result_int(pCtx, ii);
-        }
-        break;
-      }
-    }
-  }
-
-  if( iVal>0 ) sqlite3_result_int64(pCtx, iVal);
-  return SQLITE_OK;
-}
-
-/*
-** This is the xRowid method. The SQLite core calls this routine to
-** retrieve the rowid for the current row of the result set. The
-** rowid should be written to *pRowid.
-*/
-static int fts5VocabRowidMethod(
-  sqlite3_vtab_cursor *pCursor,
-  sqlite_int64 *pRowid
-){
-  Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
-  *pRowid = pCsr->rowid;
-  return SQLITE_OK;
-}
-
-static int sqlite3Fts5VocabInit(Fts5Global *pGlobal, sqlite3 *db){
-  static const sqlite3_module fts5Vocab = {
-    /* iVersion      */ 2,
-    /* xCreate       */ fts5VocabCreateMethod,
-    /* xConnect      */ fts5VocabConnectMethod,
-    /* xBestIndex    */ fts5VocabBestIndexMethod,
-    /* xDisconnect   */ fts5VocabDisconnectMethod,
-    /* xDestroy      */ fts5VocabDestroyMethod,
-    /* xOpen         */ fts5VocabOpenMethod,
-    /* xClose        */ fts5VocabCloseMethod,
-    /* xFilter       */ fts5VocabFilterMethod,
-    /* xNext         */ fts5VocabNextMethod,
-    /* xEof          */ fts5VocabEofMethod,
-    /* xColumn       */ fts5VocabColumnMethod,
-    /* xRowid        */ fts5VocabRowidMethod,
-    /* xUpdate       */ 0,
-    /* xBegin        */ 0,
-    /* xSync         */ 0,
-    /* xCommit       */ 0,
-    /* xRollback     */ 0,
-    /* xFindFunction */ 0,
-    /* xRename       */ 0,
-    /* xSavepoint    */ 0,
-    /* xRelease      */ 0,
-    /* xRollbackTo   */ 0,
-    /* xShadowName   */ 0,
-    /* xIntegrity    */ 0
-  };
-  void *p = (void*)pGlobal;
-
-  return sqlite3_create_module_v2(db, "fts5vocab", &fts5Vocab, p, 0);
-}
-
-
-/* Here ends the fts5.c composite file. */
-#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS5) */
-
-/************** End of fts5.c ************************************************/
-/************** Begin file stmt.c ********************************************/
-/*
-** 2017-05-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 demonstrates an eponymous virtual table that returns information
-** about all prepared statements for the database connection.
-**
-** Usage example:
-**
-**     .load ./stmt
-**     .mode line
-**     .header on
-**     SELECT * FROM stmt;
-*/
-#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB)
-#if !defined(SQLITEINT_H)
-/* #include "sqlite3ext.h" */
-#endif
-SQLITE_EXTENSION_INIT1
-/* #include <assert.h> */
-/* #include <string.h> */
-
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-
-
-#define STMT_NUM_INTEGER_COLUMN 10
-typedef struct StmtRow StmtRow;
-struct StmtRow {
-  sqlite3_int64 iRowid;                /* Rowid value */
-  char *zSql;                          /* column "sql" */
-  int aCol[STMT_NUM_INTEGER_COLUMN+1]; /* all other column values */
-  StmtRow *pNext;                      /* Next row to return */
-};
-
-/* stmt_vtab is a subclass of sqlite3_vtab which will
-** serve as the underlying representation of a stmt virtual table
-*/
-typedef struct stmt_vtab stmt_vtab;
-struct stmt_vtab {
-  sqlite3_vtab base;  /* Base class - must be first */
-  sqlite3 *db;        /* Database connection for this stmt vtab */
-};
-
-/* stmt_cursor is a subclass of sqlite3_vtab_cursor which will
-** serve as the underlying representation of a cursor that scans
-** over rows of the result
-*/
-typedef struct stmt_cursor stmt_cursor;
-struct stmt_cursor {
-  sqlite3_vtab_cursor base;  /* Base class - must be first */
-  sqlite3 *db;               /* Database connection for this cursor */
-  StmtRow *pRow;             /* Current row */
-};
-
-/*
-** The stmtConnect() method is invoked to create a new
-** stmt_vtab that describes the stmt virtual table.
-**
-** Think of this routine as the constructor for stmt_vtab objects.
-**
-** All this routine needs to do is:
-**
-**    (1) Allocate the stmt_vtab object and initialize all fields.
-**
-**    (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
-**        result set of queries against stmt will look like.
-*/
-static int stmtConnect(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  stmt_vtab *pNew;
-  int rc;
-
-/* Column numbers */
-#define STMT_COLUMN_SQL     0   /* SQL for the statement */
-#define STMT_COLUMN_NCOL    1   /* Number of result columns */
-#define STMT_COLUMN_RO      2   /* True if read-only */
-#define STMT_COLUMN_BUSY    3   /* True if currently busy */
-#define STMT_COLUMN_NSCAN   4   /* SQLITE_STMTSTATUS_FULLSCAN_STEP */
-#define STMT_COLUMN_NSORT   5   /* SQLITE_STMTSTATUS_SORT */
-#define STMT_COLUMN_NAIDX   6   /* SQLITE_STMTSTATUS_AUTOINDEX */
-#define STMT_COLUMN_NSTEP   7   /* SQLITE_STMTSTATUS_VM_STEP */
-#define STMT_COLUMN_REPREP  8   /* SQLITE_STMTSTATUS_REPREPARE */
-#define STMT_COLUMN_RUN     9   /* SQLITE_STMTSTATUS_RUN */
-#define STMT_COLUMN_MEM    10   /* SQLITE_STMTSTATUS_MEMUSED */
-
-
-  (void)pAux;
-  (void)argc;
-  (void)argv;
-  (void)pzErr;
-  rc = sqlite3_declare_vtab(db,
-     "CREATE TABLE x(sql,ncol,ro,busy,nscan,nsort,naidx,nstep,"
-                    "reprep,run,mem)");
-  if( rc==SQLITE_OK ){
-    pNew = sqlite3_malloc64( sizeof(*pNew) );
-    *ppVtab = (sqlite3_vtab*)pNew;
-    if( pNew==0 ) return SQLITE_NOMEM;
-    memset(pNew, 0, sizeof(*pNew));
-    pNew->db = db;
-  }
-  return rc;
-}
-
-/*
-** This method is the destructor for stmt_cursor objects.
-*/
-static int stmtDisconnect(sqlite3_vtab *pVtab){
-  sqlite3_free(pVtab);
-  return SQLITE_OK;
-}
-
-/*
-** Constructor for a new stmt_cursor object.
-*/
-static int stmtOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
-  stmt_cursor *pCur;
-  pCur = sqlite3_malloc64( sizeof(*pCur) );
-  if( pCur==0 ) return SQLITE_NOMEM;
-  memset(pCur, 0, sizeof(*pCur));
-  pCur->db = ((stmt_vtab*)p)->db;
-  *ppCursor = &pCur->base;
-  return SQLITE_OK;
-}
-
-static void stmtCsrReset(stmt_cursor *pCur){
-  StmtRow *pRow = 0;
-  StmtRow *pNext = 0;
-  for(pRow=pCur->pRow; pRow; pRow=pNext){
-    pNext = pRow->pNext;
-    sqlite3_free(pRow);
-  }
-  pCur->pRow = 0;
-}
-
-/*
-** Destructor for a stmt_cursor.
-*/
-static int stmtClose(sqlite3_vtab_cursor *cur){
-  stmtCsrReset((stmt_cursor*)cur);
-  sqlite3_free(cur);
-  return SQLITE_OK;
-}
-
-
-/*
-** Advance a stmt_cursor to its next row of output.
-*/
-static int stmtNext(sqlite3_vtab_cursor *cur){
-  stmt_cursor *pCur = (stmt_cursor*)cur;
-  StmtRow *pNext = pCur->pRow->pNext;
-  sqlite3_free(pCur->pRow);
-  pCur->pRow = pNext;
-  return SQLITE_OK;
-}
-
-/*
-** Return values of columns for the row at which the stmt_cursor
-** is currently pointing.
-*/
-static int stmtColumn(
-  sqlite3_vtab_cursor *cur,   /* The cursor */
-  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */
-  int i                       /* Which column to return */
-){
-  stmt_cursor *pCur = (stmt_cursor*)cur;
-  StmtRow *pRow = pCur->pRow;
-  if( i==STMT_COLUMN_SQL ){
-    sqlite3_result_text(ctx, pRow->zSql, -1, SQLITE_TRANSIENT);
-  }else{
-    sqlite3_result_int(ctx, pRow->aCol[i]);
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Return the rowid for the current row.  In this implementation, the
-** rowid is the same as the output value.
-*/
-static int stmtRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
-  stmt_cursor *pCur = (stmt_cursor*)cur;
-  *pRowid = pCur->pRow->iRowid;
-  return SQLITE_OK;
-}
-
-/*
-** Return TRUE if the cursor has been moved off of the last
-** row of output.
-*/
-static int stmtEof(sqlite3_vtab_cursor *cur){
-  stmt_cursor *pCur = (stmt_cursor*)cur;
-  return pCur->pRow==0;
-}
-
-/*
-** This method is called to "rewind" the stmt_cursor object back
-** to the first row of output.  This method is always called at least
-** once prior to any call to stmtColumn() or stmtRowid() or
-** stmtEof().
-*/
-static int stmtFilter(
-  sqlite3_vtab_cursor *pVtabCursor,
-  int idxNum, const char *idxStr,
-  int argc, sqlite3_value **argv
-){
-  stmt_cursor *pCur = (stmt_cursor *)pVtabCursor;
-  sqlite3_stmt *p = 0;
-  sqlite3_int64 iRowid = 1;
-  StmtRow **ppRow = 0;
-
-  (void)idxNum;
-  (void)idxStr;
-  (void)argc;
-  (void)argv;
-  stmtCsrReset(pCur);
-  ppRow = &pCur->pRow;
-  for(p=sqlite3_next_stmt(pCur->db, 0); p; p=sqlite3_next_stmt(pCur->db, p)){
-    const char *zSql = sqlite3_sql(p);
-    sqlite3_int64 nSql = zSql ? strlen(zSql)+1 : 0;
-    StmtRow *pNew = (StmtRow*)sqlite3_malloc64(sizeof(StmtRow) + nSql);
-
-    if( pNew==0 ) return SQLITE_NOMEM;
-    memset(pNew, 0, sizeof(StmtRow));
-    if( zSql ){
-      pNew->zSql = (char*)&pNew[1];
-      memcpy(pNew->zSql, zSql, nSql);
-    }
-    pNew->aCol[STMT_COLUMN_NCOL] = sqlite3_column_count(p);
-    pNew->aCol[STMT_COLUMN_RO] = sqlite3_stmt_readonly(p);
-    pNew->aCol[STMT_COLUMN_BUSY] = sqlite3_stmt_busy(p);
-    pNew->aCol[STMT_COLUMN_NSCAN] = sqlite3_stmt_status(
-        p, SQLITE_STMTSTATUS_FULLSCAN_STEP, 0
-    );
-    pNew->aCol[STMT_COLUMN_NSORT] = sqlite3_stmt_status(
-        p, SQLITE_STMTSTATUS_SORT, 0
-    );
-    pNew->aCol[STMT_COLUMN_NAIDX] = sqlite3_stmt_status(
-        p, SQLITE_STMTSTATUS_AUTOINDEX, 0
-    );
-    pNew->aCol[STMT_COLUMN_NSTEP] = sqlite3_stmt_status(
-        p, SQLITE_STMTSTATUS_VM_STEP, 0
-    );
-    pNew->aCol[STMT_COLUMN_REPREP] = sqlite3_stmt_status(
-        p, SQLITE_STMTSTATUS_REPREPARE, 0
-    );
-    pNew->aCol[STMT_COLUMN_RUN] = sqlite3_stmt_status(
-        p, SQLITE_STMTSTATUS_RUN, 0
-    );
-    pNew->aCol[STMT_COLUMN_MEM] = sqlite3_stmt_status(
-        p, SQLITE_STMTSTATUS_MEMUSED, 0
-    );
-    pNew->iRowid = iRowid++;
-    *ppRow = pNew;
-    ppRow = &pNew->pNext;
-  }
-
-  return SQLITE_OK;
-}
-
-/*
-** SQLite will invoke this method one or more times while planning a query
-** that uses the stmt virtual table.  This routine needs to create
-** a query plan for each invocation and compute an estimated cost for that
-** plan.
-*/
-static int stmtBestIndex(
-  sqlite3_vtab *tab,
-  sqlite3_index_info *pIdxInfo
-){
-  (void)tab;
-  pIdxInfo->estimatedCost = (double)500;
-  pIdxInfo->estimatedRows = 500;
-  return SQLITE_OK;
-}
-
-/*
-** This following structure defines all the methods for the
-** stmt virtual table.
-*/
-static sqlite3_module stmtModule = {
-  0,                         /* iVersion */
-  0,                         /* xCreate */
-  stmtConnect,               /* xConnect */
-  stmtBestIndex,             /* xBestIndex */
-  stmtDisconnect,            /* xDisconnect */
-  0,                         /* xDestroy */
-  stmtOpen,                  /* xOpen - open a cursor */
-  stmtClose,                 /* xClose - close a cursor */
-  stmtFilter,                /* xFilter - configure scan constraints */
-  stmtNext,                  /* xNext - advance a cursor */
-  stmtEof,                   /* xEof - check for end of scan */
-  stmtColumn,                /* xColumn - read data */
-  stmtRowid,                 /* 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 */
-  0                          /* xIntegrity */
-};
-
-#endif /* SQLITE_OMIT_VIRTUALTABLE */
-
-SQLITE_PRIVATE int sqlite3StmtVtabInit(sqlite3 *db){
-  int rc = SQLITE_OK;
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  rc = sqlite3_create_module(db, "sqlite_stmt", &stmtModule, 0);
-#endif
-  return rc;
-}
-
-#ifndef SQLITE_CORE
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-SQLITE_API int sqlite3_stmt_init(
-  sqlite3 *db,
-  char **pzErrMsg,
-  const sqlite3_api_routines *pApi
-){
-  int rc = SQLITE_OK;
-  SQLITE_EXTENSION_INIT2(pApi);
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  rc = sqlite3StmtVtabInit(db);
-#endif
-  return rc;
-}
-#endif /* SQLITE_CORE */
-#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */
-
-/************** End of stmt.c ************************************************/
-/* Return the source-id for this library */
-SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
-#endif /* SQLITE_AMALGAMATION */
-/************************** End of sqlite3.c ******************************/
diff --git a/deps/sqlite-amalgamation-3530100/sqlite3.h b/deps/sqlite-amalgamation-3530100/sqlite3.h
deleted file mode 100644
index 8ee26c99..00000000
--- a/deps/sqlite-amalgamation-3530100/sqlite3.h
+++ /dev/null
@@ -1,14335 +0,0 @@
-/*
-** 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 <stdarg.h>     /* Needed for the definition of va_list */
-
-/*
-** Make sure we can call this stuff from C++.
-*/
-#ifdef __cplusplus
-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
-** <a href="http://fossil-scm.org/">Fossil configuration management
-** system</a>.  ^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.53.1"
-#define SQLITE_VERSION_NUMBER 3053001
-#define SQLITE_SOURCE_ID      "2026-05-05 10:34:17 c88b22011a54b4f6fbd149e9f8e4de77658ce58143a1af0e3785e4e6475127e9"
-#define SQLITE_SCM_BRANCH     "branch-3.53"
-#define SQLITE_SCM_TAGS       "release version-3.53.1"
-#define SQLITE_SCM_DATETIME   "2026-05-05T10:34:17.344Z"
-
-/*
-** 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.
-**
-** <blockquote><pre>
-** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
-** assert( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,80)==0 );
-** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
-** </pre></blockquote>)^
-**
-** ^The sqlite3_version[] string constant contains the text of the
-** [SQLITE_VERSION] macro.  ^The sqlite3_libversion() function returns a
-** pointer 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 SQLITE_EXTERN const char sqlite3_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-separated 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 a 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:
-**
-** <ul>
-** <li> The application must ensure that the 1st parameter to sqlite3_exec()
-**      is a valid and open [database connection].
-** <li> The application must not close the [database connection] specified by
-**      the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
-** <li> The application must not modify the SQL statement text passed into
-**      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
-** <li> The application must not dereference the arrays or string pointers
-**       passed as the 3rd and 4th callback parameters after it returns.
-** </ul>
-*/
-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_ERROR_RESERVESIZE       (SQLITE_ERROR | (4<<8))
-#define SQLITE_ERROR_KEY               (SQLITE_ERROR | (5<<8))
-#define SQLITE_ERROR_UNABLE            (SQLITE_ERROR | (6<<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_IOERR_IN_PAGE           (SQLITE_IOERR | (34<<8))
-#define SQLITE_IOERR_BADKEY            (SQLITE_IOERR | (35<<8))
-#define SQLITE_IOERR_CODEC             (SQLITE_IOERR | (36<<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 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 been 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].
-**
-** The SQLITE_IOCAP_SUBPAGE_READ property means that it is ok to read
-** from the database file in amounts that are not a multiple of the
-** page size and that do not begin at a page boundary.  Without this
-** property, SQLite is careful to only do full-page reads and write
-** on aligned pages, with the one exception that it will do a sub-page
-** read of the first page to access the database header.
-*/
-#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
-#define SQLITE_IOCAP_SUBPAGE_READ           0x00008000
-
-/*
-** 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
-** least 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
-** <ul>
-** <li> [SQLITE_LOCK_NONE],
-** <li> [SQLITE_LOCK_SHARED],
-** <li> [SQLITE_LOCK_RESERVED],
-** <li> [SQLITE_LOCK_PENDING], or
-** <li> [SQLITE_LOCK_EXCLUSIVE].
-** </ul>
-** 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 one 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, via its output
-** pointer parameter, 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:
-**
-** <ul>
-** <li> [SQLITE_IOCAP_ATOMIC]
-** <li> [SQLITE_IOCAP_ATOMIC512]
-** <li> [SQLITE_IOCAP_ATOMIC1K]
-** <li> [SQLITE_IOCAP_ATOMIC2K]
-** <li> [SQLITE_IOCAP_ATOMIC4K]
-** <li> [SQLITE_IOCAP_ATOMIC8K]
-** <li> [SQLITE_IOCAP_ATOMIC16K]
-** <li> [SQLITE_IOCAP_ATOMIC32K]
-** <li> [SQLITE_IOCAP_ATOMIC64K]
-** <li> [SQLITE_IOCAP_SAFE_APPEND]
-** <li> [SQLITE_IOCAP_SEQUENTIAL]
-** <li> [SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN]
-** <li> [SQLITE_IOCAP_POWERSAFE_OVERWRITE]
-** <li> [SQLITE_IOCAP_IMMUTABLE]
-** <li> [SQLITE_IOCAP_BATCH_ATOMIC]
-** <li> [SQLITE_IOCAP_SUBPAGE_READ]
-** </ul>
-**
-** 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.
-**
-** <ul>
-** <li>[[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].
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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].
-**
-** <li>[[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].
-**
-** <li>[[SQLITE_FCNTL_SYNC_OMITTED]]
-** The SQLITE_FCNTL_SYNC_OMITTED file-control is no longer used.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_VFSNAME]]
-** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of
-** all [VFSes] in the VFS stack.  The names 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.
-**
-** <li>[[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 opcode 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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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].
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_NULL_IO]]
-** The [SQLITE_FCNTL_NULL_IO] opcode sets the low-level file descriptor
-** or file handle for the [sqlite3_file] object such that it will no longer
-** read or write to the database file.
-**
-** <li>[[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 <em>not</em> use this file-control.
-**
-** <li>[[SQLITE_FCNTL_ZIPVFS]]
-** The [SQLITE_FCNTL_ZIPVFS] opcode is implemented by zipvfs only. All other
-** VFS should return SQLITE_NOTFOUND for this opcode.
-**
-** <li>[[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.
-**
-** <li>[[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].
-**
-** <li>[[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].
-**
-** <li>[[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].
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_BLOCK_ON_CONNECT]]
-** The [SQLITE_FCNTL_BLOCK_ON_CONNECT] opcode is used to configure the
-** VFS to block when taking a SHARED lock to connect to a wal mode database.
-** This is used to implement the functionality associated with
-** SQLITE_SETLK_BLOCK_ON_CONNECT.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_CKSM_FILE]]
-** The [SQLITE_FCNTL_CKSM_FILE] opcode is for use internally by the
-** [checksum VFS shim] only.
-**
-** <li>[[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.
-**
-** <li>[[SQLITE_FCNTL_FILESTAT]]
-** The [SQLITE_FCNTL_FILESTAT] opcode returns low-level diagnostic information
-** about the [sqlite3_file] objects used access the database and journal files
-** for the given schema.  The fourth parameter to [sqlite3_file_control()]
-** should be an initialized [sqlite3_str] pointer.  JSON text describing
-** various aspects of the sqlite3_file object is appended to the sqlite3_str.
-** The SQLITE_FCNTL_FILESTAT opcode is usually a no-op, unless compile-time
-** options are used to enable it.
-** </ul>
-*/
-#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
-#define SQLITE_FCNTL_NULL_IO                43
-#define SQLITE_FCNTL_BLOCK_ON_CONNECT       44
-#define SQLITE_FCNTL_FILESTAT               45
-
-/* 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
-
-/* reserved file-control numbers:
-**                                         101
-**                                         102
-**                                         103
-*/
-
-
-/*
-** 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:
-**
-** <ul>
-** <li>  sqlite3_filename_database()
-** <li>  sqlite3_filename_journal()
-** <li>  sqlite3_filename_wal()
-** <li>  sqlite3_uri_parameter()
-** <li>  sqlite3_uri_boolean()
-** <li>  sqlite3_uri_int64()
-** <li>  sqlite3_uri_key()
-** </ul>
-*/
-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:
-**
-** <ul>
-** <li>  [SQLITE_OPEN_MAIN_DB]
-** <li>  [SQLITE_OPEN_MAIN_JOURNAL]
-** <li>  [SQLITE_OPEN_TEMP_DB]
-** <li>  [SQLITE_OPEN_TEMP_JOURNAL]
-** <li>  [SQLITE_OPEN_TRANSIENT_DB]
-** <li>  [SQLITE_OPEN_SUBJOURNAL]
-** <li>  [SQLITE_OPEN_SUPER_JOURNAL]
-** <li>  [SQLITE_OPEN_WAL]
-** </ul>)^
-**
-** 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:
-**
-** <ul>
-** <li> [SQLITE_OPEN_DELETEONCLOSE]
-** <li> [SQLITE_OPEN_EXCLUSIVE]
-** </ul>
-**
-** 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 <i>not</i> 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 xNextSystemCall() 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:
-**
-** <ul>
-** <li>  SQLITE_SHM_LOCK | SQLITE_SHM_SHARED
-** <li>  SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE
-** <li>  SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED
-** <li>  SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE
-** </ul>
-**
-** 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 been 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.
-**
-** <b>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.</b>
-**
-** 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:
-** <ul>
-** <li> SQLITE_CONFIG_LOG
-** <li> SQLITE_CONFIG_PCACHE_HDRSZ
-** </ul>
-**
-** 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.
-**
-** <dl>
-** [[SQLITE_CONFIG_SINGLETHREAD]] <dt>SQLITE_CONFIG_SINGLETHREAD</dt>
-** <dd>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.</dd>
-**
-** [[SQLITE_CONFIG_MULTITHREAD]] <dt>SQLITE_CONFIG_MULTITHREAD</dt>
-** <dd>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.</dd>
-**
-** [[SQLITE_CONFIG_SERIALIZED]] <dt>SQLITE_CONFIG_SERIALIZED</dt>
-** <dd>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.</dd>
-**
-** [[SQLITE_CONFIG_MALLOC]] <dt>SQLITE_CONFIG_MALLOC</dt>
-** <dd> ^(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.</dd>
-**
-** [[SQLITE_CONFIG_GETMALLOC]] <dt>SQLITE_CONFIG_GETMALLOC</dt>
-** <dd> ^(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 simulates memory allocation failure or
-** tracks memory usage, for example. </dd>
-**
-** [[SQLITE_CONFIG_SMALL_MALLOC]] <dt>SQLITE_CONFIG_SMALL_MALLOC</dt>
-** <dd> ^The SQLITE_CONFIG_SMALL_MALLOC option takes a 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 applications 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.
-** </dd>
-**
-** [[SQLITE_CONFIG_MEMSTATUS]] <dt>SQLITE_CONFIG_MEMSTATUS</dt>
-** <dd> ^The SQLITE_CONFIG_MEMSTATUS option takes a 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:
-**   <ul>
-**   <li> [sqlite3_hard_heap_limit64()]
-**   <li> [sqlite3_memory_used()]
-**   <li> [sqlite3_memory_highwater()]
-**   <li> [sqlite3_soft_heap_limit64()]
-**   <li> [sqlite3_status64()]
-**   </ul>)^
-** ^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.
-** </dd>
-**
-** [[SQLITE_CONFIG_SCRATCH]] <dt>SQLITE_CONFIG_SCRATCH</dt>
-** <dd> The SQLITE_CONFIG_SCRATCH option is no longer used.
-** </dd>
-**
-** [[SQLITE_CONFIG_PAGECACHE]] <dt>SQLITE_CONFIG_PAGECACHE</dt>
-** <dd> ^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. </dd>
-**
-** [[SQLITE_CONFIG_HEAP]] <dt>SQLITE_CONFIG_HEAP</dt>
-** <dd> ^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.</dd>
-**
-** [[SQLITE_CONFIG_MUTEX]] <dt>SQLITE_CONFIG_MUTEX</dt>
-** <dd> ^(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 of 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].</dd>
-**
-** [[SQLITE_CONFIG_GETMUTEX]] <dt>SQLITE_CONFIG_GETMUTEX</dt>
-** <dd> ^(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].</dd>
-**
-** [[SQLITE_CONFIG_LOOKASIDE]] <dt>SQLITE_CONFIG_LOOKASIDE</dt>
-** <dd> ^(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 ("sz") and the second is the number of
-** slots allocated to each database connection ("cnt").)^
-** ^(SQLITE_CONFIG_LOOKASIDE sets the <i>default</i> lookaside size.
-** The [SQLITE_DBCONFIG_LOOKASIDE] option to [sqlite3_db_config()] can
-** be used to change the lookaside configuration on individual connections.)^
-** The [-DSQLITE_DEFAULT_LOOKASIDE] option can be used to change the
-** default lookaside configuration at compile-time.
-** </dd>
-**
-** [[SQLITE_CONFIG_PCACHE2]] <dt>SQLITE_CONFIG_PCACHE2</dt>
-** <dd> ^(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.</dd>
-**
-** [[SQLITE_CONFIG_GETPCACHE2]] <dt>SQLITE_CONFIG_GETPCACHE2</dt>
-** <dd> ^(The SQLITE_CONFIG_GETPCACHE2 option takes a single argument which
-** is a pointer to an [sqlite3_pcache_methods2] object.  SQLite copies off
-** the current page cache implementation into that object.)^ </dd>
-**
-** [[SQLITE_CONFIG_LOG]] <dt>SQLITE_CONFIG_LOG</dt>
-** <dd> 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
-** a 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. </dd>
-**
-** [[SQLITE_CONFIG_URI]] <dt>SQLITE_CONFIG_URI
-** <dd>^(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]] <dt>SQLITE_CONFIG_COVERING_INDEX_SCAN
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE
-** <dd> These options are obsolete and should not be used by new code.
-** They are retained for backwards compatibility but are now no-ops.
-** </dd>
-**
-** [[SQLITE_CONFIG_SQLLOG]]
-** <dt>SQLITE_CONFIG_SQLLOG
-** <dd>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.</dd>
-**
-** [[SQLITE_CONFIG_MMAP_SIZE]]
-** <dt>SQLITE_CONFIG_MMAP_SIZE
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_WIN32_HEAPSIZE
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_PCACHE_HDRSZ
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_PMASZ
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_STMTJRNL_SPILL
-** <dd>^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]]
-** <dt>SQLITE_CONFIG_SORTERREF_SIZE
-** <dd>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 behavior.
-** This option is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option.
-**
-** [[SQLITE_CONFIG_MEMDB_MAXSIZE]]
-** <dt>SQLITE_CONFIG_MEMDB_MAXSIZE
-** <dd>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.
-**
-** [[SQLITE_CONFIG_ROWID_IN_VIEW]]
-** <dt>SQLITE_CONFIG_ROWID_IN_VIEW
-** <dd>The SQLITE_CONFIG_ROWID_IN_VIEW option enables or disables the ability
-** for VIEWs to have a ROWID.  The capability can only be enabled if SQLite is
-** compiled with -DSQLITE_ALLOW_ROWID_IN_VIEW, in which case the capability
-** defaults to on.  This configuration option queries the current setting or
-** changes the setting to off or on.  The argument is a pointer to an integer.
-** If that integer initially holds a value of 1, then the ability for VIEWs to
-** have ROWIDs is activated.  If the integer initially holds zero, then the
-** ability is deactivated.  Any other initial value for the integer leaves the
-** setting unchanged.  After changes, if any, the integer is written with
-** a 1 or 0, if the ability for VIEWs to have ROWIDs is on or off.  If SQLite
-** is compiled without -DSQLITE_ALLOW_ROWID_IN_VIEW (which is the usual and
-** recommended case) then the integer is always filled with zero, regardless
-** if its initial value.
-** </dl>
-*/
-#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 */
-#define SQLITE_CONFIG_ROWID_IN_VIEW       30  /* int* */
-
-/*
-** CAPI3REF: Database Connection Configuration Options
-**
-** These constants are the available integer configuration options that
-** can be passed as the second parameter to the [sqlite3_db_config()] interface.
-**
-** The [sqlite3_db_config()] interface is a var-args function.  It takes a
-** variable number of parameters, though always at least two.  The number of
-** parameters passed into sqlite3_db_config() depends on which of these
-** constants is given as the second parameter.  This documentation page
-** refers to parameters beyond the second as "arguments".  Thus, when this
-** page says "the N-th argument" it means "the N-th parameter past the
-** configuration option" or "the (N+2)-th parameter to sqlite3_db_config()".
-**
-** 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.
-**
-** <dl>
-** [[SQLITE_DBCONFIG_LOOKASIDE]]
-** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>
-** <dd> The SQLITE_DBCONFIG_LOOKASIDE option is used to adjust the
-** configuration of the [lookaside memory allocator] within a database
-** connection.
-** The arguments to the SQLITE_DBCONFIG_LOOKASIDE option are <i>not</i>
-** in the [DBCONFIG arguments|usual format].
-** The SQLITE_DBCONFIG_LOOKASIDE option takes three arguments, not two,
-** so that a call to [sqlite3_db_config()] that uses SQLITE_DBCONFIG_LOOKASIDE
-** should have a total of five parameters.
-** <ol>
-** <li><p>The first argument ("buf") is a
-** pointer to a memory buffer to use for lookaside memory.
-** The first argument may be NULL in which case SQLite will allocate the
-** lookaside buffer itself using [sqlite3_malloc()].
-** <li><P>The second argument ("sz") is the
-** size of each lookaside buffer slot.  Lookaside is disabled if "sz"
-** is less than 8.  The "sz" argument should be a multiple of 8 less than
-** 65536.  If "sz" does not meet this constraint, it is reduced in size until
-** it does.
-** <li><p>The third argument ("cnt") is the number of slots.
-** Lookaside is disabled if "cnt"is less than 1.
-*  The "cnt" value will be reduced, if necessary, so
-** that the product of "sz" and "cnt" does not exceed 2,147,418,112. The "cnt"
-** parameter is usually chosen so that the product of "sz" and "cnt" is less
-** than 1,000,000.
-** </ol>
-** <p>If the "buf" argument is not NULL, then it must
-** point to a memory buffer with a size that is greater than
-** or equal to the product of "sz" and "cnt".
-** The buffer must be aligned to an 8-byte boundary.
-** 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 value returned by [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].
-** If the "buf" argument is NULL and an attempt
-** to allocate memory based on "sz" and "cnt" fails, then
-** lookaside is silently disabled.
-** <p>
-** The [SQLITE_CONFIG_LOOKASIDE] configuration option can be used to set the
-** default lookaside configuration at initialization.  The
-** [-DSQLITE_DEFAULT_LOOKASIDE] option can be used to set the default lookaside
-** configuration at compile-time.  Typical values for lookaside are 1200 for
-** "sz" and 40 to 100 for "cnt".
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_FKEY]]
-** <dt>SQLITE_DBCONFIG_ENABLE_FKEY</dt>
-** <dd> ^This option is used to enable or disable the enforcement of
-** [foreign key constraints].  This is the same setting that is
-** enabled or disabled by the [PRAGMA foreign_keys] statement.
-** 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. </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]]
-** <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt>
-** <dd> ^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.
-**
-** <p>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.)^ </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_VIEW]]
-** <dt>SQLITE_DBCONFIG_ENABLE_VIEW</dt>
-** <dd> ^This option is used to enable or disable [CREATE VIEW | views].
-** There must 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.
-**
-** <p>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.)^ </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]]
-** <dt>SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER</dt>
-** <dd> ^This option is used to enable or disable using the
-** [fts3_tokenizer()] function - part of the [FTS3] full-text search engine
-** extension - without using bound parameters as the parameters. Doing so
-** is disabled by default. There must be two additional arguments. The first
-** argument is an integer. If it is passed 0, then using fts3_tokenizer()
-** without bound parameters is disabled. If it is passed a positive value,
-** then calling fts3_tokenizer without bound parameters is enabled. If it
-** is passed a negative value, this setting is not modified - this can be
-** used to query for the current setting. The second parameter is a pointer
-** to an integer into which is written 0 or 1 to indicate the current value
-** of this setting (after it is modified, if applicable).  The second
-** parameter may be a NULL pointer, in which case the value of the setting
-** is not reported back. Refer to [FTS3] documentation for further details.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]]
-** <dt>SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION</dt>
-** <dd> ^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 must 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 the 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_MAINDBNAME]] <dt>SQLITE_DBCONFIG_MAINDBNAME</dt>
-** <dd> ^This option is used to change the name of the "main" database
-** schema.  This option does not follow the
-** [DBCONFIG arguments|usual SQLITE_DBCONFIG argument format].
-** This option takes exactly one additional argument so that the
-** [sqlite3_db_config()] call has a total of three parameters.  The
-** extra argument must be 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 SQLITE_DBCONFIG MAINDBNAME
-** is unchanged until after the database connection closes.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE]]
-** <dt>SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE</dt>
-** <dd> Usually, when a database in [WAL mode] is closed or detached from a
-** database handle, SQLite checks if if there are other connections to the
-** same database, and if there are no other database connection (if the
-** connection being closed is the last open connection to the database),
-** then SQLite performs a [checkpoint] before closing the connection and
-** deletes the WAL file.  The SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE option can
-** be used to override that behavior. The first argument passed to this
-** operation (the third parameter to [sqlite3_db_config()]) is an integer
-** which is positive to disable checkpoints-on-close, or zero (the default)
-** to enable them, and negative to leave the setting unchanged.
-** The second argument (the fourth 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_QPSG]] <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt>
-** <dd>^(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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_TRIGGER_EQP]] <dt>SQLITE_DBCONFIG_TRIGGER_EQP</dt>
-** <dd> 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_RESET_DATABASE]] <dt>SQLITE_DBCONFIG_RESET_DATABASE</dt>
-** <dd> 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:
-** <ol>
-** <li> 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.
-** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0);
-** <li> [sqlite3_exec](db, "[VACUUM]", 0, 0, 0);
-** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);
-** </ol>
-** 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]] <dt>SQLITE_DBCONFIG_DEFENSIVE</dt>
-** <dd>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:
-** <ul>
-** <li> The [PRAGMA writable_schema=ON] statement.
-** <li> The [PRAGMA journal_mode=OFF] statement.
-** <li> The [PRAGMA schema_version=N] statement.
-** <li> Writes to the [sqlite_dbpage] virtual table.
-** <li> Direct writes to [shadow tables].
-** </ul>
-** </dd>
-**
-** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]] <dt>SQLITE_DBCONFIG_WRITABLE_SCHEMA</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_LEGACY_ALTER_TABLE]]
-** <dt>SQLITE_DBCONFIG_LEGACY_ALTER_TABLE</dt>
-** <dd>The SQLITE_DBCONFIG_LEGACY_ALTER_TABLE option activates or deactivates
-** the legacy behavior of the [ALTER TABLE RENAME] command such that 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_DQS_DML]]
-** <dt>SQLITE_DBCONFIG_DQS_DML</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_DQS_DDL]]
-** <dt>SQLITE_DBCONFIG_DQS_DDL</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_TRUSTED_SCHEMA]]
-** <dt>SQLITE_DBCONFIG_TRUSTED_SCHEMA</dt>
-** <dd>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:
-** <ul>
-** <li> 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].
-** <li> Prohibit the use of virtual tables inside of triggers or views
-** unless those virtual tables are tagged with [SQLITE_VTAB_INNOCUOUS].
-** </ul>
-** 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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_LEGACY_FILE_FORMAT]]
-** <dt>SQLITE_DBCONFIG_LEGACY_FILE_FORMAT</dt>
-** <dd>The SQLITE_DBCONFIG_LEGACY_FILE_FORMAT option activates or deactivates
-** the legacy file format flag.  When activated, this flag causes all newly
-** created database files 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.
-** <p>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 descending indexes.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_STMT_SCANSTATUS]]
-** <dt>SQLITE_DBCONFIG_STMT_SCANSTATUS</dt>
-** <dd>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 run-time performance statistics
-** used by [sqlite3_stmt_scanstatus_v2()] and the [nexec and ncycle]
-** columns of the [bytecode virtual table].
-** For statistics to be collected, the flag must be set on
-** the database handle both when the SQL statement is
-** [sqlite3_prepare|prepared] and when it is [sqlite3_step|stepped].
-** The flag is set (collection of statistics is enabled) by default.
-** <p>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_REVERSE_SCANORDER]]
-** <dt>SQLITE_DBCONFIG_REVERSE_SCANORDER</dt>
-** <dd>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]. <p>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.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE]]
-** <dt>SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE</dt>
-** <dd>The SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE option enables or disables
-** the ability of the [ATTACH DATABASE] SQL command to create a new database
-** file if the database filed named in the ATTACH command does not already
-** exist.  This ability of ATTACH to create a new database is enabled by
-** default.  Applications can disable or reenable the ability for ATTACH to
-** create new database files using this DBCONFIG option.<p>
-** 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 attach-create 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 attach-create flag is set
-** after processing the first argument.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE]]
-** <dt>SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE</dt>
-** <dd>The SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE option enables or disables the
-** ability of the [ATTACH DATABASE] SQL command to open a database for writing.
-** This capability is enabled by default.  Applications can disable or
-** reenable this capability using the current DBCONFIG option.  If
-** this capability is disabled, the [ATTACH] command will still work,
-** but the database will be opened read-only.  If this option is disabled,
-** then the ability to create a new database using [ATTACH] is also disabled,
-** regardless of the value of the [SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE]
-** option.<p>
-** 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 ability to ATTACH another database for writing,
-** respectively.  If the second argument is not NULL, then 0 or 1 is written
-** into the integer to which the second argument points, depending on whether
-** the ability to ATTACH a read/write database is enabled or disabled
-** after processing the first argument.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_COMMENTS]]
-** <dt>SQLITE_DBCONFIG_ENABLE_COMMENTS</dt>
-** <dd>The SQLITE_DBCONFIG_ENABLE_COMMENTS option enables or disables the
-** ability to include comments in SQL text.  Comments are enabled by default.
-** An application can disable or reenable comments in SQL text using this
-** DBCONFIG option.<p>
-** 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 ability to use comments in SQL text,
-** 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
-** comments are allowed in SQL text after processing the first argument.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_FP_DIGITS]]
-** <dt>SQLITE_DBCONFIG_FP_DIGITS</dt>
-** <dd>The SQLITE_DBCONFIG_FP_DIGITS setting is a small integer that determines
-** the number of significant digits that SQLite will attempt to preserve when
-** converting floating point numbers (IEEE 754 "doubles") into text.  The
-** default value 17, as of SQLite version 3.52.0.  The value was 15 in all
-** prior versions.<p>
-** This option takes two arguments which are an integer and a pointer
-** to an integer.  The first argument is a small integer, between 3 and 23, or
-** zero.  The FP_DIGITS setting is changed to that small integer, or left
-** unaltered if the first argument is zero or out of range. The second argument
-** is a pointer to an integer.  If the pointer is not NULL, then the value of
-** the FP_DIGITS setting, after possibly being modified by the first
-** arguments, is written into the integer to which the second argument points.
-** </dd>
-**
-** </dl>
-**
-** [[DBCONFIG arguments]] <h3>Arguments To SQLITE_DBCONFIG Options</h3>
-**
-** <p>Most of the SQLITE_DBCONFIG options take two arguments, so that the
-** overall call to [sqlite3_db_config()] has a total of four parameters.
-** The first argument (the third parameter to sqlite3_db_config()) is
-** an integer.
-** The second argument is a pointer to an integer. If the first argument is 1,
-** then the option becomes enabled.  If the first integer argument is 0,
-** then the option is disabled.
-** If the first argument is -1, then the option setting
-** is unchanged.  The second argument, the pointer to an integer, may be NULL.
-** If the second argument is not NULL, then a value of 0 or 1 is written into
-** the integer to which the second argument points, depending on whether the
-** setting is disabled or enabled after applying any changes specified by
-** the first argument.
-**
-** <p>While most SQLITE_DBCONFIG options use the argument format
-** described in the previous paragraph, the [SQLITE_DBCONFIG_MAINDBNAME],
-** [SQLITE_DBCONFIG_LOOKASIDE], and [SQLITE_DBCONFIG_FP_DIGITS] options
-** are different.  See the documentation of those exceptional options for
-** details.
-*/
-#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_ENABLE_ATTACH_CREATE  1020 /* int int* */
-#define SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE   1021 /* int int* */
-#define SQLITE_DBCONFIG_ENABLE_COMMENTS       1022 /* int int* */
-#define SQLITE_DBCONFIG_FP_DIGITS             1023 /* int int* */
-#define SQLITE_DBCONFIG_MAX                   1023 /* 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.
-** For the purposes of this interface, a CREATE TABLE AS SELECT statement
-** does not count as an INSERT, UPDATE or DELETE statement and hence the rows
-** added to the new table by the CREATE TABLE AS SELECT statement are not
-** counted.
-**
-** ^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:
-**
-** <ul>
-**   <li> ^(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.)^
-**
-**   <li> ^(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.)^
-** </ul>
-**
-** ^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:
-** <ul>
-** <li> the [sqlite3_total_changes()] interface
-** <li> the [count_changes pragma]
-** <li> the [changes() SQL function]
-** <li> the [data_version pragma]
-** </ul>
-*/
-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:
-** <ul>
-** <li> the [sqlite3_changes()] interface
-** <li> the [count_changes pragma]
-** <li> the [changes() SQL function]
-** <li> the [data_version pragma]
-** <li> the [SQLITE_FCNTL_DATA_VERSION] [file control]
-** </ul>
-*/
-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.
-** It returns 1 if an interrupt is currently in effect, or 0 otherwise.
-*/
-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 and 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: Set the Setlk Timeout
-** METHOD: sqlite3
-**
-** This routine is only useful in SQLITE_ENABLE_SETLK_TIMEOUT builds. If
-** the VFS supports blocking locks, it sets the timeout in ms used by
-** eligible locks taken on wal mode databases by the specified database
-** handle. In non-SQLITE_ENABLE_SETLK_TIMEOUT builds, or if the VFS does
-** not support blocking locks, this function is a no-op.
-**
-** Passing 0 to this function disables blocking locks altogether. Passing
-** -1 to this function requests that the VFS blocks for a long time -
-** indefinitely if possible. The results of passing any other negative value
-** are undefined.
-**
-** Internally, each SQLite database handle stores two timeout values - the
-** busy-timeout (used for rollback mode databases, or if the VFS does not
-** support blocking locks) and the setlk-timeout (used for blocking locks
-** on wal-mode databases). The sqlite3_busy_timeout() method sets both
-** values, this function sets only the setlk-timeout value. Therefore,
-** to configure separate busy-timeout and setlk-timeout values for a single
-** database handle, call sqlite3_busy_timeout() followed by this function.
-**
-** Whenever the number of connections to a wal mode database falls from
-** 1 to 0, the last connection takes an exclusive lock on the database,
-** then checkpoints and deletes the wal file. While it is doing this, any
-** new connection that tries to read from the database fails with an
-** SQLITE_BUSY error. Or, if the SQLITE_SETLK_BLOCK_ON_CONNECT flag is
-** passed to this API, the new connection blocks until the exclusive lock
-** has been released.
-*/
-SQLITE_API int sqlite3_setlk_timeout(sqlite3*, int ms, int flags);
-
-/*
-** CAPI3REF: Flags for sqlite3_setlk_timeout()
-*/
-#define SQLITE_SETLK_BLOCK_ON_CONNECT 0x01
-
-/*
-** 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 <b>result table</b> is a 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:
-**
-** <blockquote><pre>
-**        Name        | Age
-**        -----------------------
-**        Alice       | 43
-**        Bob         | 28
-**        Cindy       | 21
-** </pre></blockquote>
-**
-** 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:
-**
-** <blockquote><pre>
-**        azResult&#91;0] = "Name";
-**        azResult&#91;1] = "Age";
-**        azResult&#91;2] = "Alice";
-**        azResult&#91;3] = "43";
-**        azResult&#91;4] = "Bob";
-**        azResult&#91;5] = "28";
-**        azResult&#91;6] = "Cindy";
-**        azResult&#91;7] = "21";
-** </pre></blockquote>)^
-**
-** ^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 it 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 the 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) interface 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 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: Deprecated Tracing And Profiling Functions
-** DEPRECATED
-**
-** 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.
-**
-** <dl>
-** [[SQLITE_TRACE_STMT]] <dt>SQLITE_TRACE_STMT</dt>
-** <dd>^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]] <dt>SQLITE_TRACE_PROFILE</dt>
-** <dd>^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]] <dt>SQLITE_TRACE_ROW</dt>
-** <dd>^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]] <dt>SQLITE_TRACE_CLOSE</dt>
-** <dd>^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.
-** </dl>
-*/
-#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(D,X,P) or sqlite3_trace_v2(D,M,X,P)
-** overrides (cancels) all prior calls to sqlite3_trace(D,X,P) or
-** sqlite3_trace_v2(D,M,X,P) for the [database connection] D.  Each
-** database connection may have at most one trace callback.
-**
-** ^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:)^
-**
-** <dl>
-** ^(<dt>[SQLITE_OPEN_READONLY]</dt>
-** <dd>The database is opened in read-only mode.  If the database does
-** not already exist, an error is returned.</dd>)^
-**
-** ^(<dt>[SQLITE_OPEN_READWRITE]</dt>
-** <dd>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.</dd>)^
-**
-** ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>
-** <dd>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().</dd>)^
-** </dl>
-**
-** In addition to the required flags, the following optional flags are
-** also supported:
-**
-** <dl>
-** ^(<dt>[SQLITE_OPEN_URI]</dt>
-** <dd>The filename can be interpreted as a URI if this flag is set.</dd>)^
-**
-** ^(<dt>[SQLITE_OPEN_MEMORY]</dt>
-** <dd>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.
-** </dd>)^
-**
-** ^(<dt>[SQLITE_OPEN_NOMUTEX]</dt>
-** <dd>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].
-**
-** ^(<dt>[SQLITE_OPEN_FULLMUTEX]</dt>
-** <dd>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.)
-**
-** ^(<dt>[SQLITE_OPEN_SHAREDCACHE]</dt>
-** <dd>The database is opened with [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.
-**
-** ^(<dt>[SQLITE_OPEN_PRIVATECACHE]</dt>
-** <dd>The database is opened with [shared cache] disabled, overriding
-** the default shared cache setting provided by
-** [sqlite3_enable_shared_cache()].)^
-**
-** [[OPEN_EXRESCODE]] ^(<dt>[SQLITE_OPEN_EXRESCODE]</dt>
-** <dd>The database connection comes up in "extended result code mode".
-** In other words, the database behaves as if
-** [sqlite3_extended_result_codes(db,1)] were 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.</dd>
-**
-** [[OPEN_NOFOLLOW]] ^(<dt>[SQLITE_OPEN_NOFOLLOW]</dt>
-** <dd>The database filename is not allowed to contain a symbolic link</dd>
-** </dl>)^
-**
-** 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()]] <h3>URI Filenames</h3>
-**
-** ^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:
-**
-** <ul>
-**   <li> <b>vfs</b>: ^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().
-**
-**   <li> <b>mode</b>: ^(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().
-**
-**   <li> <b>cache</b>: ^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.
-**
-**  <li> <b>psow</b>: ^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.
-**
-**  <li> <b>nolock</b>: ^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.
-**
-**  <li> <b>immutable</b>: ^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].
-**
-** </ul>
-**
-** ^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]] <h3>URI filename examples</h3>
-**
-** <table border="1" align=center cellpadding=5>
-** <tr><th> URI filenames <th> Results
-** <tr><td> file:data.db <td>
-**          Open the file "data.db" in the current directory.
-** <tr><td> file:/home/fred/data.db<br>
-**          file:///home/fred/data.db <br>
-**          file://localhost/home/fred/data.db <br> <td>
-**          Open the database file "/home/fred/data.db".
-** <tr><td> file://darkstar/home/fred/data.db <td>
-**          An error. "darkstar" is not a recognized authority.
-** <tr><td style="white-space:nowrap">
-**          file:///C:/Documents%20and%20Settings/fred/Desktop/data.db
-**     <td> 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.
-** <tr><td> file:data.db?mode=ro&cache=private <td>
-**          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.
-** <tr><td> file:/home/fred/data.db?vfs=unix-dotfile <td>
-**          Open file "/home/fred/data.db". Use the special VFS "unix-dotfile"
-**          that uses dot-files in place of posix advisory locking.
-** <tr><td> file:data.db?mode=readonly <td>
-**          An error. "readonly" is not a valid option for the "mode" parameter.
-**          Use "ro" instead:  "file:data.db?mode=ro".
-** </table>
-**
-** ^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.
-**
-** <b>Note to Windows users:</b>  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().
-**
-** <b>Note to Windows Runtime users:</b>  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:
-** <ul>
-** <li> A database filename pointer created by the SQLite core and
-** passed into the xOpen() method of a VFS implementation, or
-** <li> A filename obtained from [sqlite3_db_filename()], or
-** <li> A new filename constructed using [sqlite3_create_filename()].
-** </ul>
-** 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 interfaces 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
-** an array P of N URI Key/Value pairs.  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:
-** <ul>
-** <li> [sqlite3_uri_parameter()],
-** <li> [sqlite3_uri_boolean()],
-** <li> [sqlite3_uri_int64()],
-** <li> [sqlite3_uri_key()],
-** <li> [sqlite3_filename_database()],
-** <li> [sqlite3_filename_journal()], or
-** <li> [sqlite3_filename_wal()].
-** </ul>
-** 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:
-**
-** <ul>
-** <li> sqlite3_errcode()
-** <li> sqlite3_extended_errcode()
-** <li> sqlite3_errmsg()
-** <li> sqlite3_errmsg16()
-** <li> sqlite3_error_offset()
-** <li> sqlite3_db_handle()
-** </ul>
-**
-** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
-** text that describes the error, as either UTF-8 or UTF-16 respectively,
-** or NULL if no error message is available.
-** (See how SQLite handles [invalid UTF] for exceptions to this rule.)
-** ^(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(E) interface returns the English-language text
-** that describes the [result code] E, as UTF-8, or NULL if E is not a
-** result code for which a text error message is available.
-** ^(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 UTF-8.
-** ^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: Set Error Code And Message
-** METHOD: sqlite3
-**
-** Set the error code of the database handle passed as the first argument
-** to errcode, and the error message to a copy of nul-terminated string
-** zErrMsg. If zErrMsg is passed NULL, then the error message is set to
-** the default message associated with the supplied error code.  Subsequent
-** calls to [sqlite3_errcode()] and [sqlite3_errmsg()] and similar will
-** return the values set by this routine in place of what was previously
-** set by SQLite itself.
-**
-** This function returns SQLITE_OK if the error code and error message are
-** successfully set, SQLITE_NOMEM if an OOM occurs, and SQLITE_MISUSE if
-** the database handle is NULL or invalid.
-**
-** The error code and message set by this routine remains in effect until
-** they are changed, either by another call to this routine or until they are
-** changed to by SQLite itself to reflect the result of some subsquent
-** API call.
-**
-** This function is intended for use by SQLite extensions or wrappers.  The
-** idea is that an extension or wrapper can use this routine to set error
-** messages and error codes and thus behave more like a core SQLite
-** feature from the point of view of an application.
-*/
-SQLITE_API int sqlite3_set_errmsg(sqlite3 *db, int errcode, const char *zErrMsg);
-
-/*
-** 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:
-**
-** <ol>
-** <li> Create the prepared statement object using [sqlite3_prepare_v2()].
-** <li> Bind values to [parameters] using the sqlite3_bind_*()
-**      interfaces.
-** <li> Run the SQL by calling [sqlite3_step()] one or more times.
-** <li> Reset the prepared statement using [sqlite3_reset()] then go back
-**      to step 2.  Do this zero or more times.
-** <li> Destroy the object using [sqlite3_finalize()].
-** </ol>
-*/
-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_<i>NAME</i> there is a
-** [limits | hard upper bound]
-** set at compile-time by a C preprocessor macro called
-** [limits | SQLITE_MAX_<i>NAME</i>].
-** (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()].
-** A concise description of these limits follows, and additional information
-** is available at [limits | Limits in SQLite].
-**
-** <dl>
-** [[SQLITE_LIMIT_LENGTH]] ^(<dt>SQLITE_LIMIT_LENGTH</dt>
-** <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
-**
-** [[SQLITE_LIMIT_SQL_LENGTH]] ^(<dt>SQLITE_LIMIT_SQL_LENGTH</dt>
-** <dd>The maximum length of an SQL statement, in bytes.</dd>)^
-**
-** [[SQLITE_LIMIT_COLUMN]] ^(<dt>SQLITE_LIMIT_COLUMN</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(<dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
-** <dd>The maximum depth of the parse tree on any expression.</dd>)^
-**
-** [[SQLITE_LIMIT_PARSER_DEPTH]] ^(<dt>SQLITE_LIMIT_PARSER_DEPTH</dt>
-** <dd>The maximum depth of the LALR(1) parser stack used to analyze
-** input SQL statements.</dd>)^
-**
-** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
-** <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
-**
-** [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
-** <dd>The maximum number of arguments on a function.</dd>)^
-**
-** [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
-** <dd>The maximum number of [ATTACH | attached databases].)^</dd>
-**
-** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]]
-** ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
-** <dd>The maximum length of the pattern argument to the [LIKE] or
-** [GLOB] operators.</dd>)^
-**
-** [[SQLITE_LIMIT_VARIABLE_NUMBER]]
-** ^(<dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
-** <dd>The maximum index number of any [parameter] in an SQL statement.)^
-**
-** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
-** <dd>The maximum depth of recursion for triggers.</dd>)^
-**
-** [[SQLITE_LIMIT_WORKER_THREADS]] ^(<dt>SQLITE_LIMIT_WORKER_THREADS</dt>
-** <dd>The maximum number of auxiliary worker threads that a single
-** [prepared statement] may start.</dd>)^
-** </dl>
-*/
-#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
-#define SQLITE_LIMIT_PARSER_DEPTH             12
-
-/*
-** CAPI3REF: Prepare Flags
-**
-** These constants define various flags that can be passed into the
-** "prepFlags" parameter of the [sqlite3_prepare_v3()] and
-** [sqlite3_prepare16_v3()] interfaces.
-**
-** New flags may be added in future releases of SQLite.
-**
-** <dl>
-** [[SQLITE_PREPARE_PERSISTENT]] ^(<dt>SQLITE_PREPARE_PERSISTENT</dt>
-** <dd>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]] <dt>SQLITE_PREPARE_NORMALIZE</dt>
-** <dd>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]] <dt>SQLITE_PREPARE_NO_VTAB</dt>
-** <dd>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.
-**
-** [[SQLITE_PREPARE_DONT_LOG]] <dt>SQLITE_PREPARE_DONT_LOG</dt>
-** <dd>The SQLITE_PREPARE_DONT_LOG flag prevents SQL compiler
-** errors from being sent to the error log defined by
-** [SQLITE_CONFIG_LOG].  This can be used, for example, to do test
-** compiles to see if some SQL syntax is well-formed, without generating
-** messages on the global error log when it is not.  If the test compile
-** fails, the sqlite3_prepare_v3() call returns the same error indications
-** with or without this flag; it just omits the call to [sqlite3_log()] that
-** logs the error.
-**
-** [[SQLITE_PREPARE_FROM_DDL]] <dt>SQLITE_PREPARE_FROM_DDL</dt>
-** <dd>The SQLITE_PREPARE_FROM_DDL flag causes the SQL compiler to enforce
-** security constraints that would otherwise only be enforced when parsing
-** the database schema.  In other words, the SQLITE_PREPARE_FROM_DDL flag
-** causes the SQL compiler to treat the SQL statement being prepared as if
-** it had come from an attacker.  When SQLITE_PREPARE_FROM_DDL is used and
-** [SQLITE_DBCONFIG_TRUSTED_SCHEMA] is off, SQL functions may only be called
-** if they are tagged with [SQLITE_INNOCUOUS] and virtual tables may only
-** be used if they are tagged with [SQLITE_VTAB_INNOCUOUS].  Best practice
-** is to use the SQLITE_PREPARE_FROM_DDL option when preparing any SQL that
-** is derived from parts of the database schema. In particular, virtual
-** table implementations that run SQL statements that are derived from
-** arguments to their CREATE VIRTUAL TABLE statement should always use
-** [sqlite3_prepare_v3()] and set the SQLITE_PREPARE_FROM_DDL flag to
-** prevent bypass of the [SQLITE_DBCONFIG_TRUSTED_SCHEMA] security checks.
-** </dl>
-*/
-#define SQLITE_PREPARE_PERSISTENT              0x01
-#define SQLITE_PREPARE_NORMALIZE               0x02
-#define SQLITE_PREPARE_NO_VTAB                 0x04
-#define SQLITE_PREPARE_DONT_LOG                0x10
-#define SQLITE_PREPARE_FROM_DDL                0x20
-
-/*
-** 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
-** [SQLITE_PREPARE_FROM_DDL|"prepFlags" option] that is sometimes
-** needed for special purpose or to pass along security restrictions.
-**
-** 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 maximum
-** number of bytes read from zSql.  When nByte is positive, zSql is read
-** up to the first zero terminator or until the nByte bytes have been read,
-** whichever comes first.  ^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 <i>including</i>
-** the nul-terminator.
-** Note that nByte measures the length of the input in bytes, not
-** characters, even for the UTF-16 interfaces.
-**
-** ^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:
-**
-** <ol>
-** <li>
-** ^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.
-** </li>
-**
-** <li>
-** ^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.
-** </li>
-**
-** <li>
-** ^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.
-** </li>
-** </ol>
-**
-** <p>^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
-** 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:
-**
-** <blockquote><pre>
-**    SELECT eval('DELETE FROM t1') FROM t2;
-** </pre></blockquote>
-**
-** 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: Change The EXPLAIN Setting For A Prepared Statement
-** METHOD: sqlite3_stmt
-**
-** The sqlite3_stmt_explain(S,E) interface changes the EXPLAIN
-** setting for [prepared statement] S.  If E is zero, then S becomes
-** a normal prepared statement.  If E is 1, then S behaves as if
-** its SQL text began with "[EXPLAIN]".  If E is 2, then S behaves as if
-** its SQL text began with "[EXPLAIN QUERY PLAN]".
-**
-** Calling sqlite3_stmt_explain(S,E) might cause S to be reprepared.
-** SQLite tries to avoid a reprepare, but a reprepare might be necessary
-** on the first transition into EXPLAIN or EXPLAIN QUERY PLAN mode.
-**
-** Because of the potential need to reprepare, a call to
-** sqlite3_stmt_explain(S,E) will fail with SQLITE_ERROR if S cannot be
-** reprepared because it was created using [sqlite3_prepare()] instead of
-** the newer [sqlite3_prepare_v2()] or [sqlite3_prepare_v3()] interfaces and
-** hence has no saved SQL text with which to reprepare.
-**
-** Changing the explain setting for a prepared statement does not change
-** the original SQL text for the statement.  Hence, if the SQL text originally
-** began with EXPLAIN or EXPLAIN QUERY PLAN, but sqlite3_stmt_explain(S,0)
-** is called to convert the statement into an ordinary statement, the EXPLAIN
-** or EXPLAIN QUERY PLAN keywords will still appear in the sqlite3_sql(S)
-** output, even though the statement now acts like a normal SQL statement.
-**
-** This routine returns SQLITE_OK if the explain mode is successfully
-** changed, or an error code if the explain mode could not be changed.
-** The explain mode cannot be changed while a statement is active.
-** Hence, it is good practice to call [sqlite3_reset(S)]
-** immediately prior to calling sqlite3_stmt_explain(S,E).
-*/
-SQLITE_API int sqlite3_stmt_explain(sqlite3_stmt *pStmt, int eMode);
-
-/*
-** 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 the 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 the following
-** templates:
-**
-** <ul>
-** <li>  ?
-** <li>  ?NNN
-** <li>  :VVV
-** <li>  @VVV
-** <li>  $VVV
-** </ul>
-**
-** 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 SQLITE_UTF8_ZT,
-** 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 the 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 <u>bytes</u> 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 occur 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 passed 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 (the E argument)
-** to sqlite3_bind_text64(S,K,Z,N,D,E) must be one of
-** [SQLITE_UTF8], [SQLITE_UTF8_ZT], [SQLITE_UTF16], [SQLITE_UTF16BE],
-** or [SQLITE_UTF16LE] to specify the encoding of the text in the
-** third parameter, Z.  The special value [SQLITE_UTF8_ZT] means that the
-** string argument is both UTF-8 encoded and is zero-terminated.  In other
-** words, SQLITE_UTF8_ZT means that the Z array is allocated to hold at
-** least N+1 bytes and that the Z&#91;N&#93; byte is zero.  If
-** the E argument to sqlite3_bind_text64(S,K,Z,N,D,E) 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, even if the call to sqlite3_bind_pointer() fails.  Due to a
-** historical design quirk, results are undefined if D is
-** SQLITE_TRANSIENT. 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 a
-** [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.
-**
-** <b>Goofy Interface Alert:</b> 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:
-**
-** <ul>
-** <li> 64-bit signed integer
-** <li> 64-bit IEEE floating point number
-** <li> string
-** <li> BLOB
-** <li> NULL
-** </ul>)^
-**
-** 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
-**
-** <b>Summary:</b>
-** <blockquote><table border=0 cellpadding=0 cellspacing=0>
-** <tr><td><b>sqlite3_column_blob</b><td>&rarr;<td>BLOB result
-** <tr><td><b>sqlite3_column_double</b><td>&rarr;<td>REAL result
-** <tr><td><b>sqlite3_column_int</b><td>&rarr;<td>32-bit INTEGER result
-** <tr><td><b>sqlite3_column_int64</b><td>&rarr;<td>64-bit INTEGER result
-** <tr><td><b>sqlite3_column_text</b><td>&rarr;<td>UTF-8 TEXT result
-** <tr><td><b>sqlite3_column_text16</b><td>&rarr;<td>UTF-16 TEXT result
-** <tr><td><b>sqlite3_column_value</b><td>&rarr;<td>The result as an
-** [sqlite3_value|unprotected sqlite3_value] object.
-** <tr><td>&nbsp;<td>&nbsp;<td>&nbsp;
-** <tr><td><b>sqlite3_column_bytes</b><td>&rarr;<td>Size of a BLOB
-** or a UTF-8 TEXT result in bytes
-** <tr><td><b>sqlite3_column_bytes16&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>Size of UTF-16
-** TEXT in bytes
-** <tr><td><b>sqlite3_column_type</b><td>&rarr;<td>Default
-** datatype of the result
-** </table></blockquote>
-**
-** <b>Details:</b>
-**
-** ^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.
-**
-** <b>Warning:</b> ^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:
-**
-** <blockquote>
-** <table border="1">
-** <tr><th> Internal<br>Type <th> Requested<br>Type <th>  Conversion
-**
-** <tr><td>  NULL    <td> INTEGER   <td> Result is 0
-** <tr><td>  NULL    <td>  FLOAT    <td> Result is 0.0
-** <tr><td>  NULL    <td>   TEXT    <td> Result is a NULL pointer
-** <tr><td>  NULL    <td>   BLOB    <td> Result is a NULL pointer
-** <tr><td> INTEGER  <td>  FLOAT    <td> Convert from integer to float
-** <tr><td> INTEGER  <td>   TEXT    <td> ASCII rendering of the integer
-** <tr><td> INTEGER  <td>   BLOB    <td> Same as INTEGER->TEXT
-** <tr><td>  FLOAT   <td> INTEGER   <td> [CAST] to INTEGER
-** <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
-** <tr><td>  FLOAT   <td>   BLOB    <td> [CAST] to BLOB
-** <tr><td>  TEXT    <td> INTEGER   <td> [CAST] to INTEGER
-** <tr><td>  TEXT    <td>  FLOAT    <td> [CAST] to REAL
-** <tr><td>  TEXT    <td>   BLOB    <td> No change
-** <tr><td>  BLOB    <td> INTEGER   <td> [CAST] to INTEGER
-** <tr><td>  BLOB    <td>  FLOAT    <td> [CAST] to REAL
-** <tr><td>  BLOB    <td>   TEXT    <td> [CAST] to TEXT, ensure zero terminator
-** </table>
-** </blockquote>)^
-**
-** 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:
-**
-** <ul>
-** <li> 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.</li>
-** <li> 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.</li>
-** <li> 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.</li>
-** </ul>
-**
-** ^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:
-**
-** <ul>
-**  <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
-**  <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
-**  <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
-** </ul>
-**
-** 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:
-**
-** <ul>
-** <li> sqlite3_column_blob()
-** <li> sqlite3_column_text()
-** <li> sqlite3_column_text16()
-** <li> sqlite3_column_bytes()
-** <li> sqlite3_column_bytes16()
-** </ul>
-**
-** 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 has 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.
-**
-** ^The return code from [sqlite3_reset(S)] indicates whether or not
-** the previous evaluation of prepared statement S completed successfully.
-** ^If [sqlite3_step(S)] has never before been called on S or if
-** [sqlite3_step(S)] has not been called since the previous call
-** to [sqlite3_reset(S)], then [sqlite3_reset(S)] will return
-** [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 might also return an [error code]
-** if there were no prior errors but the process of resetting
-** the prepared statement caused a new error. ^For example, if an
-** [INSERT] statement with a [RETURNING] clause is only stepped one time,
-** that one call to [sqlite3_step(S)] might return SQLITE_ROW but
-** the overall statement might still fail and the [sqlite3_reset(S)] call
-** might return SQLITE_BUSY if locking constraints prevent the
-** database change from committing.  Therefore, it is important that
-** applications check the return code from [sqlite3_reset(S)] even if
-** no prior call to [sqlite3_step(S)] indicated a problem.
-**
-** ^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, views, CHECK constraints, or other elements of
-** the database schema.  This flag 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 the 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 constants define integer codes that represent the various
-** text encodings supported by SQLite.
-**
-** <dl>
-** [[SQLITE_UTF8]] <dt>SQLITE_UTF8</dt><dd>Text is encoding as UTF-8</dd>
-**
-** [[SQLITE_UTF16LE]] <dt>SQLITE_UTF16LE</dt><dd>Text is encoding as UTF-16
-** with each code point being expressed "little endian" - the least significant
-** byte first.  This is the usual encoding, for example on Windows.</dd>
-**
-** [[SQLITE_UTF16BE]] <dt>SQLITE_UTF16BE</dt><dd>Text is encoding as UTF-16
-** with each code point being expressed "big endian" - the most significant
-** byte first.  This encoding is less common, but is still sometimes seen,
-** specially on older systems.
-**
-** [[SQLITE_UTF16]] <dt>SQLITE_UTF16</dt><dd>Text is encoding as UTF-16
-** with each code point being expressed either little endian or as big
-** endian, according to the native endianness of the host computer.
-**
-** [[SQLITE_ANY]] <dt>SQLITE_ANY</dt><dd>This encoding value may only be used
-** to declare the preferred text for [application-defined SQL functions]
-** created using [sqlite3_create_function()] and similar.  If the preferred
-** encoding (the 4th parameter to sqlite3_create_function() - the eTextRep
-** parameter) is SQLITE_ANY, that indicates that the function does not have
-** a preference regarding the text encoding of its parameters and can take
-** any text encoding that the SQLite core find convenient to supply.  This
-** option is deprecated.  Please do not use it in new applications.
-**
-** [[SQLITE_UTF16_ALIGNED]] <dt>SQLITE_UTF16_ALIGNED</dt><dd>This encoding
-** value may be used as the 3rd parameter (the eTextRep parameter) to
-** [sqlite3_create_collation()] and similar.  This encoding value means
-** that the application-defined collating sequence created expects its
-** input strings to be in UTF16 in native byte order, and that the start
-** of the strings must be aligned to a 2-byte boundary.
-**
-** [[SQLITE_UTF8_ZT]] <dt>SQLITE_UTF8_ZT</dt><dd>This option can only be
-** used to specify the text encoding to strings input to
-** [sqlite3_result_text64()] and [sqlite3_bind_text64()].
-** The SQLITE_UTF8_ZT encoding means that the input string (call it "z")
-** is UTF-8 encoded and that it is zero-terminated.  If the length parameter
-** (call it "n") is non-negative, this encoding option means that the caller
-** guarantees that z array contains at least n+1 bytes and that the z&#91;n&#93;
-** byte has a value of zero.
-** This option gives the same output as SQLITE_UTF8, but can be more efficient
-** by avoiding the need to make a copy of the input string, in some cases.
-** However, if z is allocated to hold fewer than n+1 bytes or if the
-** z&#91;n&#93; byte is not zero, undefined behavior may result.
-** </dl>
-*/
-#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 */
-#define SQLITE_UTF8_ZT       16    /* Zero-terminated UTF8 */
-
-/*
-** 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()].
-**
-** <dl>
-** [[SQLITE_DETERMINISTIC]] <dt>SQLITE_DETERMINISTIC</dt><dd>
-** 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.
-** </dd>
-**
-** [[SQLITE_DIRECTONLY]] <dt>SQLITE_DIRECTONLY</dt><dd>
-** 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].
-** <p>
-** 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 surreptitiously
-** modified to invoke the application-defined function in ways that are
-** harmful.
-** <p>
-** 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.
-** </dd>
-**
-** [[SQLITE_INNOCUOUS]] <dt>SQLITE_INNOCUOUS</dt><dd>
-** 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.
-** <p> 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.
-** <p>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.
-** </dd>
-**
-** [[SQLITE_SUBTYPE]] <dt>SQLITE_SUBTYPE</dt><dd>
-** The SQLITE_SUBTYPE flag indicates to SQLite that a function might call
-** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
-** This flag instructs SQLite to omit some corner-case optimizations that
-** might disrupt the operation of the [sqlite3_value_subtype()] function,
-** causing it to return zero rather than the correct subtype().
-** All SQL functions that invoke [sqlite3_value_subtype()] should have this
-** property.  If the SQLITE_SUBTYPE property is omitted, then the return
-** value from [sqlite3_value_subtype()] might sometimes be zero even though
-** a non-zero subtype was specified by the function argument expression.
-**
-** [[SQLITE_RESULT_SUBTYPE]] <dt>SQLITE_RESULT_SUBTYPE</dt><dd>
-** The SQLITE_RESULT_SUBTYPE flag indicates to SQLite that a function might call
-** [sqlite3_result_subtype()] to cause a sub-type to be associated with its
-** result.
-** Every function that invokes [sqlite3_result_subtype()] should have this
-** property.  If it does not, then the call to [sqlite3_result_subtype()]
-** might become a no-op if the function is used as a term in an
-** [expression index].  On the other hand, SQL functions that never invoke
-** [sqlite3_result_subtype()] should avoid setting this property, as the
-** purpose of this property is to disable certain optimizations that are
-** incompatible with subtypes.
-**
-** [[SQLITE_SELFORDER1]] <dt>SQLITE_SELFORDER1</dt><dd>
-** The SQLITE_SELFORDER1 flag indicates that the function is an aggregate
-** that internally orders the values provided to the first argument.  The
-** ordered-set aggregate SQL notation with a single ORDER BY term can be
-** used to invoke this function.  If the ordered-set aggregate notation is
-** used on a function that lacks this flag, then an error is raised. Note
-** that the ordered-set aggregate syntax is only available if SQLite is
-** built using the -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES compile-time option.
-** </dd>
-** </dl>
-*/
-#define SQLITE_DETERMINISTIC    0x000000800
-#define SQLITE_DIRECTONLY       0x000080000
-#define SQLITE_SUBTYPE          0x000100000
-#define SQLITE_INNOCUOUS        0x000200000
-#define SQLITE_RESULT_SUBTYPE   0x001000000
-#define SQLITE_SELFORDER1       0x002000000
-
-/*
-** 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
-**
-** <b>Summary:</b>
-** <blockquote><table border=0 cellpadding=0 cellspacing=0>
-** <tr><td><b>sqlite3_value_blob</b><td>&rarr;<td>BLOB value
-** <tr><td><b>sqlite3_value_double</b><td>&rarr;<td>REAL value
-** <tr><td><b>sqlite3_value_int</b><td>&rarr;<td>32-bit INTEGER value
-** <tr><td><b>sqlite3_value_int64</b><td>&rarr;<td>64-bit INTEGER value
-** <tr><td><b>sqlite3_value_pointer</b><td>&rarr;<td>Pointer value
-** <tr><td><b>sqlite3_value_text</b><td>&rarr;<td>UTF-8 TEXT value
-** <tr><td><b>sqlite3_value_text16</b><td>&rarr;<td>UTF-16 TEXT value in
-** the native byteorder
-** <tr><td><b>sqlite3_value_text16be</b><td>&rarr;<td>UTF-16be TEXT value
-** <tr><td><b>sqlite3_value_text16le</b><td>&rarr;<td>UTF-16le TEXT value
-** <tr><td>&nbsp;<td>&nbsp;<td>&nbsp;
-** <tr><td><b>sqlite3_value_bytes</b><td>&rarr;<td>Size of a BLOB
-** or a UTF-8 TEXT in bytes
-** <tr><td><b>sqlite3_value_bytes16&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>Size of UTF-16
-** TEXT in bytes
-** <tr><td><b>sqlite3_value_type</b><td>&rarr;<td>Default
-** datatype of the value
-** <tr><td><b>sqlite3_value_numeric_type&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>Best numeric datatype of the value
-** <tr><td><b>sqlite3_value_nochange&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>True if the column is unchanged in an UPDATE
-** against a virtual table.
-** <tr><td><b>sqlite3_value_frombind&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>True if value originated from a [bound parameter]
-** </table></blockquote>
-**
-** <b>Details:</b>
-**
-** 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
-** the prior [xColumn] method call that was invoked to extract
-** 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 while trying to do a
-** UTF8&rarr;UTF16 or UTF16&rarr;UTF8 conversion.
-** 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.
-** If the input sqlite3_value was not obtained from [sqlite3_value_dup()],
-** then valid SQL NULL returns can also be distinguished from
-** out-of-memory errors after extracting the value
-** by invoking the [sqlite3_errcode()] immediately after the suspicious
-** return value is obtained and before any
-** other SQLite interface is called on the same [database connection].
-** If the input sqlite3_value was obtained from sqlite3_value_dup() then
-** it is disconnected from the database connection and so sqlite3_errcode()
-** will not work.
-** In that case, the only way to distinguish an out-of-memory
-** condition from a true SQL NULL is to invoke sqlite3_value_type() on the
-** input to see if it is NULL prior to trying to extract the value.
-*/
-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.
-**
-** Every [application-defined SQL function] that invokes this interface
-** should include the [SQLITE_SUBTYPE] property in the text
-** encoding argument when the function is [sqlite3_create_function|registered].
-** If the [SQLITE_SUBTYPE] property is omitted, then sqlite3_value_subtype()
-** might return zero instead of the upstream subtype in some corner cases.
-*/
-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 V 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 the 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 auxiliary data with argument values. If the same argument
-** value is passed to multiple invocations of the same SQL function during
-** query execution, under some circumstances the associated auxiliary data
-** might 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 auxiliary data 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 auxiliary
-** data 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 auxiliary data
-** 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 auxiliary data 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 auxiliary data is still valid or
-** NULL if the auxiliary data 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 auxiliary data is discarded.
-** SQLite is free to discard the auxiliary data at any time, including: <ul>
-** <li> ^(when the corresponding function parameter changes)^, or
-** <li> ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
-**      SQL statement)^, or
-** <li> ^(when sqlite3_set_auxdata() is invoked again on the same
-**       parameter)^, or
-** <li> ^(during the original sqlite3_set_auxdata() call when a memory
-**      allocation error occurs.)^
-** <li> ^(during the original sqlite3_set_auxdata() call if the function
-**      is evaluated during query planning instead of during query execution,
-**      as sometimes happens with [SQLITE_ENABLE_STAT4].)^ </ul>
-**
-** Note the last two bullets 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.  Furthermore, a call to
-** sqlite3_get_auxdata() that occurs immediately after a corresponding call
-** to sqlite3_set_auxdata() might still return NULL if an out-of-memory
-** condition occurred during the sqlite3_set_auxdata() call or if the
-** function is being evaluated during query planning rather than during
-** query execution.
-**
-** ^(In practice, auxiliary data 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.
-**
-** See also: [sqlite3_get_clientdata()] and [sqlite3_set_clientdata()].
-*/
-SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
-SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
-
-/*
-** CAPI3REF: Database Connection Client Data
-** METHOD: sqlite3
-**
-** These functions are used to associate one or more named pointers
-** with a [database connection].
-** A call to sqlite3_set_clientdata(D,N,P,X) causes the pointer P
-** to be attached to [database connection] D using name N.  Subsequent
-** calls to sqlite3_get_clientdata(D,N) will return a copy of pointer P
-** or a NULL pointer if there were no prior calls to
-** sqlite3_set_clientdata() with the same values of D and N.
-** Names are compared using strcmp() and are thus case sensitive.
-** It returns 0 on success and SQLITE_NOMEM on allocation failure.
-**
-** If P and X are both non-NULL, then the destructor X is invoked with
-** argument P on the first of the following occurrences:
-** <ul>
-** <li> An out-of-memory error occurs during the call to
-**      sqlite3_set_clientdata() which attempts to register pointer P.
-** <li> A subsequent call to sqlite3_set_clientdata(D,N,P,X) is made
-**      with the same D and N parameters.
-** <li> The database connection closes.  SQLite does not make any guarantees
-**      about the order in which destructors are called, only that all
-**      destructors will be called exactly once at some point during the
-**      database connection closing process.
-** </ul>
-**
-** SQLite does not do anything with client data other than invoke
-** destructors on the client data at the appropriate time.  The intended
-** use for client data is to provide a mechanism for wrapper libraries
-** to store additional information about an SQLite database connection.
-**
-** There is no limit (other than available memory) on the number of different
-** client data pointers (with different names) that can be attached to a
-** single database connection.  However, the current implementation stores
-** the content on a linked list.  Insert and retrieval performance will
-** be proportional to the number of entries.  The design use case, and
-** the use case for which the implementation is optimized, is
-** that an application will store only small number of client data names,
-** typically just one or two.  This interface is not intended to be a
-** generalized key/value store for thousands or millions of keys.  It
-** will work for that, but performance might be disappointing.
-**
-** There is no way to enumerate the client data pointers
-** associated with a database connection.  The N parameter can be thought
-** of as a secret key such that only code that knows the secret key is able
-** to access the associated data.
-**
-** Security Warning:  These interfaces should not be exposed in scripting
-** languages or in other circumstances where it might be possible for an
-** attacker to invoke them.  Any agent that can invoke these interfaces
-** can probably also take control of the process.
-**
-** Database connection client data is only available for SQLite
-** version 3.44.0 ([dateof:3.44.0]) and later.
-**
-** See also: [sqlite3_set_auxdata()] and [sqlite3_get_auxdata()].
-*/
-SQLITE_API void *sqlite3_get_clientdata(sqlite3*,const char*);
-SQLITE_API int sqlite3_set_clientdata(sqlite3*, const char*, 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(C,Z,N,D,E) interface sets the return value of an
-** application-defined function to be a text string in an encoding
-** specified the E parameter, which must be one
-** of [SQLITE_UTF8], [SQLITE_UTF8_ZT], [SQLITE_UTF16], [SQLITE_UTF16BE],
-** or [SQLITE_UTF16LE].  ^The special value [SQLITE_UTF8_ZT] means that
-** the result text is both UTF-8 and zero-terminated.  In other words,
-** SQLITE_UTF8_ZT means that the Z array holds at least N+1 bytes and that
-** the Z&#91;N&#93; is zero.
-** ^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 were 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 a 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 *z, sqlite3_uint64 n,
-                           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.
-**
-** Every [application-defined SQL function] that invokes this interface
-** should include the [SQLITE_RESULT_SUBTYPE] property in its
-** text encoding argument when the SQL function is
-** [sqlite3_create_function|registered].  If the [SQLITE_RESULT_SUBTYPE]
-** property is omitted from the function that invokes sqlite3_result_subtype(),
-** then in some cases the sqlite3_result_subtype() might fail to set
-** the result subtype.
-**
-** If SQLite is compiled with -DSQLITE_STRICT_SUBTYPE=1, then any
-** SQL function that invokes the sqlite3_result_subtype() interface
-** and that does not have the SQLITE_RESULT_SUBTYPE property will raise
-** an error.  Future versions of SQLite might enable -DSQLITE_STRICT_SUBTYPE=1
-** by default.
-*/
-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:
-** <ul>
-** <li> [SQLITE_UTF8],
-** <li> [SQLITE_UTF16LE],
-** <li> [SQLITE_UTF16BE],
-** <li> [SQLITE_UTF16], or
-** <li> [SQLITE_UTF16_ALIGNED].
-** </ul>)^
-** ^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:
-**
-** <ol>
-** <li> If A==B then B==A.
-** <li> If A==B and B==C then A==C.
-** <li> If A&lt;B THEN B&gt;A.
-** <li> If A&lt;B and B&lt;C then A&lt;C.
-** </ol>
-**
-** 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 <u>not</u> 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*)
-);
-
-#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.
-**
-** <b>Note to Windows Runtime users:</b>  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:
-**
-** <blockquote><pre>
-** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
-** &nbsp;     TemporaryFolder->Path->Data();
-** char zPathBuf&#91;MAX_PATH + 1&#93;;
-** memset(zPathBuf, 0, sizeof(zPathBuf));
-** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
-** &nbsp;     NULL, NULL);
-** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
-** </pre></blockquote>
-*/
-SQLITE_API SQLITE_EXTERN 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 SQLITE_EXTERN 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 if 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:
-** <ul>
-** <li> [sqlite3_uri_parameter()]
-** <li> [sqlite3_uri_boolean()]
-** <li> [sqlite3_uri_int64()]
-** <li> [sqlite3_filename_database()]
-** <li> [sqlite3_filename_journal()]
-** <li> [sqlite3_filename_wal()]
-** </ul>
-*/
-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):
-** <ol>
-** <li value="0"> SQLITE_TXN_NONE
-** <li value="1"> SQLITE_TXN_READ
-** <li value="2"> SQLITE_TXN_WRITE
-** </ol>
-** ^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.
-**
-** <dl>
-** [[SQLITE_TXN_NONE]] <dt>SQLITE_TXN_NONE</dt>
-** <dd>The SQLITE_TXN_NONE state means that no transaction is currently
-** pending.</dd>
-**
-** [[SQLITE_TXN_READ]] <dt>SQLITE_TXN_READ</dt>
-** <dd>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 be 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].</dd>
-**
-** [[SQLITE_TXN_WRITE]] <dt>SQLITE_TXN_WRITE</dt>
-** <dd>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
-** SQLITE_TXN_NONE at the next [ROLLBACK] or [COMMIT].</dd>
-*/
-#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.
-**
-** <p>^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.
-**
-** <p><b>The callback is not reentrant.</b> 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().
-**
-** <p>^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 canceled.  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.
-**
-** <p>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:
-**
-** <blockquote><pre>
-** &nbsp;   unsigned int demonstration_autovac_pages_callback(
-** &nbsp;     void *pClientData,
-** &nbsp;     const char *zSchema,
-** &nbsp;     unsigned int nDbPage,
-** &nbsp;     unsigned int nFreePage,
-** &nbsp;     unsigned int nBytePerPage
-** &nbsp;   ){
-** &nbsp;     return nFreePage;
-** &nbsp;   }
-** </pre></blockquote>
-*/
-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 update hook is disabled by invoking sqlite3_update_hook()
-** with a NULL pointer as the second parameter.
-** ^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.
-**
-** Whether the update hook is invoked before or after the
-** corresponding change is currently unspecified and may differ
-** depending on the type of change. Do not rely on the order of the
-** hook call with regards to the final result of the operation which
-** triggers the hook.
-**
-** 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
-** used 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:
-**
-** <ul>
-** <li> The limit value is set to zero.
-** <li> 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.
-** <li> An alternative page cache implementation is specified using
-**      [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...).
-** <li> The page cache allocates from its own memory pool supplied
-**      by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than
-**      from the heap.
-** </ul>)^
-**
-** The circumstances under which SQLite will enforce the heap limits may
-** change 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.
-**
-** ^(<blockquote>
-** <table border="1">
-** <tr><th> Parameter <th> Output<br>Type <th>  Description
-**
-** <tr><td> 5th <td> const char* <td> Data type
-** <tr><td> 6th <td> const char* <td> Name of default collation sequence
-** <tr><td> 7th <td> int         <td> True if column has a NOT NULL constraint
-** <tr><td> 8th <td> int         <td> True if column is part of the PRIMARY KEY
-** <tr><td> 9th <td> int         <td> True if column is [AUTOINCREMENT]
-** </table>
-** </blockquote>)^
-**
-** ^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:
-**
-** <pre>
-**     data type: "INTEGER"
-**     collation sequence: "BINARY"
-**     not null: 0
-**     primary key: 1
-**     auto increment: 0
-** </pre>)^
-**
-** ^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 filename 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 tries names of the form "sqlite3_X_init"
-** where X consists of the lower-case equivalent of all ASCII alphabetic
-** characters or all ASCII alphanumeric 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.
-**
-** <b>Security warning:</b> 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.)^
-**
-** <b>Security warning:</b> 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 were as follows:
-**
-** <blockquote><pre>
-** &nbsp;  int xEntryPoint(
-** &nbsp;    sqlite3 *db,
-** &nbsp;    char **pzErrMsg,
-** &nbsp;    const struct sqlite3_api_routines *pThunk
-** &nbsp;  );
-** </pre></blockquote>)^
-**
-** 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*);
-  /* The methods above are in versions 1 through 3 of the sqlite_module object.
-  ** Those below are for version 4 and greater. */
-  int (*xIntegrity)(sqlite3_vtab *pVTab, const char *zSchema,
-                    const char *zTabName, int mFlags, char **pzErr);
-};
-
-/*
-** 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:
-**
-** <blockquote>column OP expr</blockquote>
-**
-** where OP is =, &lt;, &lt;=, &gt;, or &gt;=.)^  ^(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 changed 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. One such flag is
-** [SQLITE_INDEX_SCAN_HEX], which if set causes the [EXPLAIN QUERY PLAN]
-** output to show the idxNum as hex instead of as decimal.  Another flag is
-** SQLITE_INDEX_SCAN_UNIQUE, which if set indicates that the query plan will
-** return 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 0x00000001 /* Scan visits at most 1 row */
-#define SQLITE_INDEX_SCAN_HEX    0x00000002 /* Display idxNum as hex */
-                                            /* in EXPLAIN QUERY PLAN */
-
-/*
-** 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 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:
-**
-** <pre>
-**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
-** </pre>)^
-**
-** ^(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 returns.
-**
-** This function fails with SQLITE_ERROR if any of the following are true:
-** <ul>
-**   <li> ^(Database zDb does not exist)^,
-**   <li> ^(Table zTable does not exist within database zDb)^,
-**   <li> ^(Table zTable is a WITHOUT ROWID table)^,
-**   <li> ^(Column zColumn does not exist)^,
-**   <li> ^(Row iRow is not present in the table)^,
-**   <li> ^(The specified column of row iRow contains a value that is not
-**         a TEXT or BLOB value)^,
-**   <li> ^(Column zColumn is part of an index, PRIMARY KEY or UNIQUE
-**         constraint and the blob is being opened for read/write access)^,
-**   <li> ^([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)^.
-** </ul>
-**
-** ^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 behavior. ^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 overwrite 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:
-**
-** <ul>
-** <li>   SQLITE_MUTEX_PTHREADS
-** <li>   SQLITE_MUTEX_W32
-** <li>   SQLITE_MUTEX_NOOP
-** </ul>
-**
-** 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.
-**
-**
-** ^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 be one of these
-** integer constants:
-**
-** <ul>
-** <li>  SQLITE_MUTEX_FAST
-** <li>  SQLITE_MUTEX_RECURSIVE
-** <li>  SQLITE_MUTEX_STATIC_MAIN
-** <li>  SQLITE_MUTEX_STATIC_MEM
-** <li>  SQLITE_MUTEX_STATIC_OPEN
-** <li>  SQLITE_MUTEX_STATIC_PRNG
-** <li>  SQLITE_MUTEX_STATIC_LRU
-** <li>  SQLITE_MUTEX_STATIC_PMEM
-** <li>  SQLITE_MUTEX_STATIC_APP1
-** <li>  SQLITE_MUTEX_STATIC_APP2
-** <li>  SQLITE_MUTEX_STATIC_APP3
-** <li>  SQLITE_MUTEX_STATIC_VFS1
-** <li>  SQLITE_MUTEX_STATIC_VFS2
-** <li>  SQLITE_MUTEX_STATIC_VFS3
-** </ul>
-**
-** ^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. In most cases the SQLite core only uses
-** sqlite3_mutex_try() as an optimization, so this is acceptable
-** behavior. The exceptions are unix builds that set the
-** SQLITE_ENABLE_SETLK_TIMEOUT build option. In that case a working
-** sqlite3_mutex_try() is required.)^
-**
-** ^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):
-**
-** <ul>
-**   <li>  [sqlite3_mutex_alloc()] </li>
-**   <li>  [sqlite3_mutex_free()] </li>
-**   <li>  [sqlite3_mutex_enter()] </li>
-**   <li>  [sqlite3_mutex_try()] </li>
-**   <li>  [sqlite3_mutex_leave()] </li>
-**   <li>  [sqlite3_mutex_held()] </li>
-**   <li>  [sqlite3_mutex_notheld()] </li>
-** </ul>)^
-**
-** 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 to 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_FK_NO_ACTION             7
-#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_JSON_SELFCHECK          14
-#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
-#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
-#define SQLITE_TESTCTRL_GETOPT                  16
-#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_USELONGDOUBLE           34  /* NOT USED */
-#define SQLITE_TESTCTRL_ATOF                    34
-#define SQLITE_TESTCTRL_LAST                    34  /* Largest TESTCTRL */
-
-/*
-** CAPI3REF: SQL Keyword Checking
-**
-** These routines provide access to the set of SQL language keywords
-** recognized by SQLite.  Applications can use 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 0-based 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:
-** <ul>
-** <li> Put all identifier names inside double-quotes.  This is the official
-**      SQL way to escape identifier names.
-** <li> Put identifier names inside &#91;...&#93;.  This is not standard SQL,
-**      but it is what SQL Server does and so lots of programmers use this
-**      technique.
-** <li> Begin every identifier with the letter "Z" as no SQL keywords start
-**      with "Z".
-** <li> Include a digit somewhere in every identifier name.
-** </ul>
-**
-** 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:
-** <ol>
-** <li> ^The sqlite3_str object is created using [sqlite3_str_new()].
-** <li> ^Text is appended to the sqlite3_str object using various
-** methods, such as [sqlite3_str_appendf()].
-** <li> ^The sqlite3_str object is destroyed and the string it created
-** is returned using the [sqlite3_str_finish()] interface.
-** </ol>
-*/
-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 might also return a NULL pointer if the
-** string in [sqlite3_str] object X is zero bytes long.
-**
-** ^The [sqlite3_str_free(X)] interface destroys both the sqlite3_str object
-** X and the string content it contains.  Calling sqlite3_str_free(X) is
-** the equivalent of calling [sqlite3_free](sqlite3_str_finish(X)).
-*/
-SQLITE_API char *sqlite3_str_finish(sqlite3_str*);
-SQLITE_API void sqlite3_str_free(sqlite3_str*);
-
-/*
-** CAPI3REF: Add Content To A Dynamic String
-** METHOD: sqlite3_str
-**
-** These interfaces add or remove 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.
-**
-** ^The [sqlite3_str_truncate(X,N)] method changes the length of the string
-** under construction to be N bytes or less.  This routine is a no-op if
-** N is negative or if the string is already N bytes or smaller in size.
-**
-** 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*);
-SQLITE_API void sqlite3_str_truncate(sqlite3_str*,int N);
-
-/*
-** 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 use the pointer returned by
-** [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()].
-**
-** <dl>
-** [[SQLITE_STATUS_MEMORY_USED]] ^(<dt>SQLITE_STATUS_MEMORY_USED</dt>
-** <dd>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].</dd>)^
-**
-** [[SQLITE_STATUS_MALLOC_SIZE]] ^(<dt>SQLITE_STATUS_MALLOC_SIZE</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_STATUS_MALLOC_COUNT]] ^(<dt>SQLITE_STATUS_MALLOC_COUNT</dt>
-** <dd>This parameter records the number of separate memory allocations
-** currently checked out.</dd>)^
-**
-** [[SQLITE_STATUS_PAGECACHE_USED]] ^(<dt>SQLITE_STATUS_PAGECACHE_USED</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]]
-** ^(<dt>SQLITE_STATUS_PAGECACHE_OVERFLOW</dt>
-** <dd>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
-** were 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.</dd>)^
-**
-** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(<dt>SQLITE_STATUS_PAGECACHE_SIZE</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_STATUS_SCRATCH_USED]] <dt>SQLITE_STATUS_SCRATCH_USED</dt>
-** <dd>No longer used.</dd>
-**
-** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(<dt>SQLITE_STATUS_SCRATCH_OVERFLOW</dt>
-** <dd>No longer used.</dd>
-**
-** [[SQLITE_STATUS_SCRATCH_SIZE]] <dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
-** <dd>No longer used.</dd>
-**
-** [[SQLITE_STATUS_PARSER_STACK]] ^(<dt>SQLITE_STATUS_PARSER_STACK</dt>
-** <dd>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].</dd>)^
-** </dl>
-**
-** 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.
-**
-** ^The sqlite3_db_status64(D,O,C,H,R) routine works exactly the same
-** way as sqlite3_db_status(D,O,C,H,R) routine except that the C and H
-** parameters are pointer to 64-bit integers (type: sqlite3_int64) instead
-** of pointers to 32-bit integers, which allows larger status values
-** to be returned.  If a status value exceeds 2,147,483,647 then
-** sqlite3_db_status() will truncate the value whereas sqlite3_db_status64()
-** will return the full value.
-**
-** See also: [sqlite3_status()] and [sqlite3_stmt_status()].
-*/
-SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
-SQLITE_API int sqlite3_db_status64(sqlite3*,int,sqlite3_int64*,sqlite3_int64*,int);
-
-/*
-** 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.
-**
-** <dl>
-** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt>
-** <dd>This parameter returns the number of lookaside memory slots currently
-** checked out.</dd>)^
-**
-** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_HIT</dt>
-** <dd>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.</dd>)^
-**
-** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]]
-** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>
-** <dd>This parameter returns the number of 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.</dd>)^
-**
-** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]]
-** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL</dt>
-** <dd>This parameter returns the number of 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.</dd>)^
-**
-** [[SQLITE_DBSTATUS_CACHE_USED]] ^(<dt>SQLITE_DBSTATUS_CACHE_USED</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_USED_SHARED]]
-** ^(<dt>SQLITE_DBSTATUS_CACHE_USED_SHARED</dt>
-** <dd>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 of 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.</dd>
-**
-** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(<dt>SQLITE_DBSTATUS_SCHEMA_USED</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_STMT_USED]] ^(<dt>SQLITE_DBSTATUS_STMT_USED</dt>
-** <dd>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.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(<dt>SQLITE_DBSTATUS_CACHE_HIT</dt>
-** <dd>This parameter returns the number of pager cache hits that have
-** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT
-** is always 0.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(<dt>SQLITE_DBSTATUS_CACHE_MISS</dt>
-** <dd>This parameter returns the number of pager cache misses that have
-** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS
-** is always 0.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(<dt>SQLITE_DBSTATUS_CACHE_WRITE</dt>
-** <dd>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.
-** <p>
-** ^(There is overlap between the quantities measured by this parameter
-** (SQLITE_DBSTATUS_CACHE_WRITE) and SQLITE_DBSTATUS_TEMPBUF_SPILL.
-** Resetting one will reduce the other.)^
-** </dd>
-**
-** [[SQLITE_DBSTATUS_CACHE_SPILL]] ^(<dt>SQLITE_DBSTATUS_CACHE_SPILL</dt>
-** <dd>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 to help identify
-** inefficiencies that can be resolved by increasing the cache size.
-** </dd>
-**
-** [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(<dt>SQLITE_DBSTATUS_DEFERRED_FKS</dt>
-** <dd>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.
-**
-** [[SQLITE_DBSTATUS_TEMPBUF_SPILL] ^(<dt>SQLITE_DBSTATUS_TEMPBUF_SPILL</dt>
-** <dd>^(This parameter returns the number of bytes written to temporary
-** files on disk that could have been kept in memory had sufficient memory
-** been available.  This value includes writes to intermediate tables that
-** are part of complex queries, external sorts that spill to disk, and
-** writes to TEMP tables.)^
-** ^The highwater mark is always 0.
-** <p>
-** ^(There is overlap between the quantities measured by this parameter
-** (SQLITE_DBSTATUS_TEMPBUF_SPILL) and SQLITE_DBSTATUS_CACHE_WRITE.
-** Resetting one will reduce the other.)^
-** </dd>
-** </dl>
-*/
-#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_TEMPBUF_SPILL       13
-#define SQLITE_DBSTATUS_MAX                 13   /* 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:
-**
-** <dl>
-** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]] <dt>SQLITE_STMTSTATUS_FULLSCAN_STEP</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_SORT]] <dt>SQLITE_STMTSTATUS_SORT</dt>
-** <dd>^This is the number of sort operations that have occurred.
-** A non-zero value in this counter may indicate an opportunity to
-** improve performance through careful use of indices.</dd>
-**
-** [[SQLITE_STMTSTATUS_AUTOINDEX]] <dt>SQLITE_STMTSTATUS_AUTOINDEX</dt>
-** <dd>^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
-** improve performance by adding permanent indices that do not
-** need to be reinitialized each time the statement is run.</dd>
-**
-** [[SQLITE_STMTSTATUS_VM_STEP]] <dt>SQLITE_STMTSTATUS_VM_STEP</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_REPREPARE]] <dt>SQLITE_STMTSTATUS_REPREPARE</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_RUN]] <dt>SQLITE_STMTSTATUS_RUN</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_FILTER_MISS]]
-** [[SQLITE_STMTSTATUS_FILTER HIT]]
-** <dt>SQLITE_STMTSTATUS_FILTER_HIT<br>
-** SQLITE_STMTSTATUS_FILTER_MISS</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_STMTSTATUS_MEMUSED]] <dt>SQLITE_STMTSTATUS_MEMUSED</dt>
-** <dd>^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.
-** </dd>
-** </dl>
-*/
-#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 be 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 be
-** 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 upon 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 set to 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) for 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 determine what action to take:
-**
-** <table border=1 width=85% align=center>
-** <tr><th> createFlag <th> Behavior when page is not already in cache
-** <tr><td> 0 <td> Do not allocate a new page.  Return NULL.
-** <tr><td> 1 <td> Allocate a new page if it is easy and convenient to do so.
-**                 Otherwise return NULL.
-** <tr><td> 2 <td> Make every effort to allocate a new page.  Only return
-**                 NULL if allocating a new page is effectively impossible.
-** </table>
-**
-** ^(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 the
-** 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 become 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:
-**   <ol>
-**     <li><b>sqlite3_backup_init()</b> is called once to initialize the
-**         backup,
-**     <li><b>sqlite3_backup_step()</b> is called one or more times to transfer
-**         the data between the two databases, and finally
-**     <li><b>sqlite3_backup_finish()</b> is called to release all resources
-**         associated with the backup operation.
-**   </ol>)^
-** There should be exactly one call to sqlite3_backup_finish() for each
-** successful call to sqlite3_backup_init().
-**
-** [[sqlite3_backup_init()]] <b>sqlite3_backup_init()</b>
-**
-** ^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()]] <b>sqlite3_backup_step()</b>
-**
-** ^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
-** <ol>
-** <li> the destination database was opened read-only, or
-** <li> the destination database is using write-ahead-log journaling
-** and the destination and source page sizes differ, or
-** <li> the destination database is an in-memory database and the
-** destination and source page sizes differ.
-** </ol>)^
-**
-** ^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 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()]] <b>sqlite3_backup_finish()</b>
-**
-** 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 of 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()]]
-** <b>sqlite3_backup_remaining() and sqlite3_backup_pagecount()</b>
-**
-** ^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().)^
-**
-** <b>Concurrent Usage of Database Handles</b>
-**
-** ^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.
-**
-** <b>Alternatives To Using The Backup API</b>
-**
-** Other techniques for safely creating a consistent backup of an SQLite
-** database include:
-**
-** <ul>
-** <li> The [VACUUM INTO] command.
-** <li> The [sqlite3_rsync] utility program.
-** </ul>
-*/
-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 connection's 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 connection's
-** 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.
-**
-** <b>Callback Invocation Details</b>
-**
-** 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.
-**
-** <b>Deadlock Detection</b>
-**
-** 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.
-**
-** <b>The "DROP TABLE" Exception</b>
-**
-** 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 the default behavior or previously registered write-ahead
-** log callback.
-**
-** ^The return value is a copy of the third parameter from the
-** previous call, if any, or 0.
-**
-** ^The [sqlite3_wal_autocheckpoint()] interface and the
-** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and
-** will overwrite any prior [sqlite3_wal_hook()] settings.
-**
-** ^If a write-ahead log callback is set using this function then
-** [sqlite3_wal_checkpoint_v2()] or [PRAGMA wal_checkpoint]
-** should be invoked periodically to keep the write-ahead log file
-** from growing without bound.
-**
-** ^Passing a NULL pointer for the callback disables automatic
-** checkpointing entirely. To re-enable the default behavior, call
-** sqlite3_wal_autocheckpoint(db,1000) or use [PRAGMA wal_checkpoint].
-*/
-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 N 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]:)^
-**
-** <dl>
-** <dt>SQLITE_CHECKPOINT_PASSIVE<dd>
-**   ^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.
-**
-** <dt>SQLITE_CHECKPOINT_FULL<dd>
-**   ^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.
-**
-** <dt>SQLITE_CHECKPOINT_RESTART<dd>
-**   ^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.
-**
-** <dt>SQLITE_CHECKPOINT_TRUNCATE<dd>
-**   ^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.
-**
-** <dt>SQLITE_CHECKPOINT_NOOP<dd>
-**   ^This mode always checkpoints zero frames. The only reason to invoke
-**   a NOOP checkpoint is to access the values returned by
-**   sqlite3_wal_checkpoint_v2() via output parameters *pnLog and *pnCkpt.
-** </dl>
-**
-** ^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_NOOP    -1  /* Do no work at all */
-#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.
-**
-** <dl>
-** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]]
-** <dt>SQLITE_VTAB_CONSTRAINT_SUPPORT</dt>
-** <dd>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 user's 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.
-** </dd>
-**
-** [[SQLITE_VTAB_DIRECTONLY]]<dt>SQLITE_VTAB_DIRECTONLY</dt>
-** <dd>Calls of the form
-** [sqlite3_vtab_config](db,SQLITE_VTAB_DIRECTONLY) from within the
-** the [xConnect] or [xCreate] methods of a [virtual table] implementation
-** prohibits that virtual table from being used from within triggers and
-** views.
-** </dd>
-**
-** [[SQLITE_VTAB_INNOCUOUS]]<dt>SQLITE_VTAB_INNOCUOUS</dt>
-** <dd>Calls of the form
-** [sqlite3_vtab_config](db,SQLITE_VTAB_INNOCUOUS) from within 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.
-** </dd>
-**
-** [[SQLITE_VTAB_USES_ALL_SCHEMAS]]<dt>SQLITE_VTAB_USES_ALL_SCHEMAS</dt>
-** <dd>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.
-** </dd>
-** </dl>
-*/
-#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:
-**
-** <ol>
-** <li><p> 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.
-** <li><p> 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.
-** <li><p> Otherwise, "BINARY" is returned.
-** </ol>
-*/
-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.
-**
-** <ol><li value="0"><p>
-** ^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().
-** <li value="1"><p>
-** ^(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.
-** <li value="2"><p>
-** ^(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 columns identified
-** by "aOrderBy" are adjacent.)^  ^(Furthermore, when two or more rows
-** contain the same values for all columns identified by "colUsed", all but
-** one such row may optionally be omitted from the result.)^
-** The virtual table is not required to omit rows that are duplicates
-** over the "colUsed" columns, but if the virtual table can do that without
-** too much extra effort, it could potentially help the query to run faster.
-** This mode is used for a DISTINCT query.
-** <li value="3"><p>
-** ^(If the sqlite3_vtab_distinct() interface returns 3, that means the
-** virtual table must return rows in the order defined by "aOrderBy" as
-** if the sqlite3_vtab_distinct() interface had returned 0.  However if
-** two or more rows in the result have the same values for all columns
-** identified by "colUsed", then all but one such row may optionally be
-** omitted.)^  Like when the return value is 2, the virtual table
-** is not required to omit rows that are duplicates over the "colUsed"
-** columns, but if the virtual table can do that without
-** too much extra effort, it could potentially help the query to run faster.
-** This mode is used for queries
-** that have both DISTINCT and ORDER BY clauses.
-** </ol>
-**
-** <p>The following table summarizes the conditions under which the
-** virtual table is allowed to set the "orderByConsumed" flag based on
-** the value returned by sqlite3_vtab_distinct().  This table is a
-** restatement of the previous four paragraphs:
-**
-** <table border=1 cellspacing=0 cellpadding=10 width="90%">
-** <tr>
-** <td valign="top">sqlite3_vtab_distinct() return value
-** <td valign="top">Rows are returned in aOrderBy order
-** <td valign="top">Rows with the same value in all aOrderBy columns are
-**                  adjacent
-** <td valign="top">Duplicates over all colUsed columns may be omitted
-** <tr><td>0<td>yes<td>yes<td>no
-** <tr><td>1<td>no<td>yes<td>no
-** <tr><td>2<td>no<td>yes<td>yes
-** <tr><td>3<td>yes<td>yes<td>yes
-** </table>
-**
-** ^For the purposes of comparing virtual table output values to see if the
-** values are the 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
-** "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 positive 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:
-**
-** <ol>
-** <li><p>
-**   ^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.
-**
-** <li><p>
-**   ^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.
-** </ol>
-**
-** ^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:
-**
-** <ol>
-** <li><p> 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.
-**
-** <li><p> The last call to sqlite3_vtab_in(P,N,F) for which F was
-** non-negative had F>=1.
-** </ol>)^
-**
-** ^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 using 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:
-**
-** <blockquote><pre>
-** &nbsp;  for(rc=sqlite3_vtab_in_first(pList, &pVal);
-** &nbsp;      rc==SQLITE_OK && pVal;
-** &nbsp;      rc=sqlite3_vtab_in_next(pList, &pVal)
-** &nbsp;  ){
-** &nbsp;    // do something with pVal
-** &nbsp;  }
-** &nbsp;  if( rc!=SQLITE_DONE ){
-** &nbsp;    // an error has occurred
-** &nbsp;  }
-** </pre></blockquote>)^
-**
-** ^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 a 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 of the [ON CONFLICT] mode
-** 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).
-**
-** <dl>
-** [[SQLITE_SCANSTAT_NLOOP]] <dt>SQLITE_SCANSTAT_NLOOP</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_NVISIT]] <dt>SQLITE_SCANSTAT_NVISIT</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_EST]] <dt>SQLITE_SCANSTAT_EST</dt>
-** <dd>^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 estimate 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.</dd>
-**
-** [[SQLITE_SCANSTAT_NAME]] <dt>SQLITE_SCANSTAT_NAME</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_EXPLAIN]] <dt>SQLITE_SCANSTAT_EXPLAIN</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECTID</dt>
-** <dd>^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.</dd>
-**
-** [[SQLITE_SCANSTAT_PARENTID]] <dt>SQLITE_SCANSTAT_PARENTID</dt>
-** <dd>The "int" variable pointed to by the V parameter will be set to 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.</dd>
-**
-** [[SQLITE_SCANSTAT_NCYCLE]] <dt>SQLITE_SCANSTAT_NCYCLE</dt>
-** <dd>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.</dd>
-** </dl>
-*/
-#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
-** retrieve statistics for 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()] and the
-** [nexec and ncycle] columns of the [bytecode virtual table].
-*/
-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 is 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, because
-** the new values are not yet available. In this case, when a
-** callback made with op==SQLITE_DELETE is actually 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.
-**
-** If a read-transaction is opened by this function, then it is guaranteed
-** that the returned snapshot object may not be invalidated by a database
-** writer or checkpointer until after the read-transaction is closed. This
-** is not guaranteed if a read-transaction is already open when this
-** function is called. In that case, any subsequent write or checkpoint
-** operation on the database may invalidate the returned snapshot handle,
-** even while the read-transaction remains open.
-**
-** 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.
-**
-** <ul>
-**   <li> The database handle must not be in [autocommit mode].
-**
-**   <li> Schema S of [database connection] D must be a [WAL mode] database.
-**
-**   <li> There must not be a write transaction open on schema S of database
-**        connection D.
-**
-**   <li> 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.
-** </ul>
-**
-** 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 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 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 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 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 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 S is a NULL pointer, the main database is used.
-** 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 were 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 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.
-**
-** After the call, if the SQLITE_SERIALIZE_NOCOPY bit had been set,
-** the returned buffer content will remain accessible and unchanged
-** until either the next write operation on the connection or when
-** the connection is closed, and applications must not modify the
-** buffer. If the bit had been clear, the returned buffer will not
-** be accessed by SQLite after the call.
-**
-** 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.  If S is a NULL pointer, the main database is
-** used. 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.
-**
-** Applications must not modify the buffer P or invalidate it before
-** the database connection D is closed.
-**
-** 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 deserialize 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.
-**
-** The deserialized database should not be in [WAL mode].  If the database
-** is in WAL mode, then any attempt to use the database file will result
-** in an [SQLITE_CANTOPEN] error.  The application can set the
-** [file format version numbers] (bytes 18 and 19) of the input database P
-** to 0x01 prior to invoking sqlite3_deserialize(D,S,P,N,M,F) to force the
-** database file into rollback mode and work around this limitation.
-**
-** 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 of 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 the 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 */
-
-/*
-** CAPI3REF: Bind array values to the CARRAY table-valued function
-**
-** The sqlite3_carray_bind_v2(S,I,P,N,F,X,D) interface binds an array value to
-** parameter that is the first argument of the [carray() table-valued function].
-** The S parameter is a pointer to the [prepared statement] that uses the
-** carray() functions.  I is the parameter index to be bound.  I must be the
-** index of the parameter that is the first argument to the carray()
-** table-valued function. P is a pointer to the array to be bound, and N
-** is the number of elements in the array.  The F argument is one of
-** constants [SQLITE_CARRAY_INT32], [SQLITE_CARRAY_INT64],
-** [SQLITE_CARRAY_DOUBLE], [SQLITE_CARRAY_TEXT],
-** or [SQLITE_CARRAY_BLOB] to indicate the datatype of the array P.
-**
-** If the X argument is not a NULL pointer or one of the special
-** values [SQLITE_STATIC] or [SQLITE_TRANSIENT], then SQLite will invoke
-** the function X with argument D when it is finished using the data in P.
-** The call to X(D) is a destructor for the array P. The destructor X(D)
-** is invoked even if the call to sqlite3_carray_bind_v2() fails. If the X
-** parameter is the special-case value [SQLITE_STATIC], then SQLite assumes
-** that the data static and the destructor is never invoked.  If the X
-** parameter is the special-case value [SQLITE_TRANSIENT], then
-** sqlite3_carray_bind_v2() makes its own private copy of the data prior
-** to returning and never invokes the destructor X.
-**
-** The sqlite3_carray_bind() function works the same as sqlite3_carray_bind_v2()
-** with a D parameter set to P.  In other words,
-** sqlite3_carray_bind(S,I,P,N,F,X) is same as
-** sqlite3_carray_bind_v2(S,I,P,N,F,X,P).
-*/
-SQLITE_API int sqlite3_carray_bind_v2(
-  sqlite3_stmt *pStmt,        /* Statement to be bound */
-  int i,                      /* Parameter index */
-  void *aData,                /* Pointer to array data */
-  int nData,                  /* Number of data elements */
-  int mFlags,                 /* CARRAY flags */
-  void (*xDel)(void*),        /* Destructor for aData */
-  void *pDel                  /* Optional argument to xDel() */
-);
-SQLITE_API int sqlite3_carray_bind(
-  sqlite3_stmt *pStmt,        /* Statement to be bound */
-  int i,                      /* Parameter index */
-  void *aData,                /* Pointer to array data */
-  int nData,                  /* Number of data elements */
-  int mFlags,                 /* CARRAY flags */
-  void (*xDel)(void*)         /* Destructor for aData */
-);
-
-/*
-** CAPI3REF: Datatypes for the CARRAY table-valued function
-**
-** The fifth argument to the [sqlite3_carray_bind()] interface musts be
-** one of the following constants, to specify the datatype of the array
-** that is being bound into the [carray table-valued function].
-*/
-#define SQLITE_CARRAY_INT32     0    /* Data is 32-bit signed integers */
-#define SQLITE_CARRAY_INT64     1    /* Data is 64-bit signed integers */
-#define SQLITE_CARRAY_DOUBLE    2    /* Data is doubles */
-#define SQLITE_CARRAY_TEXT      3    /* Data is char* */
-#define SQLITE_CARRAY_BLOB      4    /* Data is struct iovec */
-
-/*
-** Versions of the above #defines that omit the initial SQLITE_, for
-** legacy compatibility.
-*/
-#define CARRAY_INT32     0    /* Data is 32-bit signed integers */
-#define CARRAY_INT64     1    /* Data is 64-bit signed integers */
-#define CARRAY_DOUBLE    2    /* Data is doubles */
-#define CARRAY_TEXT      3    /* Data is char* */
-#define CARRAY_BLOB      4    /* Data is struct iovec */
-
-/*
-** 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
-# ifndef SQLITE_OMIT_LOAD_EXTENSION
-#  define SQLITE_OMIT_LOAD_EXTENSION
-# endif
-# ifndef SQLITE_THREADSAFE
-#  define SQLITE_THREADSAFE 0
-# endif
-#endif
-
-#ifdef __cplusplus
-}  /* End of the 'extern "C"' block */
-#endif
-/* #endif for SQLITE3_H will be added by mksqlite3.tcl */
-
-/******** 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_
-
-
-#ifdef __cplusplus
-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 <rtree> WHERE <rtree col> 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 <rtree> WHERE <rtree col> 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 */
-
-
-#ifdef __cplusplus
-}  /* 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++.
-*/
-#ifdef __cplusplus
-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().
-**
-** <dt>SQLITE_SESSION_OBJCONFIG_SIZE <dd>
-**   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.
-**
-** <dt>SQLITE_SESSION_OBJCONFIG_ROWID <dd>
-**   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:
-**
-** <ul>
-**   <li> The session object "indirect" flag is set when the change is
-**        made, or
-**   <li> The change is made by an SQL trigger or foreign key action
-**        instead of directly as a result of a users SQL statement.
-** </ul>
-**
-** 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.
-**
-** <h3>Special sqlite_stat1 Handling</h3>
-**
-** 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:
-**  <pre>
-**  &nbsp;     CREATE TABLE sqlite_stat1(tbl,idx,stat)
-**  </pre>
-**
-** 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()].
-**
-** <h3>Changeset Generation</h3>
-**
-** 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:
-**
-** <ul>
-**   <li> 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.
-**
-**   <li> 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.
-** </ul>
-**
-** 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 enabled, and
-** then another field of the same row is updated while the session is disabled,
-** 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:
-**
-** <ul>
-**   <li> Has the same name,
-**   <li> Has the same set of columns declared in the same order, and
-**   <li> Has the same PRIMARY KEY definition.
-** </ul>
-**
-** 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:
-**
-** <ul>
-**   <li> 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.
-**
-**   <li> 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.
-**
-**   <li> 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.
-** </ul>
-**
-** 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.
-**
-** Unless the call to this function is a no-op as described above, it is 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:
-**
-** <ul>
-**   <li> DELETE records consist of the primary key fields only. The
-**        original values of other fields are omitted.
-**   <li> The original values of any modified fields are omitted from
-**        UPDATE records.
-** </ul>
-**
-** 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:
-**
-** <ul>
-**   <li> [sqlite3changeset_next()]
-**   <li> [sqlite3changeset_op()]
-**   <li> [sqlite3changeset_new()]
-**   <li> [sqlite3changeset_old()]
-** </ul>
-**
-** 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 <b>experimental</b>
-** 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]:
-**
-** <dt>SQLITE_CHANGESETSTART_INVERT <dd>
-**   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:
-**
-** <ul>
-**   <li> The number of columns in the table, and
-**   <li> Which of those columns make up the tables PRIMARY KEY.
-** </ul>
-**
-** 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):
-**
-** <pre>
-**   sqlite3changeset_start();
-**   while( SQLITE_ROW==sqlite3changeset_next() ){
-**     // Do something with change.
-**   }
-**   rc = sqlite3changeset_finalize();
-**   if( rc!=SQLITE_OK ){
-**     // An error has occurred
-**   }
-** </pre>
-*/
-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:
-**
-** <ul>
-**   <li> Each DELETE change is changed to an INSERT, and
-**   <li> Each INSERT change is changed to a DELETE, and
-**   <li> For each UPDATE change, the old.* and new.* values are exchanged.
-** </ul>
-**
-** 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:
-**
-** <pre>
-**   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;
-**   }
-** </pre>
-**
-** 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:
-**
-** <ul>
-**   <li> It is created using a call to sqlite3changegroup_new().
-**
-**   <li> Zero or more changesets (or patchsets) are added to the object
-**        by calling sqlite3changegroup_add().
-**
-**   <li> The result of combining all input changesets together is obtained
-**        by the application via a call to sqlite3changegroup_output().
-**
-**   <li> The object is deleted using a call to sqlite3changegroup_delete().
-** </ul>
-**
-** 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 Schema to a Changegroup
-** METHOD: sqlite3_changegroup_schema
-**
-** This method may be used to optionally enforce the rule that the changesets
-** added to the changegroup handle must match the schema of database zDb
-** ("main", "temp", or the name of an attached database). If
-** sqlite3changegroup_add() is called to add a changeset that is not compatible
-** with the configured schema, SQLITE_SCHEMA is returned and the changegroup
-** object is left in an undefined state.
-**
-** A changeset schema is considered compatible with the database schema in
-** the same way as for sqlite3changeset_apply(). Specifically, for each
-** table in the changeset, there exists a database table with:
-**
-** <ul>
-**   <li> The name identified by the changeset, and
-**   <li> at least as many columns as recorded in the changeset, and
-**   <li> the primary key columns in the same position as recorded in
-**        the changeset.
-** </ul>
-**
-** The output of the changegroup object always has the same schema as the
-** database nominated using this function. In cases where changesets passed
-** to sqlite3changegroup_add() have fewer columns than the corresponding table
-** in the database schema, these are filled in using the default column
-** values from the database schema. This makes it possible to combined
-** changesets that have different numbers of columns for a single table
-** within a changegroup, provided that they are otherwise compatible.
-*/
-SQLITE_API int sqlite3changegroup_schema(sqlite3_changegroup*, sqlite3*, const char *zDb);
-
-/*
-** 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:
-**
-** <table border=1 style="margin-left:8ex;margin-right:8ex">
-**   <tr><th style="white-space:pre">Existing Change  </th>
-**       <th style="white-space:pre">New Change       </th>
-**       <th>Output Change
-**   <tr><td>INSERT <td>INSERT <td>
-**       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.
-**   <tr><td>INSERT <td>UPDATE <td>
-**       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.
-**   <tr><td>INSERT <td>DELETE <td>
-**       The existing INSERT is removed from the changegroup. The DELETE is
-**       not added.
-**   <tr><td>UPDATE <td>INSERT <td>
-**       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.
-**   <tr><td>UPDATE <td>UPDATE <td>
-**       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.
-**   <tr><td>UPDATE <td>DELETE <td>
-**       The existing UPDATE is replaced by the new DELETE within the
-**       changegroup.
-**   <tr><td>DELETE <td>INSERT <td>
-**       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.
-**   <tr><td>DELETE <td>UPDATE <td>
-**       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.
-**   <tr><td>DELETE <td>DELETE <td>
-**       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.
-** </table>
-**
-** 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. Except, if the changegroup
-** object has been configured with a database schema using the
-** sqlite3changegroup_schema() API, then it is possible to combine changesets
-** with different numbers of columns for a single table, provided that
-** they are otherwise compatible.
-**
-** 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: Add A Single Change To A Changegroup
-** METHOD: sqlite3_changegroup
-**
-** This function adds the single change currently indicated by the iterator
-** passed as the second argument to the changegroup object. The rules for
-** adding the change are just as described for [sqlite3changegroup_add()].
-**
-** If the change is successfully added to the changegroup, SQLITE_OK is
-** returned. Otherwise, an SQLite error code is returned.
-**
-** The iterator must point to a valid entry when this function is called.
-** If it does not, SQLITE_ERROR is returned and no change is added to the
-** changegroup. Additionally, the iterator must not have been opened with
-** the SQLITE_CHANGESETAPPLY_INVERT flag. In this case SQLITE_ERROR is also
-** returned.
-*/
-SQLITE_API int sqlite3changegroup_add_change(
-  sqlite3_changegroup*,
-  sqlite3_changeset_iter*
-);
-
-
-
-/*
-** 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.
-**
-** 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. Additionally, starting with version 3.51.0,
-** an error code and error message that may be accessed using the
-** [sqlite3_errcode()] and [sqlite3_errmsg()] APIs are left in the database
-** handle.
-**
-** The fourth argument (xFilter) passed to these functions is the "filter
-** callback". This may be passed NULL, in which case all changes in the
-** changeset are applied to the database. For sqlite3changeset_apply() and
-** sqlite3_changeset_apply_v2(), if it is not NULL, then it is invoked once
-** for each table affected by at least one change in the changeset. In this
-** case the table name is passed as the second argument, and a copy of
-** the context pointer passed as the sixth argument to apply() or apply_v2()
-** 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, all changes related to the table are attempted.
-**
-** For sqlite3_changeset_apply_v3(), the xFilter callback is invoked once
-** per change. The second argument in this case is an sqlite3_changeset_iter
-** that may be queried using the usual APIs for the details of the current
-** change. If the "filter callback" returns zero in this case, then no attempt
-** is made to apply the current change. If it returns non-zero, the change
-** is applied.
-**
-** 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:
-**
-** <ul>
-**   <li> The table has the same name as the name recorded in the
-**        changeset, and
-**   <li> The table has at least as many columns as recorded in the
-**        changeset, and
-**   <li> The table has primary key columns in the same position as
-**        recorded in the changeset.
-** </ul>
-**
-** 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 each UPDATE, INSERT or DELETE
-** change that is not excluded by a filter callback. 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.
-**
-** <dl>
-** <dt>DELETE Changes<dd>
-**   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].
-**
-** <dt>INSERT Changes<dd>
-**   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].
-**
-** <dt>UPDATE Changes<dd>
-**   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].
-** </dl>
-**
-** 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.
-**
-** 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 <b>experimental</b>
-** 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 */
-);
-SQLITE_API int sqlite3changeset_apply_v3(
-  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() */
-    sqlite3_changeset_iter *p     /* Handle describing change */
-  ),
-  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]:
-**
-** <dl>
-** <dt>SQLITE_CHANGESETAPPLY_NOSAVEPOINT <dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESETAPPLY_IGNORENOOP <dd>
-**   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:
-**    <ul>
-**    <li>a delete change if the row being deleted cannot be found,
-**    <li>an update change if the modified fields are already set to
-**        their new values in the conflicting row, or
-**    <li>an insert change if all fields of the conflicting row match
-**        the row being inserted.
-**    </ul>
-**
-** <dt>SQLITE_CHANGESETAPPLY_FKNOACTION <dd>
-**   If this flag it set, then all foreign key constraints in the target
-**   database behave as if they were declared with "ON UPDATE NO ACTION ON
-**   DELETE NO ACTION", even if they are actually CASCADE, RESTRICT, SET NULL
-**   or SET DEFAULT.
-*/
-#define SQLITE_CHANGESETAPPLY_NOSAVEPOINT   0x0001
-#define SQLITE_CHANGESETAPPLY_INVERT        0x0002
-#define SQLITE_CHANGESETAPPLY_IGNORENOOP    0x0004
-#define SQLITE_CHANGESETAPPLY_FKNOACTION    0x0008
-
-/*
-** CAPI3REF: Constants Passed To The Conflict Handler
-**
-** Values that may be passed as the second argument to a conflict-handler.
-**
-** <dl>
-** <dt>SQLITE_CHANGESET_DATA<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_NOTFOUND<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_CONFLICT<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_FOREIGN_KEY<dd>
-**   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().
-**
-** <dt>SQLITE_CHANGESET_CONSTRAINT<dd>
-**   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.
-**
-** </dl>
-*/
-#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.
-**
-** <dl>
-** <dt>SQLITE_CHANGESET_OMIT<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_REPLACE<dd>
-**   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.
-**
-** <dt>SQLITE_CHANGESET_ABORT<dd>
-**   If this value is returned, any changes applied so far are rolled back
-**   and the call to sqlite3changeset_apply() returns SQLITE_ABORT.
-** </dl>
-*/
-#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:
-**
-** <dl>
-** <dt>Local INSERT<dd>
-**   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.
-**
-** <dt>Local DELETE<dd>
-**   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.
-**
-** <dt>Local UPDATE<dd>
-**   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.
-** </dl>
-**
-** 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:
-**
-** <ul>
-**    <li> If there has been one or more REPLACE resolutions on a
-**         key, it is rebased according to a REPLACE.
-**
-**    <li> 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.
-** </ul>
-**
-** 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:
-**
-** <ol>
-**   <li> An sqlite3_rebaser object is created by calling
-**        sqlite3rebaser_create().
-**   <li> 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.
-**   <li> Each local changeset is rebased by calling sqlite3rebaser_rebase().
-**   <li> The sqlite3_rebaser object is deleted by calling
-**        sqlite3rebaser_delete().
-** </ol>
-*/
-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:
-**
-** <table border=1 style="margin-left:8ex;margin-right:8ex">
-**   <tr><th>Streaming function<th>Non-streaming equivalent</th>
-**   <tr><td>sqlite3changeset_apply_strm<td>[sqlite3changeset_apply]
-**   <tr><td>sqlite3changeset_apply_strm_v2<td>[sqlite3changeset_apply_v2]
-**   <tr><td>sqlite3changeset_concat_strm<td>[sqlite3changeset_concat]
-**   <tr><td>sqlite3changeset_invert_strm<td>[sqlite3changeset_invert]
-**   <tr><td>sqlite3changeset_start_strm<td>[sqlite3changeset_start]
-**   <tr><td>sqlite3session_changeset_strm<td>[sqlite3session_changeset]
-**   <tr><td>sqlite3session_patchset_strm<td>[sqlite3session_patchset]
-** </table>
-**
-** 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
-**
-**  <pre>
-**  &nbsp;     int nChangeset,
-**  &nbsp;     void *pChangeset,
-**  </pre>
-**
-** Is replaced by:
-**
-**  <pre>
-**  &nbsp;     int (*xInput)(void *pIn, void *pData, int *pnData),
-**  &nbsp;     void *pIn,
-**  </pre>
-**
-** 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:
-**
-**  <pre>
-**  &nbsp;     int *pnChangeset,
-**  &nbsp;     void **ppChangeset,
-**  </pre>
-**
-** Is replaced by:
-**
-**  <pre>
-**  &nbsp;     int (*xOutput)(void *pOut, const void *pData, int nData),
-**  &nbsp;     void *pOut
-**  </pre>
-**
-** 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_apply_v3_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() */
-    sqlite3_changeset_iter *p
-  ),
-  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.
-**
-** <dl>
-** <dt>SQLITE_SESSION_CONFIG_STRMSIZE<dd>
-**    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.
-** </dl>
-**
-** 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
-
-/*
-** CAPI3REF: Configure a changegroup object
-**
-** Configure the changegroup object passed as the first argument.
-** At present the only valid value for the second parameter is
-** [SQLITE_CHANGEGROUP_CONFIG_PATCHSET].
-*/
-SQLITE_API int sqlite3changegroup_config(sqlite3_changegroup*, int, void *pArg);
-
-/*
-** CAPI3REF: Options for sqlite3changegroup_config().
-**
-** The following values may be passed as the 2nd parameter to
-** sqlite3changegroup_config().
-**
-** <dt>SQLITE_CHANGEGROUP_CONFIG_PATCHSET <dd>
-**   A changegroup object generates either a changeset or patchset. Usually,
-**   this is determined by whether the first call to sqlite3changegroup_add()
-**   is passed a changeset or a patchset. Or, if the first changes are added
-**   to the changegroup object using the sqlite3changegroup_change_xxx()
-**   APIs, then this option may be used to configure whether the changegroup
-**   object generates a changeset or patchset.
-**
-**   When this option is invoked, parameter pArg must point to a value of
-**   type int. If the changegroup currently contains zero changes, and the
-**   value of the int variable is zero or greater than zero, then the
-**   changegroup is configured to generate a changeset or patchset,
-**   respectively. It is a no-op, not an error, if the changegroup is not
-**   configured because it has already started accumulating changes.
-**
-**   Before returning, the int variable is set to 0 if the changegroup is
-**   configured to generate a changeset, or 1 if it is configured to generate
-**   a patchset.
-*/
-#define SQLITE_CHANGEGROUP_CONFIG_PATCHSET 1
-
-
-/*
-** CAPI3REF: Begin adding a change to a changegroup
-**
-** This API is used, in concert with other sqlite3changegroup_change_xxx()
-** APIs, to add changes to a changegroup object one at a time. To add a
-** single change, the caller must:
-**
-**   1. Invoke sqlite3changegroup_change_begin() to indicate the type of
-**      change (INSERT, UPDATE or DELETE), the affected table and whether
-**      or not the change should be marked as indirect.
-**
-**   2. Invoke sqlite3changegroup_change_int64() or one of the other four
-**      value functions - _null(), _double(), _text() or _blob() - one or
-**      more times to specify old.* and new.* values for the change being
-**      constructed.
-**
-**   3. Invoke sqlite3changegroup_change_finish() to either finish adding
-**      the change to the group, or to discard the change altogether.
-**
-** The first argument to this function must be a pointer to the existing
-** changegroup object that the change will be added to. The second argument
-** must be SQLITE_INSERT, SQLITE_UPDATE or SQLITE_DELETE. The third is the
-** name of the table that the change affects, and the fourth is a boolean
-** flag specifying whether the change should be marked as "indirect" (if
-** bIndirect is non-zero) or not indirect (if bIndirect is zero).
-**
-** Following a successful call to this function, this function may not be
-** called again on the same changegroup object until after
-** sqlite3changegroup_change_finish() has been called. Doing so is an
-** SQLITE_MISUSE error.
-**
-** The changegroup object passed as the first argument must be already
-** configured with schema data for the specified table. It may be configured
-** either by calling sqlite3changegroup_schema() with a database that contains
-** the table, or sqlite3changegroup_add() with a changeset that contains the
-** table. If the changegroup object has not been configured with a schema for
-** the specified table when this function is called, SQLITE_ERROR is returned.
-**
-** If successful, SQLITE_OK is returned. Otherwise, if an error occurs, an
-** SQLite error code is returned. In this case, if argument pzErr is non-NULL,
-** then (*pzErr) may be set to point to a buffer containing a utf-8 formated,
-** nul-terminated, English language error message. It is the responsibility
-** of the caller to eventually free this buffer using sqlite3_free().
-*/
-SQLITE_API int sqlite3changegroup_change_begin(
-  sqlite3_changegroup*,
-  int eOp,
-  const char *zTab,
-  int bIndirect,
-  char **pzErr
-);
-
-/*
-** CAPI3REF: Add a 64-bit integer to a changegroup
-**
-** This function may only be called between a successful call to
-** sqlite3changegroup_change_begin() and its matching
-** sqlite3changegroup_change_finish() call. If it is called at any
-** other time, it is an SQLITE_MISUSE error. Calling this function
-** specifies a 64-bit integer value to be used in the change currently being
-** added to the changegroup object passed as the first argument.
-**
-** The second parameter, bNew, specifies whether the value is to be part of
-** the new.* (if bNew is non-zero) or old.* (if bNew is zero) record of
-** the change under construction. If this does not match the type of change
-** specified by the preceding call to sqlite3changegroup_change_begin() (i.e.
-** an old.* value for an SQLITE_INSERT change, or a new.* value for an
-** SQLITE_DELETE), then SQLITE_ERROR is returned.
-**
-** The third parameter specifies the column of the old.* or new.* record that
-** the value will be a part of. If the specified table has an explicit primary
-** key, then this is the index of the table column, numbered from 0 in the order
-** specified within the CREATE TABLE statement. Or, if the table uses an
-** implicit rowid key, then the column 0 is the rowid and the explicit columns
-** are numbered starting from 1. If the iCol parameter is less than 0 or greater
-** than the index of the last column in the table, SQLITE_RANGE is returned.
-**
-** The fourth parameter is the integer value to use as part of the old.* or
-** new.* record.
-**
-** If this call is successful, SQLITE_OK is returned. Otherwise, if an
-** error occurs, an SQLite error code is returned.
-*/
-SQLITE_API int sqlite3changegroup_change_int64(
-  sqlite3_changegroup*,
-  int bNew,
-  int iCol,
-  sqlite3_int64 iVal
-);
-
-/*
-** CAPI3REF: Add a NULL to a changegroup
-**
-** This function is similar to sqlite3changegroup_change_int64(). Except that
-** it configures the change currently under construction with a NULL value
-** instead of a 64-bit integer.
-*/
-SQLITE_API int sqlite3changegroup_change_null(sqlite3_changegroup*, int, int);
-
-/*
-** CAPI3REF: Add an double to a changegroup
-**
-** This function is similar to sqlite3changegroup_change_int64(). Except that
-** it configures the change currently being constructed with a real value
-** instead of a 64-bit integer.
-*/
-SQLITE_API int sqlite3changegroup_change_double(sqlite3_changegroup*, int, int, double);
-
-/*
-** CAPI3REF: Add a text value to a changegroup
-**
-** This function is similar to sqlite3changegroup_change_int64(). It configures
-** the currently accumulated change with a text value instead of a 64-bit
-** integer. Parameter pVal points to a buffer containing the text encoded using
-** utf-8. Parameter nVal may either be the size of the text value in bytes, or
-** else a negative value, in which case the buffer pVal points to is assumed to
-** be nul-terminated.
-*/
-SQLITE_API int sqlite3changegroup_change_text(
-  sqlite3_changegroup*, int, int, const char *pVal, int nVal
-);
-
-/*
-** CAPI3REF: Add a blob to a changegroup
-**
-** This function is similar to sqlite3changegroup_change_int64(). It configures
-** the currently accumulated change with a blob value instead of a 64-bit
-** integer. Parameter pVal points to a buffer containing the blob. Parameter
-** nVal is the size of the blob in bytes.
-*/
-SQLITE_API int sqlite3changegroup_change_blob(
-    sqlite3_changegroup*, int, int, const void *pVal, int nVal
-);
-
-/*
-** CAPI3REF: Finish adding one-at-at-time changes to a changegroup
-**
-** This function may only be called following a successful call to
-** sqlite3changegroup_change_begin(). Otherwise, it is an SQLITE_MISUSE error.
-**
-** If parameter bDiscard is non-zero, then the current change is simply
-** discarded. In this case this function is always successful and SQLITE_OK
-** returned.
-**
-** If parameter bDiscard is zero, then an attempt is made to add the current
-** change to the changegroup. Assuming the changegroup is configured to
-** produce a changeset (not a patchset), this requires that:
-**
-**   *  If the change is an INSERT or DELETE, then a value must be specified
-**      for all columns of the new.* or old.* record, respectively.
-**
-**   *  If the change is an UPDATE record, then values must be provided for
-**      the PRIMARY KEY columns of the old.* record, but must not be provided
-**      for PRIMARY KEY columns of the new.* record.
-**
-**   *  If the change is an UPDATE record, then for each non-PRIMARY KEY
-**      column in the old.* record for which a value has been provided, a
-**      value must also be provided for the same column in the new.* record.
-**      Similarly, for each non-PK column in the old.* record for which
-**      a value is not provided, a value must not be provided for the same
-**      column in the new.* record.
-**
-**   *  All values specified for PRIMARY KEY columns must be non-NULL.
-**
-** Otherwise, it is an error.
-**
-** If the changegroup already contains a change for the same row (identified
-** by PRIMARY KEY columns), then the current change is combined with the
-** existing change in the same way as for sqlite3changegroup_add().
-**
-** For a patchset, all of the above rules apply except that it doesn't matter
-** whether or not values are provided for the non-PK old.* record columns
-** for an UPDATE or DELETE change. This means that code used to produce
-** a changeset using the sqlite3changegroup_change_xxx() APIs may also
-** be used to produce patchsets.
-**
-** If the call is successful, SQLITE_OK is returned. Otherwise, if an error
-** occurs, an SQLite error code is returned. If an error is returned and
-** parameter pzErr is not NULL, then (*pzErr) may be set to point to a buffer
-** containing a nul-terminated, utf-8 encoded, English language error message.
-** It is the responsibility of the caller to eventually free any such error
-** message buffer using sqlite3_free().
-*/
-SQLITE_API int sqlite3changegroup_change_finish(
-  sqlite3_changegroup*,
-  int bDiscard,
-  char **pzErr
-);
-
-/*
-** Make sure we can call this stuff from C++.
-*/
-#ifdef __cplusplus
-}
-#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
-
-
-#ifdef __cplusplus
-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 pUserData pointer passed to the xCreateFunction()
-**   API when the extension function was registered.
-**
-** 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:
-**   If parameter iCol is less than zero, or greater than or equal to the
-**   number of columns in the table, SQLITE_RANGE is returned.
-**
-**   Otherwise, 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:
-**   If parameter iCol is less than zero, or greater than or equal to the
-**   number of phrases in the current query, as returned by xPhraseCount,
-**   0 is returned. Otherwise, this function 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(). If iIdx is less than zero or greater than
-**   or equal to the value returned by xInstCount(), SQLITE_RANGE is returned.
-**
-**   Otherwise, 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. SQLITE_OK is returned 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 parameter iPhrase is less than zero, or greater than or equal to
-**   the number of phrases in the query, as returned by xPhraseCount(),
-**   this function returns SQLITE_RANGE.
-**
-**   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).
-**
-**   In all cases, matches are visited in (column ASC, offset ASC) order.
-**   i.e. all those in column 0, sorted by offset, followed by those in
-**   column 1, etc.
-**
-** 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.
-**
-** xQueryToken(pFts5, iPhrase, iToken, ppToken, pnToken)
-**   This is used to access token iToken of phrase iPhrase of the current
-**   query. Before returning, output parameter *ppToken is set to point
-**   to a buffer containing the requested token, and *pnToken to the
-**   size of this buffer in bytes.
-**
-**   If iPhrase or iToken are less than zero, or if iPhrase is greater than
-**   or equal to the number of phrases in the query as reported by
-**   xPhraseCount(), or if iToken is equal to or greater than the number of
-**   tokens in the phrase, SQLITE_RANGE is returned and *ppToken and *pnToken
-     are both zeroed.
-**
-**   The output text is not a copy of the query text that specified the
-**   token. It is the output of the tokenizer module. For tokendata=1
-**   tables, this includes any embedded 0x00 and trailing data.
-**
-** xInstToken(pFts5, iIdx, iToken, ppToken, pnToken)
-**   This is used to access token iToken of phrase hit iIdx within the
-**   current row. If iIdx is less than zero or greater than or equal to the
-**   value returned by xInstCount(), SQLITE_RANGE is returned.  Otherwise,
-**   output variable (*ppToken) is set to point to a buffer containing the
-**   matching document token, and (*pnToken) to the size of that buffer in
-**   bytes.
-**
-**   The output text is not a copy of the document text that was tokenized.
-**   It is the output of the tokenizer module. For tokendata=1 tables, this
-**   includes any embedded 0x00 and trailing data.
-**
-**   This API may be slow in some cases if the token identified by parameters
-**   iIdx and iToken matched a prefix token in the query. In most cases, the
-**   first call to this API for each prefix token in the query is forced
-**   to scan the portion of the full-text index that matches the prefix
-**   token to collect the extra data required by this API. If the prefix
-**   token matches a large number of token instances in the document set,
-**   this may be a performance problem.
-**
-**   If the user knows in advance that a query may use this API for a
-**   prefix token, FTS5 may be configured to collect all required data as part
-**   of the initial querying of the full-text index, avoiding the second scan
-**   entirely. This also causes prefix queries that do not use this API to
-**   run more slowly and use more memory. FTS5 may be configured in this way
-**   either on a per-table basis using the [FTS5 insttoken | 'insttoken']
-**   option, or on a per-query basis using the
-**   [fts5_insttoken | fts5_insttoken()] user function.
-**
-**   This API can be quite slow if used with an FTS5 table created with the
-**   "detail=none" or "detail=column" option.
-**
-** xColumnLocale(pFts5, iIdx, pzLocale, pnLocale)
-**   If parameter iCol is less than zero, or greater than or equal to the
-**   number of columns in the table, SQLITE_RANGE is returned.
-**
-**   Otherwise, this function attempts to retrieve the locale associated
-**   with column iCol of the current row. Usually, there is no associated
-**   locale, and output parameters (*pzLocale) and (*pnLocale) are set
-**   to NULL and 0, respectively. However, if the fts5_locale() function
-**   was used to associate a locale with the value when it was inserted
-**   into the fts5 table, then (*pzLocale) is set to point to a nul-terminated
-**   buffer containing the name of the locale in utf-8 encoding. (*pnLocale)
-**   is set to the size in bytes of the buffer, not including the
-**   nul-terminator.
-**
-**   If successful, SQLITE_OK is returned. Or, if an error occurs, an
-**   SQLite error code is returned. The final value of the output parameters
-**   is undefined in this case.
-**
-** xTokenize_v2:
-**   Tokenize text using the tokenizer belonging to the FTS5 table. This
-**   API is the same as the xTokenize() API, except that it allows a tokenizer
-**   locale to be specified.
-*/
-struct Fts5ExtensionApi {
-  int iVersion;                   /* Currently always set to 4 */
-
-  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);
-
-  /* Below this point are iVersion>=3 only */
-  int (*xQueryToken)(Fts5Context*,
-      int iPhrase, int iToken,
-      const char **ppToken, int *pnToken
-  );
-  int (*xInstToken)(Fts5Context*, int iIdx, int iToken, const char**, int*);
-
-  /* Below this point are iVersion>=4 only */
-  int (*xColumnLocale)(Fts5Context*, int iCol, const char **pz, int *pn);
-  int (*xTokenize_v2)(Fts5Context*,
-    const char *pText, int nText,      /* Text to tokenize */
-    const char *pLocale, int nLocale,  /* Locale to pass to tokenizer */
-    void *pCtx,                        /* Context passed to xToken() */
-    int (*xToken)(void*, int, const char*, int, int, int)       /* Callback */
-  );
-};
-
-/*
-** 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_v2 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 third argument indicates the reason that FTS5 is requesting
-**   tokenization of the supplied text. This is always one of the following
-**   four values:
-**
-**   <ul><li> <b>FTS5_TOKENIZE_DOCUMENT</b> - 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.
-**
-**       <li> <b>FTS5_TOKENIZE_QUERY</b> - 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.
-**
-**       <li> <b>(FTS5_TOKENIZE_QUERY | FTS5_TOKENIZE_PREFIX)</b> - 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.
-**
-**       <li> <b>FTS5_TOKENIZE_AUX</b> - 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.
-**   </ul>
-**
-**   The sixth and seventh arguments passed to xTokenize() - pLocale and
-**   nLocale - are a pointer to a buffer containing the locale to use for
-**   tokenization (e.g. "en_US") and its size in bytes, respectively. The
-**   pLocale buffer is not nul-terminated. pLocale may be passed NULL (in
-**   which case nLocale is always 0) to indicate that the tokenizer should
-**   use its default locale.
-**
-**   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.
-**
-**   If the tokenizer is registered using an fts5_tokenizer_v2 object,
-**   then the xTokenize() method has two additional arguments - pLocale
-**   and nLocale. These specify the locale that the tokenizer should use
-**   for the current request. If pLocale and nLocale are both 0, then the
-**   tokenizer should use its default locale. Otherwise, pLocale points to
-**   an nLocale byte buffer containing the name of the locale to use as utf-8
-**   text. pLocale is not nul-terminated.
-**
-** FTS5_TOKENIZER
-**
-** There is also an fts5_tokenizer object. This is an older, deprecated,
-** version of fts5_tokenizer_v2. It is similar except that:
-**
-**  <ul>
-**    <li> There is no "iVersion" field, and
-**    <li> The xTokenize() method does not take a locale argument.
-**  </ul>
-**
-** Legacy fts5_tokenizer tokenizers must be registered using the
-** legacy xCreateTokenizer() function, instead of xCreateTokenizer_v2().
-**
-** Tokenizer implementations registered using either API may be retrieved
-** using both xFindTokenizer() and xFindTokenizer_v2().
-**
-** 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:
-**
-**   <ol><li> 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.
-**
-**       <li> 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:
-**
-**   <codeblock>
-**     ... MATCH 'first place'</codeblock>
-**
-**            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:
-**
-**   <codeblock>
-**     ... MATCH '(first OR 1st) place'</codeblock>
-**
-**            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.
-**
-**       <li> 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.
-**   </ol>
-**
-**   Whether it is parsing document or query text, any call to xToken that
-**   specifies a <i>tflags</i> 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:
-**
-**   <codeblock>
-**       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);
-**</codeblock>
-**
-**   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:
-**
-**   <codeblock>
-**     ... MATCH '1s*'</codeblock>
-**
-**   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 (3)) or query
-**   text (method (2)), not both. Doing so will not cause any errors, but is
-**   inefficient.
-*/
-typedef struct Fts5Tokenizer Fts5Tokenizer;
-typedef struct fts5_tokenizer_v2 fts5_tokenizer_v2;
-struct fts5_tokenizer_v2 {
-  int iVersion;             /* Currently always 2 */
-
-  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,
-      const char *pLocale, int nLocale,
-      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 */
-      )
-  );
-};
-
-/*
-** New code should use the fts5_tokenizer_v2 type to define tokenizer
-** implementations. The following type is included for legacy applications
-** that still use it.
-*/
-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 3 */
-
-  /* Create a new tokenizer */
-  int (*xCreateTokenizer)(
-    fts5_api *pApi,
-    const char *zName,
-    void *pUserData,
-    fts5_tokenizer *pTokenizer,
-    void (*xDestroy)(void*)
-  );
-
-  /* Find an existing tokenizer */
-  int (*xFindTokenizer)(
-    fts5_api *pApi,
-    const char *zName,
-    void **ppUserData,
-    fts5_tokenizer *pTokenizer
-  );
-
-  /* Create a new auxiliary function */
-  int (*xCreateFunction)(
-    fts5_api *pApi,
-    const char *zName,
-    void *pUserData,
-    fts5_extension_function xFunction,
-    void (*xDestroy)(void*)
-  );
-
-  /* APIs below this point are only available if iVersion>=3 */
-
-  /* Create a new tokenizer */
-  int (*xCreateTokenizer_v2)(
-    fts5_api *pApi,
-    const char *zName,
-    void *pUserData,
-    fts5_tokenizer_v2 *pTokenizer,
-    void (*xDestroy)(void*)
-  );
-
-  /* Find an existing tokenizer */
-  int (*xFindTokenizer_v2)(
-    fts5_api *pApi,
-    const char *zName,
-    void **ppUserData,
-    fts5_tokenizer_v2 **ppTokenizer
-  );
-};
-
-/*
-** END OF REGISTRATION API
-*************************************************************************/
-
-#ifdef __cplusplus
-}  /* end of the 'extern "C"' block */
-#endif
-
-#endif /* _FTS5_H */
-
-/******** End of fts5.h *********/
-#endif /* SQLITE3_H */
diff --git a/deps/sqlite-amalgamation-3530100/sqlite3ext.h b/deps/sqlite-amalgamation-3530100/sqlite3ext.h
deleted file mode 100644
index cad1a2a0..00000000
--- a/deps/sqlite-amalgamation-3530100/sqlite3ext.h
+++ /dev/null
@@ -1,739 +0,0 @@
-/*
-** 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*);
-  /* Version 3.43.0 and later */
-  int (*stmt_explain)(sqlite3_stmt*,int);
-  /* Version 3.44.0 and later */
-  void *(*get_clientdata)(sqlite3*,const char*);
-  int (*set_clientdata)(sqlite3*, const char*, void*, void(*)(void*));
-  /* Version 3.50.0 and later */
-  int (*setlk_timeout)(sqlite3*,int,int);
-  /* Version 3.51.0 and later */
-  int (*set_errmsg)(sqlite3*,int,const char*);
-  int (*db_status64)(sqlite3*,int,sqlite3_int64*,sqlite3_int64*,int);
-  /* Version 3.52.0 and later */
-  void (*str_truncate)(sqlite3_str*,int);
-  void (*str_free)(sqlite3_str*);
-  int (*carray_bind)(sqlite3_stmt*,int,void*,int,int,void(*)(void*));
-  int (*carray_bind_v2)(sqlite3_stmt*,int,void*,int,int,void(*)(void*),void*);
-};
-
-/*
-** 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
-/* Version 3.43.0 and later */
-#define sqlite3_stmt_explain           sqlite3_api->stmt_explain
-/* Version 3.44.0 and later */
-#define sqlite3_get_clientdata         sqlite3_api->get_clientdata
-#define sqlite3_set_clientdata         sqlite3_api->set_clientdata
-/* Version 3.50.0 and later */
-#define sqlite3_setlk_timeout          sqlite3_api->setlk_timeout
-/* Version 3.51.0 and later */
-#define sqlite3_set_errmsg             sqlite3_api->set_errmsg
-#define sqlite3_db_status64            sqlite3_api->db_status64
-/* Version 3.52.0 and later */
-#define sqlite3_str_truncate           sqlite3_api->str_truncate
-#define sqlite3_str_free               sqlite3_api->str_free
-#define sqlite3_carray_bind            sqlite3_api->carray_bind
-#define sqlite3_carray_bind_v2         sqlite3_api->carray_bind_v2
-#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 */
diff --git a/deps/sqlite3.gyp b/deps/sqlite3.gyp
index f3914e30..07da8455 100755
--- a/deps/sqlite3.gyp
+++ b/deps/sqlite3.gyp
@@ -47,15 +47,40 @@
   },
 
   'targets': [
+    {
+      'target_name': 'action_before_build',
+      'type': 'none',
+      'hard_dependency': 1,
+      'actions': [
+        {
+          'action_name': 'unpack_sqlite_dep',
+          'inputs': [
+            './sqlite-amalgamation-<@(sqlite_version).zip'
+          ],
+          'outputs': [
+            '<(SHARED_INTERMEDIATE_DIR)/sqlite-amalgamation-<@(sqlite_version)/sqlite3.c'
+          ],
+          'action': ['node', './extract.js', './sqlite-amalgamation-<@(sqlite_version).zip', '<(SHARED_INTERMEDIATE_DIR)']
+        }
+      ],
+      'direct_dependent_settings': {
+        'include_dirs': [
+          '<(SHARED_INTERMEDIATE_DIR)/sqlite-amalgamation-<@(sqlite_version)/',
+        ]
+      },
+    },
     {
       'target_name': 'sqlite3',
       'type': 'static_library',
-      'include_dirs': [ './sqlite-amalgamation-<@(sqlite_version)/' ],
+      'include_dirs': [ '<(SHARED_INTERMEDIATE_DIR)/sqlite-amalgamation-<@(sqlite_version)/' ],
+      'dependencies': [
+        'action_before_build'
+      ],
       'sources': [
-        './sqlite-amalgamation-<@(sqlite_version)/sqlite3.c'
+        '<(SHARED_INTERMEDIATE_DIR)/sqlite-amalgamation-<@(sqlite_version)/sqlite3.c'
       ],
       'direct_dependent_settings': {
-        'include_dirs': [ './sqlite-amalgamation-<@(sqlite_version)/' ],
+        'include_dirs': [ '<(SHARED_INTERMEDIATE_DIR)/sqlite-amalgamation-<@(sqlite_version)/' ],
         'defines': [
           'SQLITE_THREADSAFE=1',
           'HAVE_USLEEP=1',
@@ -81,6 +106,9 @@
         'SQLITE_ENABLE_DBSTAT_VTAB=1',
         'SQLITE_ENABLE_MATH_FUNCTIONS'
       ],
+      'export_dependent_settings': [
+        'action_before_build',
+      ],
       'conditions': [
         ["sqlite_magic != ''", {
             'defines': [
@@ -90,4 +118,4 @@
       ],
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/memory-bank/activeContext.md b/memory-bank/activeContext.md
index 9e11c6e1..6f61124a 100644
--- a/memory-bank/activeContext.md
+++ b/memory-bank/activeContext.md
@@ -2,9 +2,9 @@
 
 ## Current Status
 
-**Last Updated**: 2026-04-25
+**Last Updated**: 2026-05-17
 
-All 277 tests pass (239 CJS + 38 ESM).
+All 339 tests pass (277 CJS + 62 ESM).
 
 ## Current Work
 
diff --git a/memory-bank/build-system.md b/memory-bank/build-system.md
index c3de58fa..a1b3472c 100644
--- a/memory-bank/build-system.md
+++ b/memory-bank/build-system.md
@@ -48,7 +48,9 @@ Common build configurations:
 ### deps/sqlite3.gyp
 
 SQLite library build configuration:
-- Compiles SQLite from amalgamation source (pre-extracted in deps/)
+- Uses two-target pattern with `action_before_build` and `sqlite3` targets
+- `action_before_build` target extracts `sqlite-amalgamation-*.zip` to `<(SHARED_INTERMEDIATE_DIR)` at build time
+- `sqlite3` target compiles from extracted source in the build intermediate directory
 - Enables FTS3/4/5, R-Tree, math functions
 - Thread-safe configuration
 
diff --git a/memory-bank/decisionLog.md b/memory-bank/decisionLog.md
index 5e71ecca..b84f7c2a 100644
--- a/memory-bank/decisionLog.md
+++ b/memory-bank/decisionLog.md
@@ -39,22 +39,21 @@
 
 ### 2026-04-21: SQLite Build Pipeline using sqlite-amalgamation-*.zip
 
-**Decision**: Switch from `sqlite-autoconf-*.tar.gz` as an amalgamation (extracted at build time via `tar` npm package) to `sqlite-amalgamation-*.zip` (pre-extracted in `deps/`).
+**Decision**: Switch from `sqlite-autoconf-*.tar.gz` as an amalgamation (extracted at build time via `tar` npm package) to `sqlite-amalgamation-*.zip` (extracted at build time to `<(SHARED_INTERMEDIATE_DIR)`).
 
 **Rationale**:
 - Removes `tar` npm dependency — smaller install for all consumers
-- Eliminates build-time extraction — simpler `sqlite3.gyp`, no `action_before_build`
+- Uses two-target pattern with `action_before_build` and `sqlite3` targets
 - No `VERSION` file conflict — amalgamation zip doesn't include it
-- Faster builds — no extraction step during `yarn install` or `yarn rebuild`
-- Simpler debugging — source files are directly visible in `deps/`
+- Clean source tree — extracted files go to build intermediate directory, not `deps/`
 - Same pattern — `sqlite_version` variable still drives path references
 
 **Changes**:
-- `deps/sqlite3.gyp` — removed `action_before_build` target, paths now reference `./sqlite-amalgamation-<@(sqlite_version)/`
-- `deps/extract.js` — deleted (no longer needed)
-- `deps/sqlite-autoconf-3530000.tar.gz` — deleted, replaced by `deps/sqlite-amalgamation-3530000/`
-- `package.json` — removed `tar` from dependencies
-- `tools/bin/bump-sqlite.sh` — downloads amalgamation zip, extracts immediately, commits directory
+- `deps/sqlite3.gyp` — added `action_before_build` target with `hard_dependency: 1`, `sqlite3` target depends on it, all paths use `<(SHARED_INTERMEDIATE_DIR)/sqlite-amalgamation-<@(sqlite_version)/`
+- `deps/extract.js` — pure Node.js zip extractor (no external deps), accepts `archive_path` and `dest_dir` as CLI arguments
+- `deps/sqlite-autoconf-3530000.tar.gz` — deleted, replaced by `deps/sqlite-amalgamation-3530100.zip`
+- `package.json` — removed `tar` from dependencies, added `deps/extract.js` and `deps/sqlite-amalgamation-*.zip` to `files` field
+- `tools/bin/bump-sqlite.sh` — downloads amalgamation zip to `deps/`, no longer pre-extracts
 
 ### 2026-04-21: ESM + CJS Dual Support
 
diff --git a/memory-bank/progress.md b/memory-bank/progress.md
index 3e0be26c..32d1ca5a 100644
--- a/memory-bank/progress.md
+++ b/memory-bank/progress.md
@@ -41,7 +41,9 @@
 ### SQLite Build Pipeline using sqlite-amalgamation-*.zip
 - Switched from `sqlite-autoconf-*.tar.gz` to `sqlite-amalgamation-*.zip`
 - Removed `tar` npm dependency
-- Simplified `deps/sqlite3.gyp` (no `action_before_build`)
+- Restored `action_before_build` target in `deps/sqlite3.gyp`
+- Extraction now goes to `<(SHARED_INTERMEDIATE_DIR)` (build intermediate directory)
+- `deps/extract.js` — pure Node.js zip extractor, accepts CLI arguments
 - Updated `tools/bin/bump-sqlite.sh`
 
 ### ESM + CJS Dual Support Implementation
@@ -93,4 +95,4 @@
 
 ### Testing Infrastructure
 - Mocha test framework with nyc coverage
-- 281 tests passing (including ESM tests)
\ No newline at end of file
+- 281 tests passing (including ESM tests)
diff --git a/memory-bank/project-overview.md b/memory-bank/project-overview.md
index df6f0f88..adef1a03 100644
--- a/memory-bank/project-overview.md
+++ b/memory-bank/project-overview.md
@@ -39,7 +39,8 @@ node-sqlite3/
 ├── deps/                       # SQLite dependency
 │   ├── sqlite3.gyp             # SQLite build config
 │   ├── common-sqlite.gypi      # Common build config
-│   └── sqlite-amalgamation-*/  # SQLite source (pre-extracted)
+│   ├── extract.js              # Pure Node.js zip extractor
+│   └── sqlite-amalgamation-*.zip  # SQLite amalgamation zip (extracted at build time)
 ├── prebuilds/                  # Bundled prebuilt binaries (not in git, included in npm package)
 ├── test/                       # Test suite (mocha)
 │   ├── esm.test.mjs            # ESM-specific tests (38 tests)
diff --git a/tools/bin/bump-sqlite.sh b/tools/bin/bump-sqlite.sh
index 6c260333..ee65c052 100755
--- a/tools/bin/bump-sqlite.sh
+++ b/tools/bin/bump-sqlite.sh
@@ -417,17 +417,18 @@ step8_create_branch() {
 }
 
 step9_download_and_replace() {
-    log_step "9" "Download new SQLite amalgamation zip and extract to deps/"
+    log_step "9" "Download new SQLite amalgamation zip to deps/"
 
     local old_dir="sqlite-amalgamation-${FROM_VERSION}"
+    local old_zip="sqlite-amalgamation-${FROM_VERSION}.zip"
     local new_dir="sqlite-amalgamation-${NEW_VERSION}"
     local new_zip="sqlite-amalgamation-${NEW_VERSION}.zip"
 
     if [[ "$DRY_RUN" == true ]]; then
         log_dry "Would download ${new_zip} from sqlite.org"
-        log_dry "Would extract ${new_zip} to deps/${new_dir}/"
-        log_dry "Would git rm deps/${old_dir}/ from deps/"
-        log_dry "Would place deps/${new_dir}/ in deps/"
+        log_dry "Would git rm deps/${old_zip} from deps/"
+        log_dry "Would place deps/${new_zip} in deps/"
+        log_dry "Would remove old extracted dir deps/${old_dir}/ (if present)"
         return
     fi
 
@@ -534,22 +535,25 @@ step9_download_and_replace() {
         log "         Skipping checksum verification."
     fi
 
-    # Extract the zip
-    log "Extracting ${new_zip}..."
-    if ! unzip -o "${tmp_dir}/${new_zip}" -d "${DEPS_DIR}/"; then
-        echo "ERROR: Failed to extract ${new_zip}" >&2
-        exit "$EXIT_GENERAL_ERROR"
-    fi
+    # Move zip to deps/
+    log "Placing ${new_zip} in deps/..."
+    mv "${tmp_dir}/${new_zip}" "${DEPS_DIR}/${new_zip}"
 
-    # Remove old amalgamation directory
-    if [[ -d "${DEPS_DIR}/${old_dir}" ]]; then
-        log "Removing old amalgamation directory: ${old_dir}"
-        git rm -r "${DEPS_DIR}/${old_dir}"
+    # Remove old zip from git
+    if [[ -f "${DEPS_DIR}/${old_zip}" ]]; then
+        log "Removing old zip from git: ${old_zip}"
+        git rm -f "${DEPS_DIR}/${old_zip}"
     else
-        log "WARNING: Old amalgamation directory not found: ${DEPS_DIR}/${old_dir}"
+        log "WARNING: Old zip not found: ${DEPS_DIR}/${old_zip}"
+    fi
+
+    # Clean up old extracted directory from disk if present
+    if [[ -d "${PROJECT_ROOT}/build/${old_dir}" ]]; then
+        log "Removing old extracted directory: ${old_dir}"
+        rm -rf "${PROJECT_ROOT}/build/${old_dir}"
     fi
 
-    log "Amalgamation extracted to deps/${new_dir}/"
+    log "Zip placed at deps/${new_zip}"
 }
 
 step10_update_gypi() {
@@ -725,7 +729,7 @@ step16_commit() {
 
     # Stage relevant files
     git add "${GYPI_FILE}"
-    git add "${DEPS_DIR}/sqlite-amalgamation-"*/
+    git add "${DEPS_DIR}/sqlite-amalgamation-${NEW_VERSION}.zip"
     git add "$README_FILE"
 
     git commit -m "$commit_msg"

From 68a3e2cef3a1319f2fa05f2363a7242b6497cf93 Mon Sep 17 00:00:00 2001
From: Guenter Sandner <www.gms@gmx.at>
Date: Sun, 17 May 2026 15:18:11 +0200
Subject: [PATCH 2/3] package sqlite as zip and extract at build time: fixed
 review comments

---
 deps/extract.js                 | 5 +++++
 memory-bank/progress.md         | 4 ++--
 memory-bank/project-overview.md | 1 -
 tools/bin/bump-sqlite.sh        | 8 ++++----
 4 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/deps/extract.js b/deps/extract.js
index 2d659ae0..b87bbab4 100644
--- a/deps/extract.js
+++ b/deps/extract.js
@@ -56,6 +56,11 @@ function extractZip(zipPath, destDir) {
 
         if (outFileName && !outFileName.endsWith('/')) {
             const outPath = path.join(destDir, outFileName);
+          const resolvedDest = path.resolve(destDir);
+          const resolvedOut = path.resolve(outPath);
+          if (!resolvedOut.startsWith(resolvedDest + path.sep)) {
+            throw new Error(`Zip Slip detected: ${outFileName} resolves outside destination directory`);
+          }
             const dir = path.dirname(outPath);
             if (!fs.existsSync(dir)) {
                 fs.mkdirSync(dir, { recursive: true });
diff --git a/memory-bank/progress.md b/memory-bank/progress.md
index 32d1ca5a..be6df801 100644
--- a/memory-bank/progress.md
+++ b/memory-bank/progress.md
@@ -50,7 +50,7 @@
 - CJS: `lib/sqlite3.js` → `lib/sqlite3-callback.js` + `lib/sqlite3-binding.js`
 - ESM: `lib/sqlite3.mjs` → `lib/promise/` (SqliteDatabase, SqliteStatement, SqliteBackup)
 - TypeScript definitions updated
-- All 281 tests passing (including ESM tests)
+- All 339 tests passing (277 CJS + 62 ESM)
 
 ### SQLite Version Bump Script
 - `tools/bin/bump-sqlite.sh` downloads amalgamation zip, extracts, commits
@@ -95,4 +95,4 @@
 
 ### Testing Infrastructure
 - Mocha test framework with nyc coverage
-- 281 tests passing (including ESM tests)
+- 339 tests passing (277 CJS + 62 ESM)
diff --git a/memory-bank/project-overview.md b/memory-bank/project-overview.md
index adef1a03..ebc06094 100644
--- a/memory-bank/project-overview.md
+++ b/memory-bank/project-overview.md
@@ -131,7 +131,6 @@ import { SqliteDatabase } from '@homeofthings/sqlite3/promise';
 ### Runtime
 - `node-addon-api`: ^8.7.0 - C++ NAPI wrapper
 - `node-gyp-build`: ^4.8.4 - Native addon binary loader (resolves prebuilt or falls back to source build)
-- `tar`: ^7.5.13 - Tarball handling
 
 ### Development
 - `mocha`: 11.7.5 - Test framework
diff --git a/tools/bin/bump-sqlite.sh b/tools/bin/bump-sqlite.sh
index ee65c052..085fd5e4 100755
--- a/tools/bin/bump-sqlite.sh
+++ b/tools/bin/bump-sqlite.sh
@@ -428,7 +428,7 @@ step9_download_and_replace() {
         log_dry "Would download ${new_zip} from sqlite.org"
         log_dry "Would git rm deps/${old_zip} from deps/"
         log_dry "Would place deps/${new_zip} in deps/"
-        log_dry "Would remove old extracted dir deps/${old_dir}/ (if present)"
+        log_dry "Would remove old extracted dir build/${old_dir}/ (if present)"
         return
     fi
 
@@ -547,9 +547,9 @@ step9_download_and_replace() {
         log "WARNING: Old zip not found: ${DEPS_DIR}/${old_zip}"
     fi
 
-    # Clean up old extracted directory from disk if present
+    # Clean up old extracted directory from build output if present
     if [[ -d "${PROJECT_ROOT}/build/${old_dir}" ]]; then
-        log "Removing old extracted directory: ${old_dir}"
+        log "Removing old extracted directory from build: ${old_dir}"
         rm -rf "${PROJECT_ROOT}/build/${old_dir}"
     fi
 
@@ -648,7 +648,7 @@ step12_check_other_changes() {
     echo ""
     echo "Please review the changelog for potential manual changes in the following files:"
     echo "  - deps/sqlite3.gyp (compile flags, defines, new extensions)"
-    echo "  - deps/sqlite-amalgamation-*/ (amalgamation source files)"
+    echo "  - deps/sqlite-amalgamation-*.zip (amalgamation archive)"
     echo ""
 
     if [[ "$DRY_RUN" == true ]]; then

From c0f7058ddabcbfee907c8d040be5c4ab90fa0ad2 Mon Sep 17 00:00:00 2001
From: Guenter Sandner <www.gms@gmx.at>
Date: Sun, 17 May 2026 18:17:53 +0200
Subject: [PATCH 3/3] package sqlite as zip and extract at build time: fixed
 win build

---
 deps/extract.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/deps/extract.js b/deps/extract.js
index b87bbab4..40528a66 100644
--- a/deps/extract.js
+++ b/deps/extract.js
@@ -80,8 +80,8 @@ function extractZip(zipPath, destDir) {
 }
 
 function main() {
-    const archivePath = process.argv[2];
-    const destDir = process.argv[3];
+    const archivePath = path.resolve(process.argv[2]);
+    const destDir = path.resolve(process.argv[3]);
 
     if (!archivePath || !destDir) {
         console.error('Usage: extract.js <archive_path> <dest_dir>');

y!tG7-b{OphhU%@?2iKWU1g) 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

5(4_c0>#w0#KSdbaDoghuRB_j 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 z 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 z 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