1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/extensions/sqlite/sqlite-source/vdbeaux.c Sun Mar 30 07:00:22 2008 +0000
1.3 @@ -0,0 +1,2243 @@
1.4 +/*
1.5 +** 2003 September 6
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** This file contains code used for creating, destroying, and populating
1.16 +** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) Prior
1.17 +** to version 2.8.7, all this code was combined into the vdbe.c source file.
1.18 +** But that file was getting too big so this subroutines were split out.
1.19 +*/
1.20 +#include "sqliteInt.h"
1.21 +#include <ctype.h>
1.22 +#include "vdbeInt.h"
1.23 +
1.24 +
1.25 +
1.26 +/*
1.27 +** When debugging the code generator in a symbolic debugger, one can
1.28 +** set the sqlite3_vdbe_addop_trace to 1 and all opcodes will be printed
1.29 +** as they are added to the instruction stream.
1.30 +*/
1.31 +#ifdef SQLITE_DEBUG
1.32 +int sqlite3_vdbe_addop_trace = 0;
1.33 +#endif
1.34 +
1.35 +
1.36 +/*
1.37 +** Create a new virtual database engine.
1.38 +*/
1.39 +Vdbe *sqlite3VdbeCreate(sqlite3 *db){
1.40 + Vdbe *p;
1.41 + p = sqlite3DbMallocZero(db, sizeof(Vdbe) );
1.42 + if( p==0 ) return 0;
1.43 + p->db = db;
1.44 + if( db->pVdbe ){
1.45 + db->pVdbe->pPrev = p;
1.46 + }
1.47 + p->pNext = db->pVdbe;
1.48 + p->pPrev = 0;
1.49 + db->pVdbe = p;
1.50 + p->magic = VDBE_MAGIC_INIT;
1.51 + return p;
1.52 +}
1.53 +
1.54 +/*
1.55 +** Remember the SQL string for a prepared statement.
1.56 +*/
1.57 +void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n){
1.58 + if( p==0 ) return;
1.59 + assert( p->zSql==0 );
1.60 + p->zSql = sqlite3DbStrNDup(p->db, z, n);
1.61 +}
1.62 +
1.63 +/*
1.64 +** Return the SQL associated with a prepared statement
1.65 +*/
1.66 +const char *sqlite3VdbeGetSql(Vdbe *p){
1.67 + return p->zSql;
1.68 +}
1.69 +
1.70 +/*
1.71 +** Swap all content between two VDBE structures.
1.72 +*/
1.73 +void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
1.74 + Vdbe tmp, *pTmp;
1.75 + char *zTmp;
1.76 + int nTmp;
1.77 + tmp = *pA;
1.78 + *pA = *pB;
1.79 + *pB = tmp;
1.80 + pTmp = pA->pNext;
1.81 + pA->pNext = pB->pNext;
1.82 + pB->pNext = pTmp;
1.83 + pTmp = pA->pPrev;
1.84 + pA->pPrev = pB->pPrev;
1.85 + pB->pPrev = pTmp;
1.86 + zTmp = pA->zSql;
1.87 + pA->zSql = pB->zSql;
1.88 + pB->zSql = zTmp;
1.89 + nTmp = pA->nSql;
1.90 + pA->nSql = pB->nSql;
1.91 + pB->nSql = nTmp;
1.92 +}
1.93 +
1.94 +#ifdef SQLITE_DEBUG
1.95 +/*
1.96 +** Turn tracing on or off
1.97 +*/
1.98 +void sqlite3VdbeTrace(Vdbe *p, FILE *trace){
1.99 + p->trace = trace;
1.100 +}
1.101 +#endif
1.102 +
1.103 +/*
1.104 +** Resize the Vdbe.aOp array so that it contains at least N
1.105 +** elements. If the Vdbe is in VDBE_MAGIC_RUN state, then
1.106 +** the Vdbe.aOp array will be sized to contain exactly N
1.107 +** elements. Vdbe.nOpAlloc is set to reflect the new size of
1.108 +** the array.
1.109 +**
1.110 +** If an out-of-memory error occurs while resizing the array,
1.111 +** Vdbe.aOp and Vdbe.nOpAlloc remain unchanged (this is so that
1.112 +** any opcodes already allocated can be correctly deallocated
1.113 +** along with the rest of the Vdbe).
1.114 +*/
1.115 +static void resizeOpArray(Vdbe *p, int N){
1.116 + int runMode = p->magic==VDBE_MAGIC_RUN;
1.117 + if( runMode || p->nOpAlloc<N ){
1.118 + VdbeOp *pNew;
1.119 + int nNew = N + 100*(!runMode);
1.120 + int oldSize = p->nOpAlloc;
1.121 + pNew = sqlite3DbRealloc(p->db, p->aOp, nNew*sizeof(Op));
1.122 + if( pNew ){
1.123 + p->nOpAlloc = nNew;
1.124 + p->aOp = pNew;
1.125 + if( nNew>oldSize ){
1.126 + memset(&p->aOp[oldSize], 0, (nNew-oldSize)*sizeof(Op));
1.127 + }
1.128 + }
1.129 + }
1.130 +}
1.131 +
1.132 +/*
1.133 +** Add a new instruction to the list of instructions current in the
1.134 +** VDBE. Return the address of the new instruction.
1.135 +**
1.136 +** Parameters:
1.137 +**
1.138 +** p Pointer to the VDBE
1.139 +**
1.140 +** op The opcode for this instruction
1.141 +**
1.142 +** p1, p2 First two of the three possible operands.
1.143 +**
1.144 +** Use the sqlite3VdbeResolveLabel() function to fix an address and
1.145 +** the sqlite3VdbeChangeP3() function to change the value of the P3
1.146 +** operand.
1.147 +*/
1.148 +int sqlite3VdbeAddOp(Vdbe *p, int op, int p1, int p2){
1.149 + int i;
1.150 + VdbeOp *pOp;
1.151 +
1.152 + i = p->nOp;
1.153 + assert( p->magic==VDBE_MAGIC_INIT );
1.154 + if( p->nOpAlloc<=i ){
1.155 + resizeOpArray(p, i+1);
1.156 + if( p->db->mallocFailed ){
1.157 + return 0;
1.158 + }
1.159 + }
1.160 + p->nOp++;
1.161 + pOp = &p->aOp[i];
1.162 + pOp->opcode = op;
1.163 + pOp->p1 = p1;
1.164 + pOp->p2 = p2;
1.165 + pOp->p3 = 0;
1.166 + pOp->p3type = P3_NOTUSED;
1.167 + p->expired = 0;
1.168 +#ifdef SQLITE_DEBUG
1.169 + if( sqlite3_vdbe_addop_trace ) sqlite3VdbePrintOp(0, i, &p->aOp[i]);
1.170 +#endif
1.171 + return i;
1.172 +}
1.173 +
1.174 +/*
1.175 +** Add an opcode that includes the p3 value.
1.176 +*/
1.177 +int sqlite3VdbeOp3(Vdbe *p, int op, int p1, int p2, const char *zP3,int p3type){
1.178 + int addr = sqlite3VdbeAddOp(p, op, p1, p2);
1.179 + sqlite3VdbeChangeP3(p, addr, zP3, p3type);
1.180 + return addr;
1.181 +}
1.182 +
1.183 +/*
1.184 +** Create a new symbolic label for an instruction that has yet to be
1.185 +** coded. The symbolic label is really just a negative number. The
1.186 +** label can be used as the P2 value of an operation. Later, when
1.187 +** the label is resolved to a specific address, the VDBE will scan
1.188 +** through its operation list and change all values of P2 which match
1.189 +** the label into the resolved address.
1.190 +**
1.191 +** The VDBE knows that a P2 value is a label because labels are
1.192 +** always negative and P2 values are suppose to be non-negative.
1.193 +** Hence, a negative P2 value is a label that has yet to be resolved.
1.194 +**
1.195 +** Zero is returned if a malloc() fails.
1.196 +*/
1.197 +int sqlite3VdbeMakeLabel(Vdbe *p){
1.198 + int i;
1.199 + i = p->nLabel++;
1.200 + assert( p->magic==VDBE_MAGIC_INIT );
1.201 + if( i>=p->nLabelAlloc ){
1.202 + p->nLabelAlloc = p->nLabelAlloc*2 + 10;
1.203 + p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
1.204 + p->nLabelAlloc*sizeof(p->aLabel[0]));
1.205 + }
1.206 + if( p->aLabel ){
1.207 + p->aLabel[i] = -1;
1.208 + }
1.209 + return -1-i;
1.210 +}
1.211 +
1.212 +/*
1.213 +** Resolve label "x" to be the address of the next instruction to
1.214 +** be inserted. The parameter "x" must have been obtained from
1.215 +** a prior call to sqlite3VdbeMakeLabel().
1.216 +*/
1.217 +void sqlite3VdbeResolveLabel(Vdbe *p, int x){
1.218 + int j = -1-x;
1.219 + assert( p->magic==VDBE_MAGIC_INIT );
1.220 + assert( j>=0 && j<p->nLabel );
1.221 + if( p->aLabel ){
1.222 + p->aLabel[j] = p->nOp;
1.223 + }
1.224 +}
1.225 +
1.226 +/*
1.227 +** Return non-zero if opcode 'op' is guarenteed not to push more values
1.228 +** onto the VDBE stack than it pops off.
1.229 +*/
1.230 +static int opcodeNoPush(u8 op){
1.231 + /* The 10 NOPUSH_MASK_n constants are defined in the automatically
1.232 + ** generated header file opcodes.h. Each is a 16-bit bitmask, one
1.233 + ** bit corresponding to each opcode implemented by the virtual
1.234 + ** machine in vdbe.c. The bit is true if the word "no-push" appears
1.235 + ** in a comment on the same line as the "case OP_XXX:" in
1.236 + ** sqlite3VdbeExec() in vdbe.c.
1.237 + **
1.238 + ** If the bit is true, then the corresponding opcode is guarenteed not
1.239 + ** to grow the stack when it is executed. Otherwise, it may grow the
1.240 + ** stack by at most one entry.
1.241 + **
1.242 + ** NOPUSH_MASK_0 corresponds to opcodes 0 to 15. NOPUSH_MASK_1 contains
1.243 + ** one bit for opcodes 16 to 31, and so on.
1.244 + **
1.245 + ** 16-bit bitmasks (rather than 32-bit) are specified in opcodes.h
1.246 + ** because the file is generated by an awk program. Awk manipulates
1.247 + ** all numbers as floating-point and we don't want to risk a rounding
1.248 + ** error if someone builds with an awk that uses (for example) 32-bit
1.249 + ** IEEE floats.
1.250 + */
1.251 + static const u32 masks[5] = {
1.252 + NOPUSH_MASK_0 + (((unsigned)NOPUSH_MASK_1)<<16),
1.253 + NOPUSH_MASK_2 + (((unsigned)NOPUSH_MASK_3)<<16),
1.254 + NOPUSH_MASK_4 + (((unsigned)NOPUSH_MASK_5)<<16),
1.255 + NOPUSH_MASK_6 + (((unsigned)NOPUSH_MASK_7)<<16),
1.256 + NOPUSH_MASK_8 + (((unsigned)NOPUSH_MASK_9)<<16)
1.257 + };
1.258 + assert( op<32*5 );
1.259 + return (masks[op>>5] & (1<<(op&0x1F)));
1.260 +}
1.261 +
1.262 +#ifndef NDEBUG
1.263 +int sqlite3VdbeOpcodeNoPush(u8 op){
1.264 + return opcodeNoPush(op);
1.265 +}
1.266 +#endif
1.267 +
1.268 +/*
1.269 +** Loop through the program looking for P2 values that are negative.
1.270 +** Each such value is a label. Resolve the label by setting the P2
1.271 +** value to its correct non-zero value.
1.272 +**
1.273 +** This routine is called once after all opcodes have been inserted.
1.274 +**
1.275 +** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument
1.276 +** to an OP_Function, OP_AggStep or OP_VFilter opcode. This is used by
1.277 +** sqlite3VdbeMakeReady() to size the Vdbe.apArg[] array.
1.278 +**
1.279 +** The integer *pMaxStack is set to the maximum number of vdbe stack
1.280 +** entries that static analysis reveals this program might need.
1.281 +**
1.282 +** This routine also does the following optimization: It scans for
1.283 +** Halt instructions where P1==SQLITE_CONSTRAINT or P2==OE_Abort or for
1.284 +** IdxInsert instructions where P2!=0. If no such instruction is
1.285 +** found, then every Statement instruction is changed to a Noop. In
1.286 +** this way, we avoid creating the statement journal file unnecessarily.
1.287 +*/
1.288 +static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs, int *pMaxStack){
1.289 + int i;
1.290 + int nMaxArgs = 0;
1.291 + int nMaxStack = p->nOp;
1.292 + Op *pOp;
1.293 + int *aLabel = p->aLabel;
1.294 + int doesStatementRollback = 0;
1.295 + int hasStatementBegin = 0;
1.296 + for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
1.297 + u8 opcode = pOp->opcode;
1.298 +
1.299 + if( opcode==OP_Function || opcode==OP_AggStep
1.300 +#ifndef SQLITE_OMIT_VIRTUALTABLE
1.301 + || opcode==OP_VUpdate
1.302 +#endif
1.303 + ){
1.304 + if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
1.305 + }
1.306 + if( opcode==OP_Halt ){
1.307 + if( pOp->p1==SQLITE_CONSTRAINT && pOp->p2==OE_Abort ){
1.308 + doesStatementRollback = 1;
1.309 + }
1.310 + }else if( opcode==OP_Statement ){
1.311 + hasStatementBegin = 1;
1.312 +#ifndef SQLITE_OMIT_VIRTUALTABLE
1.313 + }else if( opcode==OP_VUpdate || opcode==OP_VRename ){
1.314 + doesStatementRollback = 1;
1.315 + }else if( opcode==OP_VFilter ){
1.316 + int n;
1.317 + assert( p->nOp - i >= 3 );
1.318 + assert( pOp[-2].opcode==OP_Integer );
1.319 + n = pOp[-2].p1;
1.320 + if( n>nMaxArgs ) nMaxArgs = n;
1.321 +#endif
1.322 + }
1.323 + if( opcodeNoPush(opcode) ){
1.324 + nMaxStack--;
1.325 + }
1.326 +
1.327 + if( pOp->p2>=0 ) continue;
1.328 + assert( -1-pOp->p2<p->nLabel );
1.329 + pOp->p2 = aLabel[-1-pOp->p2];
1.330 + }
1.331 + sqlite3_free(p->aLabel);
1.332 + p->aLabel = 0;
1.333 +
1.334 + *pMaxFuncArgs = nMaxArgs;
1.335 + *pMaxStack = nMaxStack;
1.336 +
1.337 + /* If we never rollback a statement transaction, then statement
1.338 + ** transactions are not needed. So change every OP_Statement
1.339 + ** opcode into an OP_Noop. This avoid a call to sqlite3OsOpenExclusive()
1.340 + ** which can be expensive on some platforms.
1.341 + */
1.342 + if( hasStatementBegin && !doesStatementRollback ){
1.343 + for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
1.344 + if( pOp->opcode==OP_Statement ){
1.345 + pOp->opcode = OP_Noop;
1.346 + }
1.347 + }
1.348 + }
1.349 +}
1.350 +
1.351 +/*
1.352 +** Return the address of the next instruction to be inserted.
1.353 +*/
1.354 +int sqlite3VdbeCurrentAddr(Vdbe *p){
1.355 + assert( p->magic==VDBE_MAGIC_INIT );
1.356 + return p->nOp;
1.357 +}
1.358 +
1.359 +/*
1.360 +** Add a whole list of operations to the operation stack. Return the
1.361 +** address of the first operation added.
1.362 +*/
1.363 +int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){
1.364 + int addr;
1.365 + assert( p->magic==VDBE_MAGIC_INIT );
1.366 + resizeOpArray(p, p->nOp + nOp);
1.367 + if( p->db->mallocFailed ){
1.368 + return 0;
1.369 + }
1.370 + addr = p->nOp;
1.371 + if( nOp>0 ){
1.372 + int i;
1.373 + VdbeOpList const *pIn = aOp;
1.374 + for(i=0; i<nOp; i++, pIn++){
1.375 + int p2 = pIn->p2;
1.376 + VdbeOp *pOut = &p->aOp[i+addr];
1.377 + pOut->opcode = pIn->opcode;
1.378 + pOut->p1 = pIn->p1;
1.379 + pOut->p2 = p2<0 ? addr + ADDR(p2) : p2;
1.380 + pOut->p3 = pIn->p3;
1.381 + pOut->p3type = pIn->p3 ? P3_STATIC : P3_NOTUSED;
1.382 +#ifdef SQLITE_DEBUG
1.383 + if( sqlite3_vdbe_addop_trace ){
1.384 + sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]);
1.385 + }
1.386 +#endif
1.387 + }
1.388 + p->nOp += nOp;
1.389 + }
1.390 + return addr;
1.391 +}
1.392 +
1.393 +/*
1.394 +** Change the value of the P1 operand for a specific instruction.
1.395 +** This routine is useful when a large program is loaded from a
1.396 +** static array using sqlite3VdbeAddOpList but we want to make a
1.397 +** few minor changes to the program.
1.398 +*/
1.399 +void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){
1.400 + assert( p==0 || p->magic==VDBE_MAGIC_INIT );
1.401 + if( p && addr>=0 && p->nOp>addr && p->aOp ){
1.402 + p->aOp[addr].p1 = val;
1.403 + }
1.404 +}
1.405 +
1.406 +/*
1.407 +** Change the value of the P2 operand for a specific instruction.
1.408 +** This routine is useful for setting a jump destination.
1.409 +*/
1.410 +void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){
1.411 + assert( val>=0 );
1.412 + assert( p==0 || p->magic==VDBE_MAGIC_INIT );
1.413 + if( p && addr>=0 && p->nOp>addr && p->aOp ){
1.414 + p->aOp[addr].p2 = val;
1.415 + }
1.416 +}
1.417 +
1.418 +/*
1.419 +** Change the P2 operand of instruction addr so that it points to
1.420 +** the address of the next instruction to be coded.
1.421 +*/
1.422 +void sqlite3VdbeJumpHere(Vdbe *p, int addr){
1.423 + sqlite3VdbeChangeP2(p, addr, p->nOp);
1.424 +}
1.425 +
1.426 +
1.427 +/*
1.428 +** If the input FuncDef structure is ephemeral, then free it. If
1.429 +** the FuncDef is not ephermal, then do nothing.
1.430 +*/
1.431 +static void freeEphemeralFunction(FuncDef *pDef){
1.432 + if( pDef && (pDef->flags & SQLITE_FUNC_EPHEM)!=0 ){
1.433 + sqlite3_free(pDef);
1.434 + }
1.435 +}
1.436 +
1.437 +/*
1.438 +** Delete a P3 value if necessary.
1.439 +*/
1.440 +static void freeP3(int p3type, void *p3){
1.441 + if( p3 ){
1.442 + switch( p3type ){
1.443 + case P3_DYNAMIC:
1.444 + case P3_KEYINFO:
1.445 + case P3_KEYINFO_HANDOFF: {
1.446 + sqlite3_free(p3);
1.447 + break;
1.448 + }
1.449 + case P3_MPRINTF: {
1.450 + sqlite3_free(p3);
1.451 + break;
1.452 + }
1.453 + case P3_VDBEFUNC: {
1.454 + VdbeFunc *pVdbeFunc = (VdbeFunc *)p3;
1.455 + freeEphemeralFunction(pVdbeFunc->pFunc);
1.456 + sqlite3VdbeDeleteAuxData(pVdbeFunc, 0);
1.457 + sqlite3_free(pVdbeFunc);
1.458 + break;
1.459 + }
1.460 + case P3_FUNCDEF: {
1.461 + freeEphemeralFunction((FuncDef*)p3);
1.462 + break;
1.463 + }
1.464 + case P3_MEM: {
1.465 + sqlite3ValueFree((sqlite3_value*)p3);
1.466 + break;
1.467 + }
1.468 + }
1.469 + }
1.470 +}
1.471 +
1.472 +
1.473 +/*
1.474 +** Change N opcodes starting at addr to No-ops.
1.475 +*/
1.476 +void sqlite3VdbeChangeToNoop(Vdbe *p, int addr, int N){
1.477 + if( p && p->aOp ){
1.478 + VdbeOp *pOp = &p->aOp[addr];
1.479 + while( N-- ){
1.480 + freeP3(pOp->p3type, pOp->p3);
1.481 + memset(pOp, 0, sizeof(pOp[0]));
1.482 + pOp->opcode = OP_Noop;
1.483 + pOp++;
1.484 + }
1.485 + }
1.486 +}
1.487 +
1.488 +/*
1.489 +** Change the value of the P3 operand for a specific instruction.
1.490 +** This routine is useful when a large program is loaded from a
1.491 +** static array using sqlite3VdbeAddOpList but we want to make a
1.492 +** few minor changes to the program.
1.493 +**
1.494 +** If n>=0 then the P3 operand is dynamic, meaning that a copy of
1.495 +** the string is made into memory obtained from sqlite3_malloc().
1.496 +** A value of n==0 means copy bytes of zP3 up to and including the
1.497 +** first null byte. If n>0 then copy n+1 bytes of zP3.
1.498 +**
1.499 +** If n==P3_KEYINFO it means that zP3 is a pointer to a KeyInfo structure.
1.500 +** A copy is made of the KeyInfo structure into memory obtained from
1.501 +** sqlite3_malloc, to be freed when the Vdbe is finalized.
1.502 +** n==P3_KEYINFO_HANDOFF indicates that zP3 points to a KeyInfo structure
1.503 +** stored in memory that the caller has obtained from sqlite3_malloc. The
1.504 +** caller should not free the allocation, it will be freed when the Vdbe is
1.505 +** finalized.
1.506 +**
1.507 +** Other values of n (P3_STATIC, P3_COLLSEQ etc.) indicate that zP3 points
1.508 +** to a string or structure that is guaranteed to exist for the lifetime of
1.509 +** the Vdbe. In these cases we can just copy the pointer.
1.510 +**
1.511 +** If addr<0 then change P3 on the most recently inserted instruction.
1.512 +*/
1.513 +void sqlite3VdbeChangeP3(Vdbe *p, int addr, const char *zP3, int n){
1.514 + Op *pOp;
1.515 + assert( p==0 || p->magic==VDBE_MAGIC_INIT );
1.516 + if( p==0 || p->aOp==0 || p->db->mallocFailed ){
1.517 + if (n != P3_KEYINFO) {
1.518 + freeP3(n, (void*)*(char**)&zP3);
1.519 + }
1.520 + return;
1.521 + }
1.522 + if( addr<0 || addr>=p->nOp ){
1.523 + addr = p->nOp - 1;
1.524 + if( addr<0 ) return;
1.525 + }
1.526 + pOp = &p->aOp[addr];
1.527 + freeP3(pOp->p3type, pOp->p3);
1.528 + pOp->p3 = 0;
1.529 + if( zP3==0 ){
1.530 + pOp->p3 = 0;
1.531 + pOp->p3type = P3_NOTUSED;
1.532 + }else if( n==P3_KEYINFO ){
1.533 + KeyInfo *pKeyInfo;
1.534 + int nField, nByte;
1.535 +
1.536 + nField = ((KeyInfo*)zP3)->nField;
1.537 + nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField;
1.538 + pKeyInfo = sqlite3_malloc( nByte );
1.539 + pOp->p3 = (char*)pKeyInfo;
1.540 + if( pKeyInfo ){
1.541 + unsigned char *aSortOrder;
1.542 + memcpy(pKeyInfo, zP3, nByte);
1.543 + aSortOrder = pKeyInfo->aSortOrder;
1.544 + if( aSortOrder ){
1.545 + pKeyInfo->aSortOrder = (unsigned char*)&pKeyInfo->aColl[nField];
1.546 + memcpy(pKeyInfo->aSortOrder, aSortOrder, nField);
1.547 + }
1.548 + pOp->p3type = P3_KEYINFO;
1.549 + }else{
1.550 + p->db->mallocFailed = 1;
1.551 + pOp->p3type = P3_NOTUSED;
1.552 + }
1.553 + }else if( n==P3_KEYINFO_HANDOFF ){
1.554 + pOp->p3 = (char*)zP3;
1.555 + pOp->p3type = P3_KEYINFO;
1.556 + }else if( n<0 ){
1.557 + pOp->p3 = (char*)zP3;
1.558 + pOp->p3type = n;
1.559 + }else{
1.560 + if( n==0 ) n = strlen(zP3);
1.561 + pOp->p3 = sqlite3DbStrNDup(p->db, zP3, n);
1.562 + pOp->p3type = P3_DYNAMIC;
1.563 + }
1.564 +}
1.565 +
1.566 +#ifndef NDEBUG
1.567 +/*
1.568 +** Replace the P3 field of the most recently coded instruction with
1.569 +** comment text.
1.570 +*/
1.571 +void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
1.572 + va_list ap;
1.573 + assert( p->nOp>0 || p->aOp==0 );
1.574 + assert( p->aOp==0 || p->aOp[p->nOp-1].p3==0 || p->db->mallocFailed );
1.575 + va_start(ap, zFormat);
1.576 + sqlite3VdbeChangeP3(p, -1, sqlite3VMPrintf(p->db, zFormat, ap), P3_DYNAMIC);
1.577 + va_end(ap);
1.578 +}
1.579 +#endif
1.580 +
1.581 +/*
1.582 +** Return the opcode for a given address.
1.583 +*/
1.584 +VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
1.585 + assert( p->magic==VDBE_MAGIC_INIT );
1.586 + assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
1.587 + return ((addr>=0 && addr<p->nOp)?(&p->aOp[addr]):0);
1.588 +}
1.589 +
1.590 +#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \
1.591 + || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
1.592 +/*
1.593 +** Compute a string that describes the P3 parameter for an opcode.
1.594 +** Use zTemp for any required temporary buffer space.
1.595 +*/
1.596 +static char *displayP3(Op *pOp, char *zTemp, int nTemp){
1.597 + char *zP3;
1.598 + assert( nTemp>=20 );
1.599 + switch( pOp->p3type ){
1.600 + case P3_KEYINFO: {
1.601 + int i, j;
1.602 + KeyInfo *pKeyInfo = (KeyInfo*)pOp->p3;
1.603 + sqlite3_snprintf(nTemp, zTemp, "keyinfo(%d", pKeyInfo->nField);
1.604 + i = strlen(zTemp);
1.605 + for(j=0; j<pKeyInfo->nField; j++){
1.606 + CollSeq *pColl = pKeyInfo->aColl[j];
1.607 + if( pColl ){
1.608 + int n = strlen(pColl->zName);
1.609 + if( i+n>nTemp-6 ){
1.610 + memcpy(&zTemp[i],",...",4);
1.611 + break;
1.612 + }
1.613 + zTemp[i++] = ',';
1.614 + if( pKeyInfo->aSortOrder && pKeyInfo->aSortOrder[j] ){
1.615 + zTemp[i++] = '-';
1.616 + }
1.617 + memcpy(&zTemp[i], pColl->zName,n+1);
1.618 + i += n;
1.619 + }else if( i+4<nTemp-6 ){
1.620 + memcpy(&zTemp[i],",nil",4);
1.621 + i += 4;
1.622 + }
1.623 + }
1.624 + zTemp[i++] = ')';
1.625 + zTemp[i] = 0;
1.626 + assert( i<nTemp );
1.627 + zP3 = zTemp;
1.628 + break;
1.629 + }
1.630 + case P3_COLLSEQ: {
1.631 + CollSeq *pColl = (CollSeq*)pOp->p3;
1.632 + sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
1.633 + zP3 = zTemp;
1.634 + break;
1.635 + }
1.636 + case P3_FUNCDEF: {
1.637 + FuncDef *pDef = (FuncDef*)pOp->p3;
1.638 + sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
1.639 + zP3 = zTemp;
1.640 + break;
1.641 + }
1.642 +#ifndef SQLITE_OMIT_VIRTUALTABLE
1.643 + case P3_VTAB: {
1.644 + sqlite3_vtab *pVtab = (sqlite3_vtab*)pOp->p3;
1.645 + sqlite3_snprintf(nTemp, zTemp, "vtab:%p:%p", pVtab, pVtab->pModule);
1.646 + zP3 = zTemp;
1.647 + break;
1.648 + }
1.649 +#endif
1.650 + default: {
1.651 + zP3 = pOp->p3;
1.652 + if( zP3==0 || pOp->opcode==OP_Noop ){
1.653 + zP3 = "";
1.654 + }
1.655 + }
1.656 + }
1.657 + assert( zP3!=0 );
1.658 + return zP3;
1.659 +}
1.660 +#endif
1.661 +
1.662 +/*
1.663 +** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
1.664 +**
1.665 +*/
1.666 +void sqlite3VdbeUsesBtree(Vdbe *p, int i){
1.667 + int mask;
1.668 + assert( i>=0 && i<p->db->nDb );
1.669 + assert( i<sizeof(p->btreeMask)*8 );
1.670 + mask = 1<<i;
1.671 + if( (p->btreeMask & mask)==0 ){
1.672 + p->btreeMask |= mask;
1.673 + sqlite3BtreeMutexArrayInsert(&p->aMutex, p->db->aDb[i].pBt);
1.674 + }
1.675 +}
1.676 +
1.677 +
1.678 +#if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
1.679 +/*
1.680 +** Print a single opcode. This routine is used for debugging only.
1.681 +*/
1.682 +void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
1.683 + char *zP3;
1.684 + char zPtr[50];
1.685 + static const char *zFormat1 = "%4d %-13s %4d %4d %s\n";
1.686 + if( pOut==0 ) pOut = stdout;
1.687 + zP3 = displayP3(pOp, zPtr, sizeof(zPtr));
1.688 + fprintf(pOut, zFormat1,
1.689 + pc, sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, zP3);
1.690 + fflush(pOut);
1.691 +}
1.692 +#endif
1.693 +
1.694 +/*
1.695 +** Release an array of N Mem elements
1.696 +*/
1.697 +static void releaseMemArray(Mem *p, int N){
1.698 + if( p ){
1.699 + while( N-->0 ){
1.700 + assert( N<2 || p[0].db==p[1].db );
1.701 + sqlite3VdbeMemRelease(p++);
1.702 + }
1.703 + }
1.704 +}
1.705 +
1.706 +#ifndef SQLITE_OMIT_EXPLAIN
1.707 +/*
1.708 +** Give a listing of the program in the virtual machine.
1.709 +**
1.710 +** The interface is the same as sqlite3VdbeExec(). But instead of
1.711 +** running the code, it invokes the callback once for each instruction.
1.712 +** This feature is used to implement "EXPLAIN".
1.713 +*/
1.714 +int sqlite3VdbeList(
1.715 + Vdbe *p /* The VDBE */
1.716 +){
1.717 + sqlite3 *db = p->db;
1.718 + int i;
1.719 + int rc = SQLITE_OK;
1.720 +
1.721 + assert( p->explain );
1.722 + if( p->magic!=VDBE_MAGIC_RUN ) return SQLITE_MISUSE;
1.723 + assert( db->magic==SQLITE_MAGIC_BUSY );
1.724 + assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
1.725 +
1.726 + /* Even though this opcode does not put dynamic strings onto the
1.727 + ** the stack, they may become dynamic if the user calls
1.728 + ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
1.729 + */
1.730 + if( p->pTos==&p->aStack[4] ){
1.731 + releaseMemArray(p->aStack, 5);
1.732 + }
1.733 + p->resOnStack = 0;
1.734 +
1.735 + do{
1.736 + i = p->pc++;
1.737 + }while( i<p->nOp && p->explain==2 && p->aOp[i].opcode!=OP_Explain );
1.738 + if( i>=p->nOp ){
1.739 + p->rc = SQLITE_OK;
1.740 + rc = SQLITE_DONE;
1.741 + }else if( db->u1.isInterrupted ){
1.742 + p->rc = SQLITE_INTERRUPT;
1.743 + rc = SQLITE_ERROR;
1.744 + sqlite3SetString(&p->zErrMsg, sqlite3ErrStr(p->rc), (char*)0);
1.745 + }else{
1.746 + Op *pOp = &p->aOp[i];
1.747 + Mem *pMem = p->aStack;
1.748 + pMem->flags = MEM_Int;
1.749 + pMem->type = SQLITE_INTEGER;
1.750 + pMem->u.i = i; /* Program counter */
1.751 + pMem++;
1.752 +
1.753 + pMem->flags = MEM_Static|MEM_Str|MEM_Term;
1.754 + pMem->z = (char*)sqlite3OpcodeName(pOp->opcode); /* Opcode */
1.755 + assert( pMem->z!=0 );
1.756 + pMem->n = strlen(pMem->z);
1.757 + pMem->type = SQLITE_TEXT;
1.758 + pMem->enc = SQLITE_UTF8;
1.759 + pMem++;
1.760 +
1.761 + pMem->flags = MEM_Int;
1.762 + pMem->u.i = pOp->p1; /* P1 */
1.763 + pMem->type = SQLITE_INTEGER;
1.764 + pMem++;
1.765 +
1.766 + pMem->flags = MEM_Int;
1.767 + pMem->u.i = pOp->p2; /* P2 */
1.768 + pMem->type = SQLITE_INTEGER;
1.769 + pMem++;
1.770 +
1.771 + pMem->flags = MEM_Ephem|MEM_Str|MEM_Term; /* P3 */
1.772 + pMem->z = displayP3(pOp, pMem->zShort, sizeof(pMem->zShort));
1.773 + assert( pMem->z!=0 );
1.774 + pMem->n = strlen(pMem->z);
1.775 + pMem->type = SQLITE_TEXT;
1.776 + pMem->enc = SQLITE_UTF8;
1.777 +
1.778 + p->nResColumn = 5 - 2*(p->explain-1);
1.779 + p->pTos = pMem;
1.780 + p->rc = SQLITE_OK;
1.781 + p->resOnStack = 1;
1.782 + rc = SQLITE_ROW;
1.783 + }
1.784 + return rc;
1.785 +}
1.786 +#endif /* SQLITE_OMIT_EXPLAIN */
1.787 +
1.788 +#ifdef SQLITE_DEBUG
1.789 +/*
1.790 +** Print the SQL that was used to generate a VDBE program.
1.791 +*/
1.792 +void sqlite3VdbePrintSql(Vdbe *p){
1.793 + int nOp = p->nOp;
1.794 + VdbeOp *pOp;
1.795 + if( nOp<1 ) return;
1.796 + pOp = &p->aOp[nOp-1];
1.797 + if( pOp->opcode==OP_Noop && pOp->p3!=0 ){
1.798 + const char *z = pOp->p3;
1.799 + while( isspace(*(u8*)z) ) z++;
1.800 + printf("SQL: [%s]\n", z);
1.801 + }
1.802 +}
1.803 +#endif
1.804 +
1.805 +#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
1.806 +/*
1.807 +** Print an IOTRACE message showing SQL content.
1.808 +*/
1.809 +void sqlite3VdbeIOTraceSql(Vdbe *p){
1.810 + int nOp = p->nOp;
1.811 + VdbeOp *pOp;
1.812 + if( sqlite3_io_trace==0 ) return;
1.813 + if( nOp<1 ) return;
1.814 + pOp = &p->aOp[nOp-1];
1.815 + if( pOp->opcode==OP_Noop && pOp->p3!=0 ){
1.816 + int i, j;
1.817 + char z[1000];
1.818 + sqlite3_snprintf(sizeof(z), z, "%s", pOp->p3);
1.819 + for(i=0; isspace((unsigned char)z[i]); i++){}
1.820 + for(j=0; z[i]; i++){
1.821 + if( isspace((unsigned char)z[i]) ){
1.822 + if( z[i-1]!=' ' ){
1.823 + z[j++] = ' ';
1.824 + }
1.825 + }else{
1.826 + z[j++] = z[i];
1.827 + }
1.828 + }
1.829 + z[j] = 0;
1.830 + sqlite3_io_trace("SQL %s\n", z);
1.831 + }
1.832 +}
1.833 +#endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */
1.834 +
1.835 +
1.836 +/*
1.837 +** Prepare a virtual machine for execution. This involves things such
1.838 +** as allocating stack space and initializing the program counter.
1.839 +** After the VDBE has be prepped, it can be executed by one or more
1.840 +** calls to sqlite3VdbeExec().
1.841 +**
1.842 +** This is the only way to move a VDBE from VDBE_MAGIC_INIT to
1.843 +** VDBE_MAGIC_RUN.
1.844 +*/
1.845 +void sqlite3VdbeMakeReady(
1.846 + Vdbe *p, /* The VDBE */
1.847 + int nVar, /* Number of '?' see in the SQL statement */
1.848 + int nMem, /* Number of memory cells to allocate */
1.849 + int nCursor, /* Number of cursors to allocate */
1.850 + int isExplain /* True if the EXPLAIN keywords is present */
1.851 +){
1.852 + int n;
1.853 + sqlite3 *db = p->db;
1.854 +
1.855 + assert( p!=0 );
1.856 + assert( p->magic==VDBE_MAGIC_INIT );
1.857 +
1.858 + /* There should be at least one opcode.
1.859 + */
1.860 + assert( p->nOp>0 );
1.861 +
1.862 + /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. This
1.863 + * is because the call to resizeOpArray() below may shrink the
1.864 + * p->aOp[] array to save memory if called when in VDBE_MAGIC_RUN
1.865 + * state.
1.866 + */
1.867 + p->magic = VDBE_MAGIC_RUN;
1.868 +
1.869 + /* No instruction ever pushes more than a single element onto the
1.870 + ** stack. And the stack never grows on successive executions of the
1.871 + ** same loop. So the total number of instructions is an upper bound
1.872 + ** on the maximum stack depth required. (Added later:) The
1.873 + ** resolveP2Values() call computes a tighter upper bound on the
1.874 + ** stack size.
1.875 + **
1.876 + ** Allocation all the stack space we will ever need.
1.877 + */
1.878 + if( p->aStack==0 ){
1.879 + int nArg; /* Maximum number of args passed to a user function. */
1.880 + int nStack; /* Maximum number of stack entries required */
1.881 + resolveP2Values(p, &nArg, &nStack);
1.882 + resizeOpArray(p, p->nOp);
1.883 + assert( nVar>=0 );
1.884 + assert( nStack<p->nOp );
1.885 + if( isExplain ){
1.886 + nStack = 10;
1.887 + }
1.888 + p->aStack = sqlite3DbMallocZero(db,
1.889 + nStack*sizeof(p->aStack[0]) /* aStack */
1.890 + + nArg*sizeof(Mem*) /* apArg */
1.891 + + nVar*sizeof(Mem) /* aVar */
1.892 + + nVar*sizeof(char*) /* azVar */
1.893 + + nMem*sizeof(Mem) /* aMem */
1.894 + + nCursor*sizeof(Cursor*) /* apCsr */
1.895 + );
1.896 + if( !db->mallocFailed ){
1.897 + p->aMem = &p->aStack[nStack];
1.898 + p->nMem = nMem;
1.899 + p->aVar = &p->aMem[nMem];
1.900 + p->nVar = nVar;
1.901 + p->okVar = 0;
1.902 + p->apArg = (Mem**)&p->aVar[nVar];
1.903 + p->azVar = (char**)&p->apArg[nArg];
1.904 + p->apCsr = (Cursor**)&p->azVar[nVar];
1.905 + p->nCursor = nCursor;
1.906 + for(n=0; n<nVar; n++){
1.907 + p->aVar[n].flags = MEM_Null;
1.908 + p->aVar[n].db = db;
1.909 + }
1.910 + for(n=0; n<nStack; n++){
1.911 + p->aStack[n].db = db;
1.912 + }
1.913 + }
1.914 + }
1.915 + for(n=0; n<p->nMem; n++){
1.916 + p->aMem[n].flags = MEM_Null;
1.917 + p->aMem[n].db = db;
1.918 + }
1.919 +
1.920 + p->pTos = &p->aStack[-1];
1.921 + p->pc = -1;
1.922 + p->rc = SQLITE_OK;
1.923 + p->uniqueCnt = 0;
1.924 + p->returnDepth = 0;
1.925 + p->errorAction = OE_Abort;
1.926 + p->popStack = 0;
1.927 + p->explain |= isExplain;
1.928 + p->magic = VDBE_MAGIC_RUN;
1.929 + p->nChange = 0;
1.930 + p->cacheCtr = 1;
1.931 + p->minWriteFileFormat = 255;
1.932 + p->openedStatement = 0;
1.933 +#ifdef VDBE_PROFILE
1.934 + {
1.935 + int i;
1.936 + for(i=0; i<p->nOp; i++){
1.937 + p->aOp[i].cnt = 0;
1.938 + p->aOp[i].cycles = 0;
1.939 + }
1.940 + }
1.941 +#endif
1.942 +}
1.943 +
1.944 +/*
1.945 +** Close a VDBE cursor and release all the resources that cursor happens
1.946 +** to hold.
1.947 +*/
1.948 +void sqlite3VdbeFreeCursor(Vdbe *p, Cursor *pCx){
1.949 + if( pCx==0 ){
1.950 + return;
1.951 + }
1.952 + if( pCx->pCursor ){
1.953 + sqlite3BtreeCloseCursor(pCx->pCursor);
1.954 + }
1.955 + if( pCx->pBt ){
1.956 + sqlite3BtreeClose(pCx->pBt);
1.957 + }
1.958 +#ifndef SQLITE_OMIT_VIRTUALTABLE
1.959 + if( pCx->pVtabCursor ){
1.960 + sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor;
1.961 + const sqlite3_module *pModule = pCx->pModule;
1.962 + p->inVtabMethod = 1;
1.963 + sqlite3SafetyOff(p->db);
1.964 + pModule->xClose(pVtabCursor);
1.965 + sqlite3SafetyOn(p->db);
1.966 + p->inVtabMethod = 0;
1.967 + }
1.968 +#endif
1.969 + sqlite3_free(pCx->pData);
1.970 + sqlite3_free(pCx->aType);
1.971 + sqlite3_free(pCx);
1.972 +}
1.973 +
1.974 +/*
1.975 +** Close all cursors except for VTab cursors that are currently
1.976 +** in use.
1.977 +*/
1.978 +static void closeAllCursorsExceptActiveVtabs(Vdbe *p){
1.979 + int i;
1.980 + if( p->apCsr==0 ) return;
1.981 + for(i=0; i<p->nCursor; i++){
1.982 + Cursor *pC = p->apCsr[i];
1.983 + if( pC && (!p->inVtabMethod || !pC->pVtabCursor) ){
1.984 + sqlite3VdbeFreeCursor(p, pC);
1.985 + p->apCsr[i] = 0;
1.986 + }
1.987 + }
1.988 +}
1.989 +
1.990 +/*
1.991 +** Clean up the VM after execution.
1.992 +**
1.993 +** This routine will automatically close any cursors, lists, and/or
1.994 +** sorters that were left open. It also deletes the values of
1.995 +** variables in the aVar[] array.
1.996 +*/
1.997 +static void Cleanup(Vdbe *p){
1.998 + int i;
1.999 + if( p->aStack ){
1.1000 + releaseMemArray(p->aStack, 1 + (p->pTos - p->aStack));
1.1001 + p->pTos = &p->aStack[-1];
1.1002 + }
1.1003 + closeAllCursorsExceptActiveVtabs(p);
1.1004 + releaseMemArray(p->aMem, p->nMem);
1.1005 + sqlite3VdbeFifoClear(&p->sFifo);
1.1006 + if( p->contextStack ){
1.1007 + for(i=0; i<p->contextStackTop; i++){
1.1008 + sqlite3VdbeFifoClear(&p->contextStack[i].sFifo);
1.1009 + }
1.1010 + sqlite3_free(p->contextStack);
1.1011 + }
1.1012 + p->contextStack = 0;
1.1013 + p->contextStackDepth = 0;
1.1014 + p->contextStackTop = 0;
1.1015 + sqlite3_free(p->zErrMsg);
1.1016 + p->zErrMsg = 0;
1.1017 + p->resOnStack = 0;
1.1018 +}
1.1019 +
1.1020 +/*
1.1021 +** Set the number of result columns that will be returned by this SQL
1.1022 +** statement. This is now set at compile time, rather than during
1.1023 +** execution of the vdbe program so that sqlite3_column_count() can
1.1024 +** be called on an SQL statement before sqlite3_step().
1.1025 +*/
1.1026 +void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
1.1027 + Mem *pColName;
1.1028 + int n;
1.1029 +
1.1030 + releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
1.1031 + sqlite3_free(p->aColName);
1.1032 + n = nResColumn*COLNAME_N;
1.1033 + p->nResColumn = nResColumn;
1.1034 + p->aColName = pColName = (Mem*)sqlite3DbMallocZero(p->db, sizeof(Mem)*n );
1.1035 + if( p->aColName==0 ) return;
1.1036 + while( n-- > 0 ){
1.1037 + pColName->flags = MEM_Null;
1.1038 + pColName->db = p->db;
1.1039 + pColName++;
1.1040 + }
1.1041 +}
1.1042 +
1.1043 +/*
1.1044 +** Set the name of the idx'th column to be returned by the SQL statement.
1.1045 +** zName must be a pointer to a nul terminated string.
1.1046 +**
1.1047 +** This call must be made after a call to sqlite3VdbeSetNumCols().
1.1048 +**
1.1049 +** If N==P3_STATIC it means that zName is a pointer to a constant static
1.1050 +** string and we can just copy the pointer. If it is P3_DYNAMIC, then
1.1051 +** the string is freed using sqlite3_free() when the vdbe is finished with
1.1052 +** it. Otherwise, N bytes of zName are copied.
1.1053 +*/
1.1054 +int sqlite3VdbeSetColName(Vdbe *p, int idx, int var, const char *zName, int N){
1.1055 + int rc;
1.1056 + Mem *pColName;
1.1057 + assert( idx<p->nResColumn );
1.1058 + assert( var<COLNAME_N );
1.1059 + if( p->db->mallocFailed ) return SQLITE_NOMEM;
1.1060 + assert( p->aColName!=0 );
1.1061 + pColName = &(p->aColName[idx+var*p->nResColumn]);
1.1062 + if( N==P3_DYNAMIC || N==P3_STATIC ){
1.1063 + rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, SQLITE_STATIC);
1.1064 + }else{
1.1065 + rc = sqlite3VdbeMemSetStr(pColName, zName, N, SQLITE_UTF8,SQLITE_TRANSIENT);
1.1066 + }
1.1067 + if( rc==SQLITE_OK && N==P3_DYNAMIC ){
1.1068 + pColName->flags = (pColName->flags&(~MEM_Static))|MEM_Dyn;
1.1069 + pColName->xDel = 0;
1.1070 + }
1.1071 + return rc;
1.1072 +}
1.1073 +
1.1074 +/*
1.1075 +** A read or write transaction may or may not be active on database handle
1.1076 +** db. If a transaction is active, commit it. If there is a
1.1077 +** write-transaction spanning more than one database file, this routine
1.1078 +** takes care of the master journal trickery.
1.1079 +*/
1.1080 +static int vdbeCommit(sqlite3 *db){
1.1081 + int i;
1.1082 + int nTrans = 0; /* Number of databases with an active write-transaction */
1.1083 + int rc = SQLITE_OK;
1.1084 + int needXcommit = 0;
1.1085 +
1.1086 + /* Before doing anything else, call the xSync() callback for any
1.1087 + ** virtual module tables written in this transaction. This has to
1.1088 + ** be done before determining whether a master journal file is
1.1089 + ** required, as an xSync() callback may add an attached database
1.1090 + ** to the transaction.
1.1091 + */
1.1092 + rc = sqlite3VtabSync(db, rc);
1.1093 + if( rc!=SQLITE_OK ){
1.1094 + return rc;
1.1095 + }
1.1096 +
1.1097 + /* This loop determines (a) if the commit hook should be invoked and
1.1098 + ** (b) how many database files have open write transactions, not
1.1099 + ** including the temp database. (b) is important because if more than
1.1100 + ** one database file has an open write transaction, a master journal
1.1101 + ** file is required for an atomic commit.
1.1102 + */
1.1103 + for(i=0; i<db->nDb; i++){
1.1104 + Btree *pBt = db->aDb[i].pBt;
1.1105 + if( sqlite3BtreeIsInTrans(pBt) ){
1.1106 + needXcommit = 1;
1.1107 + if( i!=1 ) nTrans++;
1.1108 + }
1.1109 + }
1.1110 +
1.1111 + /* If there are any write-transactions at all, invoke the commit hook */
1.1112 + if( needXcommit && db->xCommitCallback ){
1.1113 + sqlite3SafetyOff(db);
1.1114 + rc = db->xCommitCallback(db->pCommitArg);
1.1115 + sqlite3SafetyOn(db);
1.1116 + if( rc ){
1.1117 + return SQLITE_CONSTRAINT;
1.1118 + }
1.1119 + }
1.1120 +
1.1121 + /* The simple case - no more than one database file (not counting the
1.1122 + ** TEMP database) has a transaction active. There is no need for the
1.1123 + ** master-journal.
1.1124 + **
1.1125 + ** If the return value of sqlite3BtreeGetFilename() is a zero length
1.1126 + ** string, it means the main database is :memory:. In that case we do
1.1127 + ** not support atomic multi-file commits, so use the simple case then
1.1128 + ** too.
1.1129 + */
1.1130 + if( 0==strlen(sqlite3BtreeGetFilename(db->aDb[0].pBt)) || nTrans<=1 ){
1.1131 + for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
1.1132 + Btree *pBt = db->aDb[i].pBt;
1.1133 + if( pBt ){
1.1134 + rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
1.1135 + }
1.1136 + }
1.1137 +
1.1138 + /* Do the commit only if all databases successfully complete phase 1.
1.1139 + ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
1.1140 + ** IO error while deleting or truncating a journal file. It is unlikely,
1.1141 + ** but could happen. In this case abandon processing and return the error.
1.1142 + */
1.1143 + for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
1.1144 + Btree *pBt = db->aDb[i].pBt;
1.1145 + if( pBt ){
1.1146 + rc = sqlite3BtreeCommitPhaseTwo(pBt);
1.1147 + }
1.1148 + }
1.1149 + if( rc==SQLITE_OK ){
1.1150 + sqlite3VtabCommit(db);
1.1151 + }
1.1152 + }
1.1153 +
1.1154 + /* The complex case - There is a multi-file write-transaction active.
1.1155 + ** This requires a master journal file to ensure the transaction is
1.1156 + ** committed atomicly.
1.1157 + */
1.1158 +#ifndef SQLITE_OMIT_DISKIO
1.1159 + else{
1.1160 + sqlite3_vfs *pVfs = db->pVfs;
1.1161 + int needSync = 0;
1.1162 + char *zMaster = 0; /* File-name for the master journal */
1.1163 + char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
1.1164 + sqlite3_file *pMaster = 0;
1.1165 + i64 offset = 0;
1.1166 +
1.1167 + /* Select a master journal file name */
1.1168 + do {
1.1169 + u32 random;
1.1170 + sqlite3_free(zMaster);
1.1171 + sqlite3Randomness(sizeof(random), &random);
1.1172 + zMaster = sqlite3MPrintf(db, "%s-mj%08X", zMainFile, random&0x7fffffff);
1.1173 + if( !zMaster ){
1.1174 + return SQLITE_NOMEM;
1.1175 + }
1.1176 + }while( sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS) );
1.1177 +
1.1178 + /* Open the master journal. */
1.1179 + rc = sqlite3OsOpenMalloc(pVfs, zMaster, &pMaster,
1.1180 + SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
1.1181 + SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_MASTER_JOURNAL, 0
1.1182 + );
1.1183 + if( rc!=SQLITE_OK ){
1.1184 + sqlite3_free(zMaster);
1.1185 + return rc;
1.1186 + }
1.1187 +
1.1188 + /* Write the name of each database file in the transaction into the new
1.1189 + ** master journal file. If an error occurs at this point close
1.1190 + ** and delete the master journal file. All the individual journal files
1.1191 + ** still have 'null' as the master journal pointer, so they will roll
1.1192 + ** back independently if a failure occurs.
1.1193 + */
1.1194 + for(i=0; i<db->nDb; i++){
1.1195 + Btree *pBt = db->aDb[i].pBt;
1.1196 + if( i==1 ) continue; /* Ignore the TEMP database */
1.1197 + if( sqlite3BtreeIsInTrans(pBt) ){
1.1198 + char const *zFile = sqlite3BtreeGetJournalname(pBt);
1.1199 + if( zFile[0]==0 ) continue; /* Ignore :memory: databases */
1.1200 + if( !needSync && !sqlite3BtreeSyncDisabled(pBt) ){
1.1201 + needSync = 1;
1.1202 + }
1.1203 + rc = sqlite3OsWrite(pMaster, zFile, strlen(zFile)+1, offset);
1.1204 + offset += strlen(zFile)+1;
1.1205 + if( rc!=SQLITE_OK ){
1.1206 + sqlite3OsCloseFree(pMaster);
1.1207 + sqlite3OsDelete(pVfs, zMaster, 0);
1.1208 + sqlite3_free(zMaster);
1.1209 + return rc;
1.1210 + }
1.1211 + }
1.1212 + }
1.1213 +
1.1214 + /* Sync the master journal file. If the IOCAP_SEQUENTIAL device
1.1215 + ** flag is set this is not required.
1.1216 + */
1.1217 + zMainFile = sqlite3BtreeGetDirname(db->aDb[0].pBt);
1.1218 + if( (needSync
1.1219 + && (0==(sqlite3OsDeviceCharacteristics(pMaster)&SQLITE_IOCAP_SEQUENTIAL))
1.1220 + && (rc=sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL))!=SQLITE_OK) ){
1.1221 + sqlite3OsCloseFree(pMaster);
1.1222 + sqlite3OsDelete(pVfs, zMaster, 0);
1.1223 + sqlite3_free(zMaster);
1.1224 + return rc;
1.1225 + }
1.1226 +
1.1227 + /* Sync all the db files involved in the transaction. The same call
1.1228 + ** sets the master journal pointer in each individual journal. If
1.1229 + ** an error occurs here, do not delete the master journal file.
1.1230 + **
1.1231 + ** If the error occurs during the first call to
1.1232 + ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
1.1233 + ** master journal file will be orphaned. But we cannot delete it,
1.1234 + ** in case the master journal file name was written into the journal
1.1235 + ** file before the failure occured.
1.1236 + */
1.1237 + for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
1.1238 + Btree *pBt = db->aDb[i].pBt;
1.1239 + if( pBt ){
1.1240 + rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster);
1.1241 + }
1.1242 + }
1.1243 + sqlite3OsCloseFree(pMaster);
1.1244 + if( rc!=SQLITE_OK ){
1.1245 + sqlite3_free(zMaster);
1.1246 + return rc;
1.1247 + }
1.1248 +
1.1249 + /* Delete the master journal file. This commits the transaction. After
1.1250 + ** doing this the directory is synced again before any individual
1.1251 + ** transaction files are deleted.
1.1252 + */
1.1253 + rc = sqlite3OsDelete(pVfs, zMaster, 1);
1.1254 + sqlite3_free(zMaster);
1.1255 + zMaster = 0;
1.1256 + if( rc ){
1.1257 + return rc;
1.1258 + }
1.1259 +
1.1260 + /* All files and directories have already been synced, so the following
1.1261 + ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
1.1262 + ** deleting or truncating journals. If something goes wrong while
1.1263 + ** this is happening we don't really care. The integrity of the
1.1264 + ** transaction is already guaranteed, but some stray 'cold' journals
1.1265 + ** may be lying around. Returning an error code won't help matters.
1.1266 + */
1.1267 + disable_simulated_io_errors();
1.1268 + for(i=0; i<db->nDb; i++){
1.1269 + Btree *pBt = db->aDb[i].pBt;
1.1270 + if( pBt ){
1.1271 + sqlite3BtreeCommitPhaseTwo(pBt);
1.1272 + }
1.1273 + }
1.1274 + enable_simulated_io_errors();
1.1275 +
1.1276 + sqlite3VtabCommit(db);
1.1277 + }
1.1278 +#endif
1.1279 +
1.1280 + return rc;
1.1281 +}
1.1282 +
1.1283 +/*
1.1284 +** This routine checks that the sqlite3.activeVdbeCnt count variable
1.1285 +** matches the number of vdbe's in the list sqlite3.pVdbe that are
1.1286 +** currently active. An assertion fails if the two counts do not match.
1.1287 +** This is an internal self-check only - it is not an essential processing
1.1288 +** step.
1.1289 +**
1.1290 +** This is a no-op if NDEBUG is defined.
1.1291 +*/
1.1292 +#ifndef NDEBUG
1.1293 +static void checkActiveVdbeCnt(sqlite3 *db){
1.1294 + Vdbe *p;
1.1295 + int cnt = 0;
1.1296 + p = db->pVdbe;
1.1297 + while( p ){
1.1298 + if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
1.1299 + cnt++;
1.1300 + }
1.1301 + p = p->pNext;
1.1302 + }
1.1303 + assert( cnt==db->activeVdbeCnt );
1.1304 +}
1.1305 +#else
1.1306 +#define checkActiveVdbeCnt(x)
1.1307 +#endif
1.1308 +
1.1309 +/*
1.1310 +** For every Btree that in database connection db which
1.1311 +** has been modified, "trip" or invalidate each cursor in
1.1312 +** that Btree might have been modified so that the cursor
1.1313 +** can never be used again. This happens when a rollback
1.1314 +*** occurs. We have to trip all the other cursors, even
1.1315 +** cursor from other VMs in different database connections,
1.1316 +** so that none of them try to use the data at which they
1.1317 +** were pointing and which now may have been changed due
1.1318 +** to the rollback.
1.1319 +**
1.1320 +** Remember that a rollback can delete tables complete and
1.1321 +** reorder rootpages. So it is not sufficient just to save
1.1322 +** the state of the cursor. We have to invalidate the cursor
1.1323 +** so that it is never used again.
1.1324 +*/
1.1325 +void invalidateCursorsOnModifiedBtrees(sqlite3 *db){
1.1326 + int i;
1.1327 + for(i=0; i<db->nDb; i++){
1.1328 + Btree *p = db->aDb[i].pBt;
1.1329 + if( p && sqlite3BtreeIsInTrans(p) ){
1.1330 + sqlite3BtreeTripAllCursors(p, SQLITE_ABORT);
1.1331 + }
1.1332 + }
1.1333 +}
1.1334 +
1.1335 +/*
1.1336 +** This routine is called the when a VDBE tries to halt. If the VDBE
1.1337 +** has made changes and is in autocommit mode, then commit those
1.1338 +** changes. If a rollback is needed, then do the rollback.
1.1339 +**
1.1340 +** This routine is the only way to move the state of a VM from
1.1341 +** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to
1.1342 +** call this on a VM that is in the SQLITE_MAGIC_HALT state.
1.1343 +**
1.1344 +** Return an error code. If the commit could not complete because of
1.1345 +** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it
1.1346 +** means the close did not happen and needs to be repeated.
1.1347 +*/
1.1348 +int sqlite3VdbeHalt(Vdbe *p){
1.1349 + sqlite3 *db = p->db;
1.1350 + int i;
1.1351 + int (*xFunc)(Btree *pBt) = 0; /* Function to call on each btree backend */
1.1352 + int isSpecialError; /* Set to true if SQLITE_NOMEM or IOERR */
1.1353 +
1.1354 + /* This function contains the logic that determines if a statement or
1.1355 + ** transaction will be committed or rolled back as a result of the
1.1356 + ** execution of this virtual machine.
1.1357 + **
1.1358 + ** If any of the following errors occur:
1.1359 + **
1.1360 + ** SQLITE_NOMEM
1.1361 + ** SQLITE_IOERR
1.1362 + ** SQLITE_FULL
1.1363 + ** SQLITE_INTERRUPT
1.1364 + **
1.1365 + ** Then the internal cache might have been left in an inconsistent
1.1366 + ** state. We need to rollback the statement transaction, if there is
1.1367 + ** one, or the complete transaction if there is no statement transaction.
1.1368 + */
1.1369 +
1.1370 + if( p->db->mallocFailed ){
1.1371 + p->rc = SQLITE_NOMEM;
1.1372 + }
1.1373 + closeAllCursorsExceptActiveVtabs(p);
1.1374 + if( p->magic!=VDBE_MAGIC_RUN ){
1.1375 + return SQLITE_OK;
1.1376 + }
1.1377 + checkActiveVdbeCnt(db);
1.1378 +
1.1379 + /* No commit or rollback needed if the program never started */
1.1380 + if( p->pc>=0 ){
1.1381 + int mrc; /* Primary error code from p->rc */
1.1382 +
1.1383 + /* Lock all btrees used by the statement */
1.1384 + sqlite3BtreeMutexArrayEnter(&p->aMutex);
1.1385 +
1.1386 + /* Check for one of the special errors */
1.1387 + mrc = p->rc & 0xff;
1.1388 + isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR
1.1389 + || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL ;
1.1390 + if( isSpecialError ){
1.1391 + /* This loop does static analysis of the query to see which of the
1.1392 + ** following three categories it falls into:
1.1393 + **
1.1394 + ** Read-only
1.1395 + ** Query with statement journal
1.1396 + ** Query without statement journal
1.1397 + **
1.1398 + ** We could do something more elegant than this static analysis (i.e.
1.1399 + ** store the type of query as part of the compliation phase), but
1.1400 + ** handling malloc() or IO failure is a fairly obscure edge case so
1.1401 + ** this is probably easier. Todo: Might be an opportunity to reduce
1.1402 + ** code size a very small amount though...
1.1403 + */
1.1404 + int notReadOnly = 0;
1.1405 + int isStatement = 0;
1.1406 + assert(p->aOp || p->nOp==0);
1.1407 + for(i=0; i<p->nOp; i++){
1.1408 + switch( p->aOp[i].opcode ){
1.1409 + case OP_Transaction:
1.1410 + notReadOnly |= p->aOp[i].p2;
1.1411 + break;
1.1412 + case OP_Statement:
1.1413 + isStatement = 1;
1.1414 + break;
1.1415 + }
1.1416 + }
1.1417 +
1.1418 +
1.1419 + /* If the query was read-only, we need do no rollback at all. Otherwise,
1.1420 + ** proceed with the special handling.
1.1421 + */
1.1422 + if( notReadOnly || mrc!=SQLITE_INTERRUPT ){
1.1423 + if( p->rc==SQLITE_IOERR_BLOCKED && isStatement ){
1.1424 + xFunc = sqlite3BtreeRollbackStmt;
1.1425 + p->rc = SQLITE_BUSY;
1.1426 + } else if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && isStatement ){
1.1427 + xFunc = sqlite3BtreeRollbackStmt;
1.1428 + }else{
1.1429 + /* We are forced to roll back the active transaction. Before doing
1.1430 + ** so, abort any other statements this handle currently has active.
1.1431 + */
1.1432 + invalidateCursorsOnModifiedBtrees(db);
1.1433 + sqlite3RollbackAll(db);
1.1434 + db->autoCommit = 1;
1.1435 + }
1.1436 + }
1.1437 + }
1.1438 +
1.1439 + /* If the auto-commit flag is set and this is the only active vdbe, then
1.1440 + ** we do either a commit or rollback of the current transaction.
1.1441 + **
1.1442 + ** Note: This block also runs if one of the special errors handled
1.1443 + ** above has occured.
1.1444 + */
1.1445 + if( db->autoCommit && db->activeVdbeCnt==1 ){
1.1446 + if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
1.1447 + /* The auto-commit flag is true, and the vdbe program was
1.1448 + ** successful or hit an 'OR FAIL' constraint. This means a commit
1.1449 + ** is required.
1.1450 + */
1.1451 + int rc = vdbeCommit(db);
1.1452 + if( rc==SQLITE_BUSY ){
1.1453 + sqlite3BtreeMutexArrayLeave(&p->aMutex);
1.1454 + return SQLITE_BUSY;
1.1455 + }else if( rc!=SQLITE_OK ){
1.1456 + p->rc = rc;
1.1457 + sqlite3RollbackAll(db);
1.1458 + }else{
1.1459 + sqlite3CommitInternalChanges(db);
1.1460 + }
1.1461 + }else{
1.1462 + sqlite3RollbackAll(db);
1.1463 + }
1.1464 + }else if( !xFunc ){
1.1465 + if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
1.1466 + if( p->openedStatement ){
1.1467 + xFunc = sqlite3BtreeCommitStmt;
1.1468 + }
1.1469 + }else if( p->errorAction==OE_Abort ){
1.1470 + xFunc = sqlite3BtreeRollbackStmt;
1.1471 + }else{
1.1472 + invalidateCursorsOnModifiedBtrees(db);
1.1473 + sqlite3RollbackAll(db);
1.1474 + db->autoCommit = 1;
1.1475 + }
1.1476 + }
1.1477 +
1.1478 + /* If xFunc is not NULL, then it is one of sqlite3BtreeRollbackStmt or
1.1479 + ** sqlite3BtreeCommitStmt. Call it once on each backend. If an error occurs
1.1480 + ** and the return code is still SQLITE_OK, set the return code to the new
1.1481 + ** error value.
1.1482 + */
1.1483 + assert(!xFunc ||
1.1484 + xFunc==sqlite3BtreeCommitStmt ||
1.1485 + xFunc==sqlite3BtreeRollbackStmt
1.1486 + );
1.1487 + for(i=0; xFunc && i<db->nDb; i++){
1.1488 + int rc;
1.1489 + Btree *pBt = db->aDb[i].pBt;
1.1490 + if( pBt ){
1.1491 + rc = xFunc(pBt);
1.1492 + if( rc && (p->rc==SQLITE_OK || p->rc==SQLITE_CONSTRAINT) ){
1.1493 + p->rc = rc;
1.1494 + sqlite3SetString(&p->zErrMsg, 0);
1.1495 + }
1.1496 + }
1.1497 + }
1.1498 +
1.1499 + /* If this was an INSERT, UPDATE or DELETE and the statement was committed,
1.1500 + ** set the change counter.
1.1501 + */
1.1502 + if( p->changeCntOn && p->pc>=0 ){
1.1503 + if( !xFunc || xFunc==sqlite3BtreeCommitStmt ){
1.1504 + sqlite3VdbeSetChanges(db, p->nChange);
1.1505 + }else{
1.1506 + sqlite3VdbeSetChanges(db, 0);
1.1507 + }
1.1508 + p->nChange = 0;
1.1509 + }
1.1510 +
1.1511 + /* Rollback or commit any schema changes that occurred. */
1.1512 + if( p->rc!=SQLITE_OK && db->flags&SQLITE_InternChanges ){
1.1513 + sqlite3ResetInternalSchema(db, 0);
1.1514 + db->flags = (db->flags | SQLITE_InternChanges);
1.1515 + }
1.1516 +
1.1517 + /* Release the locks */
1.1518 + sqlite3BtreeMutexArrayLeave(&p->aMutex);
1.1519 + }
1.1520 +
1.1521 + /* We have successfully halted and closed the VM. Record this fact. */
1.1522 + if( p->pc>=0 ){
1.1523 + db->activeVdbeCnt--;
1.1524 + }
1.1525 + p->magic = VDBE_MAGIC_HALT;
1.1526 + checkActiveVdbeCnt(db);
1.1527 + if( p->db->mallocFailed ){
1.1528 + p->rc = SQLITE_NOMEM;
1.1529 + }
1.1530 + checkActiveVdbeCnt(db);
1.1531 +
1.1532 + return SQLITE_OK;
1.1533 +}
1.1534 +
1.1535 +
1.1536 +/*
1.1537 +** Each VDBE holds the result of the most recent sqlite3_step() call
1.1538 +** in p->rc. This routine sets that result back to SQLITE_OK.
1.1539 +*/
1.1540 +void sqlite3VdbeResetStepResult(Vdbe *p){
1.1541 + p->rc = SQLITE_OK;
1.1542 +}
1.1543 +
1.1544 +/*
1.1545 +** Clean up a VDBE after execution but do not delete the VDBE just yet.
1.1546 +** Write any error messages into *pzErrMsg. Return the result code.
1.1547 +**
1.1548 +** After this routine is run, the VDBE should be ready to be executed
1.1549 +** again.
1.1550 +**
1.1551 +** To look at it another way, this routine resets the state of the
1.1552 +** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to
1.1553 +** VDBE_MAGIC_INIT.
1.1554 +*/
1.1555 +int sqlite3VdbeReset(Vdbe *p){
1.1556 + sqlite3 *db;
1.1557 + db = p->db;
1.1558 +
1.1559 + /* If the VM did not run to completion or if it encountered an
1.1560 + ** error, then it might not have been halted properly. So halt
1.1561 + ** it now.
1.1562 + */
1.1563 + sqlite3SafetyOn(db);
1.1564 + sqlite3VdbeHalt(p);
1.1565 + sqlite3SafetyOff(db);
1.1566 +
1.1567 + /* If the VDBE has be run even partially, then transfer the error code
1.1568 + ** and error message from the VDBE into the main database structure. But
1.1569 + ** if the VDBE has just been set to run but has not actually executed any
1.1570 + ** instructions yet, leave the main database error information unchanged.
1.1571 + */
1.1572 + if( p->pc>=0 ){
1.1573 + if( p->zErrMsg ){
1.1574 + sqlite3ValueSetStr(db->pErr,-1,p->zErrMsg,SQLITE_UTF8,sqlite3_free);
1.1575 + db->errCode = p->rc;
1.1576 + p->zErrMsg = 0;
1.1577 + }else if( p->rc ){
1.1578 + sqlite3Error(db, p->rc, 0);
1.1579 + }else{
1.1580 + sqlite3Error(db, SQLITE_OK, 0);
1.1581 + }
1.1582 + }else if( p->rc && p->expired ){
1.1583 + /* The expired flag was set on the VDBE before the first call
1.1584 + ** to sqlite3_step(). For consistency (since sqlite3_step() was
1.1585 + ** called), set the database error in this case as well.
1.1586 + */
1.1587 + sqlite3Error(db, p->rc, 0);
1.1588 + }
1.1589 +
1.1590 + /* Reclaim all memory used by the VDBE
1.1591 + */
1.1592 + Cleanup(p);
1.1593 +
1.1594 + /* Save profiling information from this VDBE run.
1.1595 + */
1.1596 + assert( p->pTos<&p->aStack[p->pc<0?0:p->pc] || !p->aStack );
1.1597 +#ifdef VDBE_PROFILE
1.1598 + {
1.1599 + FILE *out = fopen("vdbe_profile.out", "a");
1.1600 + if( out ){
1.1601 + int i;
1.1602 + fprintf(out, "---- ");
1.1603 + for(i=0; i<p->nOp; i++){
1.1604 + fprintf(out, "%02x", p->aOp[i].opcode);
1.1605 + }
1.1606 + fprintf(out, "\n");
1.1607 + for(i=0; i<p->nOp; i++){
1.1608 + fprintf(out, "%6d %10lld %8lld ",
1.1609 + p->aOp[i].cnt,
1.1610 + p->aOp[i].cycles,
1.1611 + p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
1.1612 + );
1.1613 + sqlite3VdbePrintOp(out, i, &p->aOp[i]);
1.1614 + }
1.1615 + fclose(out);
1.1616 + }
1.1617 + }
1.1618 +#endif
1.1619 + p->magic = VDBE_MAGIC_INIT;
1.1620 + p->aborted = 0;
1.1621 + return p->rc & db->errMask;
1.1622 +}
1.1623 +
1.1624 +/*
1.1625 +** Clean up and delete a VDBE after execution. Return an integer which is
1.1626 +** the result code. Write any error message text into *pzErrMsg.
1.1627 +*/
1.1628 +int sqlite3VdbeFinalize(Vdbe *p){
1.1629 + int rc = SQLITE_OK;
1.1630 + if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){
1.1631 + rc = sqlite3VdbeReset(p);
1.1632 + assert( (rc & p->db->errMask)==rc );
1.1633 + }else if( p->magic!=VDBE_MAGIC_INIT ){
1.1634 + return SQLITE_MISUSE;
1.1635 + }
1.1636 + sqlite3VdbeDelete(p);
1.1637 + return rc;
1.1638 +}
1.1639 +
1.1640 +/*
1.1641 +** Call the destructor for each auxdata entry in pVdbeFunc for which
1.1642 +** the corresponding bit in mask is clear. Auxdata entries beyond 31
1.1643 +** are always destroyed. To destroy all auxdata entries, call this
1.1644 +** routine with mask==0.
1.1645 +*/
1.1646 +void sqlite3VdbeDeleteAuxData(VdbeFunc *pVdbeFunc, int mask){
1.1647 + int i;
1.1648 + for(i=0; i<pVdbeFunc->nAux; i++){
1.1649 + struct AuxData *pAux = &pVdbeFunc->apAux[i];
1.1650 + if( (i>31 || !(mask&(1<<i))) && pAux->pAux ){
1.1651 + if( pAux->xDelete ){
1.1652 + pAux->xDelete(pAux->pAux);
1.1653 + }
1.1654 + pAux->pAux = 0;
1.1655 + }
1.1656 + }
1.1657 +}
1.1658 +
1.1659 +/*
1.1660 +** Delete an entire VDBE.
1.1661 +*/
1.1662 +void sqlite3VdbeDelete(Vdbe *p){
1.1663 + int i;
1.1664 + if( p==0 ) return;
1.1665 + Cleanup(p);
1.1666 + if( p->pPrev ){
1.1667 + p->pPrev->pNext = p->pNext;
1.1668 + }else{
1.1669 + assert( p->db->pVdbe==p );
1.1670 + p->db->pVdbe = p->pNext;
1.1671 + }
1.1672 + if( p->pNext ){
1.1673 + p->pNext->pPrev = p->pPrev;
1.1674 + }
1.1675 + if( p->aOp ){
1.1676 + for(i=0; i<p->nOp; i++){
1.1677 + Op *pOp = &p->aOp[i];
1.1678 + freeP3(pOp->p3type, pOp->p3);
1.1679 + }
1.1680 + sqlite3_free(p->aOp);
1.1681 + }
1.1682 + releaseMemArray(p->aVar, p->nVar);
1.1683 + sqlite3_free(p->aLabel);
1.1684 + sqlite3_free(p->aStack);
1.1685 + releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
1.1686 + sqlite3_free(p->aColName);
1.1687 + sqlite3_free(p->zSql);
1.1688 + p->magic = VDBE_MAGIC_DEAD;
1.1689 + sqlite3_free(p);
1.1690 +}
1.1691 +
1.1692 +/*
1.1693 +** If a MoveTo operation is pending on the given cursor, then do that
1.1694 +** MoveTo now. Return an error code. If no MoveTo is pending, this
1.1695 +** routine does nothing and returns SQLITE_OK.
1.1696 +*/
1.1697 +int sqlite3VdbeCursorMoveto(Cursor *p){
1.1698 + if( p->deferredMoveto ){
1.1699 + int res, rc;
1.1700 +#ifdef SQLITE_TEST
1.1701 + extern int sqlite3_search_count;
1.1702 +#endif
1.1703 + assert( p->isTable );
1.1704 + rc = sqlite3BtreeMoveto(p->pCursor, 0, p->movetoTarget, 0, &res);
1.1705 + if( rc ) return rc;
1.1706 + *p->pIncrKey = 0;
1.1707 + p->lastRowid = keyToInt(p->movetoTarget);
1.1708 + p->rowidIsValid = res==0;
1.1709 + if( res<0 ){
1.1710 + rc = sqlite3BtreeNext(p->pCursor, &res);
1.1711 + if( rc ) return rc;
1.1712 + }
1.1713 +#ifdef SQLITE_TEST
1.1714 + sqlite3_search_count++;
1.1715 +#endif
1.1716 + p->deferredMoveto = 0;
1.1717 + p->cacheStatus = CACHE_STALE;
1.1718 + }
1.1719 + return SQLITE_OK;
1.1720 +}
1.1721 +
1.1722 +/*
1.1723 +** The following functions:
1.1724 +**
1.1725 +** sqlite3VdbeSerialType()
1.1726 +** sqlite3VdbeSerialTypeLen()
1.1727 +** sqlite3VdbeSerialRead()
1.1728 +** sqlite3VdbeSerialLen()
1.1729 +** sqlite3VdbeSerialWrite()
1.1730 +**
1.1731 +** encapsulate the code that serializes values for storage in SQLite
1.1732 +** data and index records. Each serialized value consists of a
1.1733 +** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
1.1734 +** integer, stored as a varint.
1.1735 +**
1.1736 +** In an SQLite index record, the serial type is stored directly before
1.1737 +** the blob of data that it corresponds to. In a table record, all serial
1.1738 +** types are stored at the start of the record, and the blobs of data at
1.1739 +** the end. Hence these functions allow the caller to handle the
1.1740 +** serial-type and data blob seperately.
1.1741 +**
1.1742 +** The following table describes the various storage classes for data:
1.1743 +**
1.1744 +** serial type bytes of data type
1.1745 +** -------------- --------------- ---------------
1.1746 +** 0 0 NULL
1.1747 +** 1 1 signed integer
1.1748 +** 2 2 signed integer
1.1749 +** 3 3 signed integer
1.1750 +** 4 4 signed integer
1.1751 +** 5 6 signed integer
1.1752 +** 6 8 signed integer
1.1753 +** 7 8 IEEE float
1.1754 +** 8 0 Integer constant 0
1.1755 +** 9 0 Integer constant 1
1.1756 +** 10,11 reserved for expansion
1.1757 +** N>=12 and even (N-12)/2 BLOB
1.1758 +** N>=13 and odd (N-13)/2 text
1.1759 +**
1.1760 +** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions
1.1761 +** of SQLite will not understand those serial types.
1.1762 +*/
1.1763 +
1.1764 +/*
1.1765 +** Return the serial-type for the value stored in pMem.
1.1766 +*/
1.1767 +u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
1.1768 + int flags = pMem->flags;
1.1769 + int n;
1.1770 +
1.1771 + if( flags&MEM_Null ){
1.1772 + return 0;
1.1773 + }
1.1774 + if( flags&MEM_Int ){
1.1775 + /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
1.1776 +# define MAX_6BYTE ((((i64)0x00001000)<<32)-1)
1.1777 + i64 i = pMem->u.i;
1.1778 + u64 u;
1.1779 + if( file_format>=4 && (i&1)==i ){
1.1780 + return 8+i;
1.1781 + }
1.1782 + u = i<0 ? -i : i;
1.1783 + if( u<=127 ) return 1;
1.1784 + if( u<=32767 ) return 2;
1.1785 + if( u<=8388607 ) return 3;
1.1786 + if( u<=2147483647 ) return 4;
1.1787 + if( u<=MAX_6BYTE ) return 5;
1.1788 + return 6;
1.1789 + }
1.1790 + if( flags&MEM_Real ){
1.1791 + return 7;
1.1792 + }
1.1793 + assert( flags&(MEM_Str|MEM_Blob) );
1.1794 + n = pMem->n;
1.1795 + if( flags & MEM_Zero ){
1.1796 + n += pMem->u.i;
1.1797 + }
1.1798 + assert( n>=0 );
1.1799 + return ((n*2) + 12 + ((flags&MEM_Str)!=0));
1.1800 +}
1.1801 +
1.1802 +/*
1.1803 +** Return the length of the data corresponding to the supplied serial-type.
1.1804 +*/
1.1805 +int sqlite3VdbeSerialTypeLen(u32 serial_type){
1.1806 + if( serial_type>=12 ){
1.1807 + return (serial_type-12)/2;
1.1808 + }else{
1.1809 + static const u8 aSize[] = { 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0 };
1.1810 + return aSize[serial_type];
1.1811 + }
1.1812 +}
1.1813 +
1.1814 +/*
1.1815 +** If we are on an architecture with mixed-endian floating
1.1816 +** points (ex: ARM7) then swap the lower 4 bytes with the
1.1817 +** upper 4 bytes. Return the result.
1.1818 +**
1.1819 +** For most architectures, this is a no-op.
1.1820 +**
1.1821 +** (later): It is reported to me that the mixed-endian problem
1.1822 +** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
1.1823 +** that early versions of GCC stored the two words of a 64-bit
1.1824 +** float in the wrong order. And that error has been propagated
1.1825 +** ever since. The blame is not necessarily with GCC, though.
1.1826 +** GCC might have just copying the problem from a prior compiler.
1.1827 +** I am also told that newer versions of GCC that follow a different
1.1828 +** ABI get the byte order right.
1.1829 +**
1.1830 +** Developers using SQLite on an ARM7 should compile and run their
1.1831 +** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
1.1832 +** enabled, some asserts below will ensure that the byte order of
1.1833 +** floating point values is correct.
1.1834 +**
1.1835 +** (2007-08-30) Frank van Vugt has studied this problem closely
1.1836 +** and has send his findings to the SQLite developers. Frank
1.1837 +** writes that some Linux kernels offer floating point hardware
1.1838 +** emulation that uses only 32-bit mantissas instead of a full
1.1839 +** 48-bits as required by the IEEE standard. (This is the
1.1840 +** CONFIG_FPE_FASTFPE option.) On such systems, floating point
1.1841 +** byte swapping becomes very complicated. To avoid problems,
1.1842 +** the necessary byte swapping is carried out using a 64-bit integer
1.1843 +** rather than a 64-bit float. Frank assures us that the code here
1.1844 +** works for him. We, the developers, have no way to independently
1.1845 +** verify this, but Frank seems to know what he is talking about
1.1846 +** so we trust him.
1.1847 +*/
1.1848 +#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
1.1849 +static u64 floatSwap(u64 in){
1.1850 + union {
1.1851 + u64 r;
1.1852 + u32 i[2];
1.1853 + } u;
1.1854 + u32 t;
1.1855 +
1.1856 + u.r = in;
1.1857 + t = u.i[0];
1.1858 + u.i[0] = u.i[1];
1.1859 + u.i[1] = t;
1.1860 + return u.r;
1.1861 +}
1.1862 +# define swapMixedEndianFloat(X) X = floatSwap(X)
1.1863 +#else
1.1864 +# define swapMixedEndianFloat(X)
1.1865 +#endif
1.1866 +
1.1867 +/*
1.1868 +** Write the serialized data blob for the value stored in pMem into
1.1869 +** buf. It is assumed that the caller has allocated sufficient space.
1.1870 +** Return the number of bytes written.
1.1871 +**
1.1872 +** nBuf is the amount of space left in buf[]. nBuf must always be
1.1873 +** large enough to hold the entire field. Except, if the field is
1.1874 +** a blob with a zero-filled tail, then buf[] might be just the right
1.1875 +** size to hold everything except for the zero-filled tail. If buf[]
1.1876 +** is only big enough to hold the non-zero prefix, then only write that
1.1877 +** prefix into buf[]. But if buf[] is large enough to hold both the
1.1878 +** prefix and the tail then write the prefix and set the tail to all
1.1879 +** zeros.
1.1880 +**
1.1881 +** Return the number of bytes actually written into buf[]. The number
1.1882 +** of bytes in the zero-filled tail is included in the return value only
1.1883 +** if those bytes were zeroed in buf[].
1.1884 +*/
1.1885 +int sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
1.1886 + u32 serial_type = sqlite3VdbeSerialType(pMem, file_format);
1.1887 + int len;
1.1888 +
1.1889 + /* Integer and Real */
1.1890 + if( serial_type<=7 && serial_type>0 ){
1.1891 + u64 v;
1.1892 + int i;
1.1893 + if( serial_type==7 ){
1.1894 + assert( sizeof(v)==sizeof(pMem->r) );
1.1895 + memcpy(&v, &pMem->r, sizeof(v));
1.1896 + swapMixedEndianFloat(v);
1.1897 + }else{
1.1898 + v = pMem->u.i;
1.1899 + }
1.1900 + len = i = sqlite3VdbeSerialTypeLen(serial_type);
1.1901 + assert( len<=nBuf );
1.1902 + while( i-- ){
1.1903 + buf[i] = (v&0xFF);
1.1904 + v >>= 8;
1.1905 + }
1.1906 + return len;
1.1907 + }
1.1908 +
1.1909 + /* String or blob */
1.1910 + if( serial_type>=12 ){
1.1911 + assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.i:0)
1.1912 + == sqlite3VdbeSerialTypeLen(serial_type) );
1.1913 + assert( pMem->n<=nBuf );
1.1914 + len = pMem->n;
1.1915 + memcpy(buf, pMem->z, len);
1.1916 + if( pMem->flags & MEM_Zero ){
1.1917 + len += pMem->u.i;
1.1918 + if( len>nBuf ){
1.1919 + len = nBuf;
1.1920 + }
1.1921 + memset(&buf[pMem->n], 0, len-pMem->n);
1.1922 + }
1.1923 + return len;
1.1924 + }
1.1925 +
1.1926 + /* NULL or constants 0 or 1 */
1.1927 + return 0;
1.1928 +}
1.1929 +
1.1930 +/*
1.1931 +** Deserialize the data blob pointed to by buf as serial type serial_type
1.1932 +** and store the result in pMem. Return the number of bytes read.
1.1933 +*/
1.1934 +int sqlite3VdbeSerialGet(
1.1935 + const unsigned char *buf, /* Buffer to deserialize from */
1.1936 + u32 serial_type, /* Serial type to deserialize */
1.1937 + Mem *pMem /* Memory cell to write value into */
1.1938 +){
1.1939 + switch( serial_type ){
1.1940 + case 10: /* Reserved for future use */
1.1941 + case 11: /* Reserved for future use */
1.1942 + case 0: { /* NULL */
1.1943 + pMem->flags = MEM_Null;
1.1944 + break;
1.1945 + }
1.1946 + case 1: { /* 1-byte signed integer */
1.1947 + pMem->u.i = (signed char)buf[0];
1.1948 + pMem->flags = MEM_Int;
1.1949 + return 1;
1.1950 + }
1.1951 + case 2: { /* 2-byte signed integer */
1.1952 + pMem->u.i = (((signed char)buf[0])<<8) | buf[1];
1.1953 + pMem->flags = MEM_Int;
1.1954 + return 2;
1.1955 + }
1.1956 + case 3: { /* 3-byte signed integer */
1.1957 + pMem->u.i = (((signed char)buf[0])<<16) | (buf[1]<<8) | buf[2];
1.1958 + pMem->flags = MEM_Int;
1.1959 + return 3;
1.1960 + }
1.1961 + case 4: { /* 4-byte signed integer */
1.1962 + pMem->u.i = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
1.1963 + pMem->flags = MEM_Int;
1.1964 + return 4;
1.1965 + }
1.1966 + case 5: { /* 6-byte signed integer */
1.1967 + u64 x = (((signed char)buf[0])<<8) | buf[1];
1.1968 + u32 y = (buf[2]<<24) | (buf[3]<<16) | (buf[4]<<8) | buf[5];
1.1969 + x = (x<<32) | y;
1.1970 + pMem->u.i = *(i64*)&x;
1.1971 + pMem->flags = MEM_Int;
1.1972 + return 6;
1.1973 + }
1.1974 + case 6: /* 8-byte signed integer */
1.1975 + case 7: { /* IEEE floating point */
1.1976 + u64 x;
1.1977 + u32 y;
1.1978 +#if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
1.1979 + /* Verify that integers and floating point values use the same
1.1980 + ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
1.1981 + ** defined that 64-bit floating point values really are mixed
1.1982 + ** endian.
1.1983 + */
1.1984 + static const u64 t1 = ((u64)0x3ff00000)<<32;
1.1985 + static const double r1 = 1.0;
1.1986 + u64 t2 = t1;
1.1987 + swapMixedEndianFloat(t2);
1.1988 + assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
1.1989 +#endif
1.1990 +
1.1991 + x = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
1.1992 + y = (buf[4]<<24) | (buf[5]<<16) | (buf[6]<<8) | buf[7];
1.1993 + x = (x<<32) | y;
1.1994 + if( serial_type==6 ){
1.1995 + pMem->u.i = *(i64*)&x;
1.1996 + pMem->flags = MEM_Int;
1.1997 + }else{
1.1998 + assert( sizeof(x)==8 && sizeof(pMem->r)==8 );
1.1999 + swapMixedEndianFloat(x);
1.2000 + memcpy(&pMem->r, &x, sizeof(x));
1.2001 + pMem->flags = MEM_Real;
1.2002 + }
1.2003 + return 8;
1.2004 + }
1.2005 + case 8: /* Integer 0 */
1.2006 + case 9: { /* Integer 1 */
1.2007 + pMem->u.i = serial_type-8;
1.2008 + pMem->flags = MEM_Int;
1.2009 + return 0;
1.2010 + }
1.2011 + default: {
1.2012 + int len = (serial_type-12)/2;
1.2013 + pMem->z = (char *)buf;
1.2014 + pMem->n = len;
1.2015 + pMem->xDel = 0;
1.2016 + if( serial_type&0x01 ){
1.2017 + pMem->flags = MEM_Str | MEM_Ephem;
1.2018 + }else{
1.2019 + pMem->flags = MEM_Blob | MEM_Ephem;
1.2020 + }
1.2021 + return len;
1.2022 + }
1.2023 + }
1.2024 + return 0;
1.2025 +}
1.2026 +
1.2027 +/*
1.2028 +** The header of a record consists of a sequence variable-length integers.
1.2029 +** These integers are almost always small and are encoded as a single byte.
1.2030 +** The following macro takes advantage this fact to provide a fast decode
1.2031 +** of the integers in a record header. It is faster for the common case
1.2032 +** where the integer is a single byte. It is a little slower when the
1.2033 +** integer is two or more bytes. But overall it is faster.
1.2034 +**
1.2035 +** The following expressions are equivalent:
1.2036 +**
1.2037 +** x = sqlite3GetVarint32( A, &B );
1.2038 +**
1.2039 +** x = GetVarint( A, B );
1.2040 +**
1.2041 +*/
1.2042 +#define GetVarint(A,B) ((B = *(A))<=0x7f ? 1 : sqlite3GetVarint32(A, &B))
1.2043 +
1.2044 +/*
1.2045 +** This function compares the two table rows or index records specified by
1.2046 +** {nKey1, pKey1} and {nKey2, pKey2}, returning a negative, zero
1.2047 +** or positive integer if {nKey1, pKey1} is less than, equal to or
1.2048 +** greater than {nKey2, pKey2}. Both Key1 and Key2 must be byte strings
1.2049 +** composed by the OP_MakeRecord opcode of the VDBE.
1.2050 +*/
1.2051 +int sqlite3VdbeRecordCompare(
1.2052 + void *userData,
1.2053 + int nKey1, const void *pKey1,
1.2054 + int nKey2, const void *pKey2
1.2055 +){
1.2056 + KeyInfo *pKeyInfo = (KeyInfo*)userData;
1.2057 + u32 d1, d2; /* Offset into aKey[] of next data element */
1.2058 + u32 idx1, idx2; /* Offset into aKey[] of next header element */
1.2059 + u32 szHdr1, szHdr2; /* Number of bytes in header */
1.2060 + int i = 0;
1.2061 + int nField;
1.2062 + int rc = 0;
1.2063 + const unsigned char *aKey1 = (const unsigned char *)pKey1;
1.2064 + const unsigned char *aKey2 = (const unsigned char *)pKey2;
1.2065 +
1.2066 + Mem mem1;
1.2067 + Mem mem2;
1.2068 + mem1.enc = pKeyInfo->enc;
1.2069 + mem1.db = pKeyInfo->db;
1.2070 + mem2.enc = pKeyInfo->enc;
1.2071 + mem2.db = pKeyInfo->db;
1.2072 +
1.2073 + idx1 = GetVarint(aKey1, szHdr1);
1.2074 + d1 = szHdr1;
1.2075 + idx2 = GetVarint(aKey2, szHdr2);
1.2076 + d2 = szHdr2;
1.2077 + nField = pKeyInfo->nField;
1.2078 + while( idx1<szHdr1 && idx2<szHdr2 ){
1.2079 + u32 serial_type1;
1.2080 + u32 serial_type2;
1.2081 +
1.2082 + /* Read the serial types for the next element in each key. */
1.2083 + idx1 += GetVarint( aKey1+idx1, serial_type1 );
1.2084 + if( d1>=nKey1 && sqlite3VdbeSerialTypeLen(serial_type1)>0 ) break;
1.2085 + idx2 += GetVarint( aKey2+idx2, serial_type2 );
1.2086 + if( d2>=nKey2 && sqlite3VdbeSerialTypeLen(serial_type2)>0 ) break;
1.2087 +
1.2088 + /* Extract the values to be compared.
1.2089 + */
1.2090 + d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1);
1.2091 + d2 += sqlite3VdbeSerialGet(&aKey2[d2], serial_type2, &mem2);
1.2092 +
1.2093 + /* Do the comparison
1.2094 + */
1.2095 + rc = sqlite3MemCompare(&mem1, &mem2, i<nField ? pKeyInfo->aColl[i] : 0);
1.2096 + if( mem1.flags & MEM_Dyn ) sqlite3VdbeMemRelease(&mem1);
1.2097 + if( mem2.flags & MEM_Dyn ) sqlite3VdbeMemRelease(&mem2);
1.2098 + if( rc!=0 ){
1.2099 + break;
1.2100 + }
1.2101 + i++;
1.2102 + }
1.2103 +
1.2104 + /* One of the keys ran out of fields, but all the fields up to that point
1.2105 + ** were equal. If the incrKey flag is true, then the second key is
1.2106 + ** treated as larger.
1.2107 + */
1.2108 + if( rc==0 ){
1.2109 + if( pKeyInfo->incrKey ){
1.2110 + rc = -1;
1.2111 + }else if( d1<nKey1 ){
1.2112 + rc = 1;
1.2113 + }else if( d2<nKey2 ){
1.2114 + rc = -1;
1.2115 + }
1.2116 + }else if( pKeyInfo->aSortOrder && i<pKeyInfo->nField
1.2117 + && pKeyInfo->aSortOrder[i] ){
1.2118 + rc = -rc;
1.2119 + }
1.2120 +
1.2121 + return rc;
1.2122 +}
1.2123 +
1.2124 +/*
1.2125 +** The argument is an index entry composed using the OP_MakeRecord opcode.
1.2126 +** The last entry in this record should be an integer (specifically
1.2127 +** an integer rowid). This routine returns the number of bytes in
1.2128 +** that integer.
1.2129 +*/
1.2130 +int sqlite3VdbeIdxRowidLen(const u8 *aKey){
1.2131 + u32 szHdr; /* Size of the header */
1.2132 + u32 typeRowid; /* Serial type of the rowid */
1.2133 +
1.2134 + sqlite3GetVarint32(aKey, &szHdr);
1.2135 + sqlite3GetVarint32(&aKey[szHdr-1], &typeRowid);
1.2136 + return sqlite3VdbeSerialTypeLen(typeRowid);
1.2137 +}
1.2138 +
1.2139 +
1.2140 +/*
1.2141 +** pCur points at an index entry created using the OP_MakeRecord opcode.
1.2142 +** Read the rowid (the last field in the record) and store it in *rowid.
1.2143 +** Return SQLITE_OK if everything works, or an error code otherwise.
1.2144 +*/
1.2145 +int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){
1.2146 + i64 nCellKey = 0;
1.2147 + int rc;
1.2148 + u32 szHdr; /* Size of the header */
1.2149 + u32 typeRowid; /* Serial type of the rowid */
1.2150 + u32 lenRowid; /* Size of the rowid */
1.2151 + Mem m, v;
1.2152 +
1.2153 + sqlite3BtreeKeySize(pCur, &nCellKey);
1.2154 + if( nCellKey<=0 ){
1.2155 + return SQLITE_CORRUPT_BKPT;
1.2156 + }
1.2157 + rc = sqlite3VdbeMemFromBtree(pCur, 0, nCellKey, 1, &m);
1.2158 + if( rc ){
1.2159 + return rc;
1.2160 + }
1.2161 + sqlite3GetVarint32((u8*)m.z, &szHdr);
1.2162 + sqlite3GetVarint32((u8*)&m.z[szHdr-1], &typeRowid);
1.2163 + lenRowid = sqlite3VdbeSerialTypeLen(typeRowid);
1.2164 + sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
1.2165 + *rowid = v.u.i;
1.2166 + sqlite3VdbeMemRelease(&m);
1.2167 + return SQLITE_OK;
1.2168 +}
1.2169 +
1.2170 +/*
1.2171 +** Compare the key of the index entry that cursor pC is point to against
1.2172 +** the key string in pKey (of length nKey). Write into *pRes a number
1.2173 +** that is negative, zero, or positive if pC is less than, equal to,
1.2174 +** or greater than pKey. Return SQLITE_OK on success.
1.2175 +**
1.2176 +** pKey is either created without a rowid or is truncated so that it
1.2177 +** omits the rowid at the end. The rowid at the end of the index entry
1.2178 +** is ignored as well.
1.2179 +*/
1.2180 +int sqlite3VdbeIdxKeyCompare(
1.2181 + Cursor *pC, /* The cursor to compare against */
1.2182 + int nKey, const u8 *pKey, /* The key to compare */
1.2183 + int *res /* Write the comparison result here */
1.2184 +){
1.2185 + i64 nCellKey = 0;
1.2186 + int rc;
1.2187 + BtCursor *pCur = pC->pCursor;
1.2188 + int lenRowid;
1.2189 + Mem m;
1.2190 +
1.2191 + sqlite3BtreeKeySize(pCur, &nCellKey);
1.2192 + if( nCellKey<=0 ){
1.2193 + *res = 0;
1.2194 + return SQLITE_OK;
1.2195 + }
1.2196 + rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, nCellKey, 1, &m);
1.2197 + if( rc ){
1.2198 + return rc;
1.2199 + }
1.2200 + lenRowid = sqlite3VdbeIdxRowidLen((u8*)m.z);
1.2201 + *res = sqlite3VdbeRecordCompare(pC->pKeyInfo, m.n-lenRowid, m.z, nKey, pKey);
1.2202 + sqlite3VdbeMemRelease(&m);
1.2203 + return SQLITE_OK;
1.2204 +}
1.2205 +
1.2206 +/*
1.2207 +** This routine sets the value to be returned by subsequent calls to
1.2208 +** sqlite3_changes() on the database handle 'db'.
1.2209 +*/
1.2210 +void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){
1.2211 + assert( sqlite3_mutex_held(db->mutex) );
1.2212 + db->nChange = nChange;
1.2213 + db->nTotalChange += nChange;
1.2214 +}
1.2215 +
1.2216 +/*
1.2217 +** Set a flag in the vdbe to update the change counter when it is finalised
1.2218 +** or reset.
1.2219 +*/
1.2220 +void sqlite3VdbeCountChanges(Vdbe *v){
1.2221 + v->changeCntOn = 1;
1.2222 +}
1.2223 +
1.2224 +/*
1.2225 +** Mark every prepared statement associated with a database connection
1.2226 +** as expired.
1.2227 +**
1.2228 +** An expired statement means that recompilation of the statement is
1.2229 +** recommend. Statements expire when things happen that make their
1.2230 +** programs obsolete. Removing user-defined functions or collating
1.2231 +** sequences, or changing an authorization function are the types of
1.2232 +** things that make prepared statements obsolete.
1.2233 +*/
1.2234 +void sqlite3ExpirePreparedStatements(sqlite3 *db){
1.2235 + Vdbe *p;
1.2236 + for(p = db->pVdbe; p; p=p->pNext){
1.2237 + p->expired = 1;
1.2238 + }
1.2239 +}
1.2240 +
1.2241 +/*
1.2242 +** Return the database associated with the Vdbe.
1.2243 +*/
1.2244 +sqlite3 *sqlite3VdbeDb(Vdbe *v){
1.2245 + return v->db;
1.2246 +}
