000001 /*
000002 ** 2003 September 6
000003 **
000004 ** The author disclaims copyright to this source code. In place of
000005 ** a legal notice, here is a blessing:
000006 **
000007 ** May you do good and not evil.
000008 ** May you find forgiveness for yourself and forgive others.
000009 ** May you share freely, never taking more than you give.
000010 **
000011 *************************************************************************
000012 ** This file contains code used for creating, destroying, and populating
000013 ** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.)
000014 */
000015 #include "sqliteInt.h"
000016 #include "vdbeInt.h"
000017
000018 /* Forward references */
000019 static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef);
000020 static void vdbeFreeOpArray(sqlite3 *, Op *, int);
000021
000022 /*
000023 ** Create a new virtual database engine.
000024 */
000025 Vdbe *sqlite3VdbeCreate(Parse *pParse){
000026 sqlite3 *db = pParse->db;
000027 Vdbe *p;
000028 p = sqlite3DbMallocRawNN(db, sizeof(Vdbe) );
000029 if( p==0 ) return 0;
000030 memset(&p->aOp, 0, sizeof(Vdbe)-offsetof(Vdbe,aOp));
000031 p->db = db;
000032 if( db->pVdbe ){
000033 db->pVdbe->pPrev = p;
000034 }
000035 p->pNext = db->pVdbe;
000036 p->pPrev = 0;
000037 db->pVdbe = p;
000038 p->magic = VDBE_MAGIC_INIT;
000039 p->pParse = pParse;
000040 pParse->pVdbe = p;
000041 assert( pParse->aLabel==0 );
000042 assert( pParse->nLabel==0 );
000043 assert( p->nOpAlloc==0 );
000044 assert( pParse->szOpAlloc==0 );
000045 sqlite3VdbeAddOp2(p, OP_Init, 0, 1);
000046 return p;
000047 }
000048
000049 /*
000050 ** Return the Parse object that owns a Vdbe object.
000051 */
000052 Parse *sqlite3VdbeParser(Vdbe *p){
000053 return p->pParse;
000054 }
000055
000056 /*
000057 ** Change the error string stored in Vdbe.zErrMsg
000058 */
000059 void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){
000060 va_list ap;
000061 sqlite3DbFree(p->db, p->zErrMsg);
000062 va_start(ap, zFormat);
000063 p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap);
000064 va_end(ap);
000065 }
000066
000067 /*
000068 ** Remember the SQL string for a prepared statement.
000069 */
000070 void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlags){
000071 if( p==0 ) return;
000072 p->prepFlags = prepFlags;
000073 if( (prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
000074 p->expmask = 0;
000075 }
000076 assert( p->zSql==0 );
000077 p->zSql = sqlite3DbStrNDup(p->db, z, n);
000078 }
000079
000080 #ifdef SQLITE_ENABLE_NORMALIZE
000081 /*
000082 ** Add a new element to the Vdbe->pDblStr list.
000083 */
000084 void sqlite3VdbeAddDblquoteStr(sqlite3 *db, Vdbe *p, const char *z){
000085 if( p ){
000086 int n = sqlite3Strlen30(z);
000087 DblquoteStr *pStr = sqlite3DbMallocRawNN(db,
000088 sizeof(*pStr)+n+1-sizeof(pStr->z));
000089 if( pStr ){
000090 pStr->pNextStr = p->pDblStr;
000091 p->pDblStr = pStr;
000092 memcpy(pStr->z, z, n+1);
000093 }
000094 }
000095 }
000096 #endif
000097
000098 #ifdef SQLITE_ENABLE_NORMALIZE
000099 /*
000100 ** zId of length nId is a double-quoted identifier. Check to see if
000101 ** that identifier is really used as a string literal.
000102 */
000103 int sqlite3VdbeUsesDoubleQuotedString(
000104 Vdbe *pVdbe, /* The prepared statement */
000105 const char *zId /* The double-quoted identifier, already dequoted */
000106 ){
000107 DblquoteStr *pStr;
000108 assert( zId!=0 );
000109 if( pVdbe->pDblStr==0 ) return 0;
000110 for(pStr=pVdbe->pDblStr; pStr; pStr=pStr->pNextStr){
000111 if( strcmp(zId, pStr->z)==0 ) return 1;
000112 }
000113 return 0;
000114 }
000115 #endif
000116
000117 /*
000118 ** Swap all content between two VDBE structures.
000119 */
000120 void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
000121 Vdbe tmp, *pTmp;
000122 char *zTmp;
000123 assert( pA->db==pB->db );
000124 tmp = *pA;
000125 *pA = *pB;
000126 *pB = tmp;
000127 pTmp = pA->pNext;
000128 pA->pNext = pB->pNext;
000129 pB->pNext = pTmp;
000130 pTmp = pA->pPrev;
000131 pA->pPrev = pB->pPrev;
000132 pB->pPrev = pTmp;
000133 zTmp = pA->zSql;
000134 pA->zSql = pB->zSql;
000135 pB->zSql = zTmp;
000136 #ifdef SQLITE_ENABLE_NORMALIZE
000137 zTmp = pA->zNormSql;
000138 pA->zNormSql = pB->zNormSql;
000139 pB->zNormSql = zTmp;
000140 #endif
000141 pB->expmask = pA->expmask;
000142 pB->prepFlags = pA->prepFlags;
000143 memcpy(pB->aCounter, pA->aCounter, sizeof(pB->aCounter));
000144 pB->aCounter[SQLITE_STMTSTATUS_REPREPARE]++;
000145 }
000146
000147 /*
000148 ** Resize the Vdbe.aOp array so that it is at least nOp elements larger
000149 ** than its current size. nOp is guaranteed to be less than or equal
000150 ** to 1024/sizeof(Op).
000151 **
000152 ** If an out-of-memory error occurs while resizing the array, return
000153 ** SQLITE_NOMEM. In this case Vdbe.aOp and Vdbe.nOpAlloc remain
000154 ** unchanged (this is so that any opcodes already allocated can be
000155 ** correctly deallocated along with the rest of the Vdbe).
000156 */
000157 static int growOpArray(Vdbe *v, int nOp){
000158 VdbeOp *pNew;
000159 Parse *p = v->pParse;
000160
000161 /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
000162 ** more frequent reallocs and hence provide more opportunities for
000163 ** simulated OOM faults. SQLITE_TEST_REALLOC_STRESS is generally used
000164 ** during testing only. With SQLITE_TEST_REALLOC_STRESS grow the op array
000165 ** by the minimum* amount required until the size reaches 512. Normal
000166 ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
000167 ** size of the op array or add 1KB of space, whichever is smaller. */
000168 #ifdef SQLITE_TEST_REALLOC_STRESS
000169 sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
000170 : (sqlite3_int64)v->nOpAlloc+nOp);
000171 #else
000172 sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
000173 : (sqlite3_int64)(1024/sizeof(Op)));
000174 UNUSED_PARAMETER(nOp);
000175 #endif
000176
000177 /* Ensure that the size of a VDBE does not grow too large */
000178 if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
000179 sqlite3OomFault(p->db);
000180 return SQLITE_NOMEM;
000181 }
000182
000183 assert( nOp<=(1024/sizeof(Op)) );
000184 assert( nNew>=(v->nOpAlloc+nOp) );
000185 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
000186 if( pNew ){
000187 p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew);
000188 v->nOpAlloc = p->szOpAlloc/sizeof(Op);
000189 v->aOp = pNew;
000190 }
000191 return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT);
000192 }
000193
000194 #ifdef SQLITE_DEBUG
000195 /* This routine is just a convenient place to set a breakpoint that will
000196 ** fire after each opcode is inserted and displayed using
000197 ** "PRAGMA vdbe_addoptrace=on".
000198 */
000199 static void test_addop_breakpoint(void){
000200 static int n = 0;
000201 n++;
000202 }
000203 #endif
000204
000205 /*
000206 ** Add a new instruction to the list of instructions current in the
000207 ** VDBE. Return the address of the new instruction.
000208 **
000209 ** Parameters:
000210 **
000211 ** p Pointer to the VDBE
000212 **
000213 ** op The opcode for this instruction
000214 **
000215 ** p1, p2, p3 Operands
000216 **
000217 ** Use the sqlite3VdbeResolveLabel() function to fix an address and
000218 ** the sqlite3VdbeChangeP4() function to change the value of the P4
000219 ** operand.
000220 */
000221 static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){
000222 assert( p->nOpAlloc<=p->nOp );
000223 if( growOpArray(p, 1) ) return 1;
000224 assert( p->nOpAlloc>p->nOp );
000225 return sqlite3VdbeAddOp3(p, op, p1, p2, p3);
000226 }
000227 int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
000228 int i;
000229 VdbeOp *pOp;
000230
000231 i = p->nOp;
000232 assert( p->magic==VDBE_MAGIC_INIT );
000233 assert( op>=0 && op<0xff );
000234 if( p->nOpAlloc<=i ){
000235 return growOp3(p, op, p1, p2, p3);
000236 }
000237 p->nOp++;
000238 pOp = &p->aOp[i];
000239 pOp->opcode = (u8)op;
000240 pOp->p5 = 0;
000241 pOp->p1 = p1;
000242 pOp->p2 = p2;
000243 pOp->p3 = p3;
000244 pOp->p4.p = 0;
000245 pOp->p4type = P4_NOTUSED;
000246 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
000247 pOp->zComment = 0;
000248 #endif
000249 #ifdef SQLITE_DEBUG
000250 if( p->db->flags & SQLITE_VdbeAddopTrace ){
000251 sqlite3VdbePrintOp(0, i, &p->aOp[i]);
000252 test_addop_breakpoint();
000253 }
000254 #endif
000255 #ifdef VDBE_PROFILE
000256 pOp->cycles = 0;
000257 pOp->cnt = 0;
000258 #endif
000259 #ifdef SQLITE_VDBE_COVERAGE
000260 pOp->iSrcLine = 0;
000261 #endif
000262 return i;
000263 }
000264 int sqlite3VdbeAddOp0(Vdbe *p, int op){
000265 return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
000266 }
000267 int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
000268 return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
000269 }
000270 int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
000271 return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
000272 }
000273
000274 /* Generate code for an unconditional jump to instruction iDest
000275 */
000276 int sqlite3VdbeGoto(Vdbe *p, int iDest){
000277 return sqlite3VdbeAddOp3(p, OP_Goto, 0, iDest, 0);
000278 }
000279
000280 /* Generate code to cause the string zStr to be loaded into
000281 ** register iDest
000282 */
000283 int sqlite3VdbeLoadString(Vdbe *p, int iDest, const char *zStr){
000284 return sqlite3VdbeAddOp4(p, OP_String8, 0, iDest, 0, zStr, 0);
000285 }
000286
000287 /*
000288 ** Generate code that initializes multiple registers to string or integer
000289 ** constants. The registers begin with iDest and increase consecutively.
000290 ** One register is initialized for each characgter in zTypes[]. For each
000291 ** "s" character in zTypes[], the register is a string if the argument is
000292 ** not NULL, or OP_Null if the value is a null pointer. For each "i" character
000293 ** in zTypes[], the register is initialized to an integer.
000294 **
000295 ** If the input string does not end with "X" then an OP_ResultRow instruction
000296 ** is generated for the values inserted.
000297 */
000298 void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes, ...){
000299 va_list ap;
000300 int i;
000301 char c;
000302 va_start(ap, zTypes);
000303 for(i=0; (c = zTypes[i])!=0; i++){
000304 if( c=='s' ){
000305 const char *z = va_arg(ap, const char*);
000306 sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest+i, 0, z, 0);
000307 }else if( c=='i' ){
000308 sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest+i);
000309 }else{
000310 goto skip_op_resultrow;
000311 }
000312 }
000313 sqlite3VdbeAddOp2(p, OP_ResultRow, iDest, i);
000314 skip_op_resultrow:
000315 va_end(ap);
000316 }
000317
000318 /*
000319 ** Add an opcode that includes the p4 value as a pointer.
000320 */
000321 int sqlite3VdbeAddOp4(
000322 Vdbe *p, /* Add the opcode to this VM */
000323 int op, /* The new opcode */
000324 int p1, /* The P1 operand */
000325 int p2, /* The P2 operand */
000326 int p3, /* The P3 operand */
000327 const char *zP4, /* The P4 operand */
000328 int p4type /* P4 operand type */
000329 ){
000330 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
000331 sqlite3VdbeChangeP4(p, addr, zP4, p4type);
000332 return addr;
000333 }
000334
000335 /*
000336 ** Add an OP_Function or OP_PureFunc opcode.
000337 **
000338 ** The eCallCtx argument is information (typically taken from Expr.op2)
000339 ** that describes the calling context of the function. 0 means a general
000340 ** function call. NC_IsCheck means called by a check constraint,
000341 ** NC_IdxExpr means called as part of an index expression. NC_PartIdx
000342 ** means in the WHERE clause of a partial index. NC_GenCol means called
000343 ** while computing a generated column value. 0 is the usual case.
000344 */
000345 int sqlite3VdbeAddFunctionCall(
000346 Parse *pParse, /* Parsing context */
000347 int p1, /* Constant argument mask */
000348 int p2, /* First argument register */
000349 int p3, /* Register into which results are written */
000350 int nArg, /* Number of argument */
000351 const FuncDef *pFunc, /* The function to be invoked */
000352 int eCallCtx /* Calling context */
000353 ){
000354 Vdbe *v = pParse->pVdbe;
000355 int nByte;
000356 int addr;
000357 sqlite3_context *pCtx;
000358 assert( v );
000359 nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*);
000360 pCtx = sqlite3DbMallocRawNN(pParse->db, nByte);
000361 if( pCtx==0 ){
000362 assert( pParse->db->mallocFailed );
000363 freeEphemeralFunction(pParse->db, (FuncDef*)pFunc);
000364 return 0;
000365 }
000366 pCtx->pOut = 0;
000367 pCtx->pFunc = (FuncDef*)pFunc;
000368 pCtx->pVdbe = 0;
000369 pCtx->isError = 0;
000370 pCtx->argc = nArg;
000371 pCtx->iOp = sqlite3VdbeCurrentAddr(v);
000372 addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function,
000373 p1, p2, p3, (char*)pCtx, P4_FUNCCTX);
000374 sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef);
000375 return addr;
000376 }
000377
000378 /*
000379 ** Add an opcode that includes the p4 value with a P4_INT64 or
000380 ** P4_REAL type.
000381 */
000382 int sqlite3VdbeAddOp4Dup8(
000383 Vdbe *p, /* Add the opcode to this VM */
000384 int op, /* The new opcode */
000385 int p1, /* The P1 operand */
000386 int p2, /* The P2 operand */
000387 int p3, /* The P3 operand */
000388 const u8 *zP4, /* The P4 operand */
000389 int p4type /* P4 operand type */
000390 ){
000391 char *p4copy = sqlite3DbMallocRawNN(sqlite3VdbeDb(p), 8);
000392 if( p4copy ) memcpy(p4copy, zP4, 8);
000393 return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type);
000394 }
000395
000396 #ifndef SQLITE_OMIT_EXPLAIN
000397 /*
000398 ** Return the address of the current EXPLAIN QUERY PLAN baseline.
000399 ** 0 means "none".
000400 */
000401 int sqlite3VdbeExplainParent(Parse *pParse){
000402 VdbeOp *pOp;
000403 if( pParse->addrExplain==0 ) return 0;
000404 pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain);
000405 return pOp->p2;
000406 }
000407
000408 /*
000409 ** Set a debugger breakpoint on the following routine in order to
000410 ** monitor the EXPLAIN QUERY PLAN code generation.
000411 */
000412 #if defined(SQLITE_DEBUG)
000413 void sqlite3ExplainBreakpoint(const char *z1, const char *z2){
000414 (void)z1;
000415 (void)z2;
000416 }
000417 #endif
000418
000419 /*
000420 ** Add a new OP_ opcode.
000421 **
000422 ** If the bPush flag is true, then make this opcode the parent for
000423 ** subsequent Explains until sqlite3VdbeExplainPop() is called.
000424 */
000425 void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){
000426 #ifndef SQLITE_DEBUG
000427 /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined.
000428 ** But omit them (for performance) during production builds */
000429 if( pParse->explain==2 )
000430 #endif
000431 {
000432 char *zMsg;
000433 Vdbe *v;
000434 va_list ap;
000435 int iThis;
000436 va_start(ap, zFmt);
000437 zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap);
000438 va_end(ap);
000439 v = pParse->pVdbe;
000440 iThis = v->nOp;
000441 sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
000442 zMsg, P4_DYNAMIC);
000443 sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetOp(v,-1)->p4.z);
000444 if( bPush){
000445 pParse->addrExplain = iThis;
000446 }
000447 }
000448 }
000449
000450 /*
000451 ** Pop the EXPLAIN QUERY PLAN stack one level.
000452 */
000453 void sqlite3VdbeExplainPop(Parse *pParse){
000454 sqlite3ExplainBreakpoint("POP", 0);
000455 pParse->addrExplain = sqlite3VdbeExplainParent(pParse);
000456 }
000457 #endif /* SQLITE_OMIT_EXPLAIN */
000458
000459 /*
000460 ** Add an OP_ParseSchema opcode. This routine is broken out from
000461 ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
000462 ** as having been used.
000463 **
000464 ** The zWhere string must have been obtained from sqlite3_malloc().
000465 ** This routine will take ownership of the allocated memory.
000466 */
000467 void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
000468 int j;
000469 sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
000470 for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
000471 }
000472
000473 /*
000474 ** Add an opcode that includes the p4 value as an integer.
000475 */
000476 int sqlite3VdbeAddOp4Int(
000477 Vdbe *p, /* Add the opcode to this VM */
000478 int op, /* The new opcode */
000479 int p1, /* The P1 operand */
000480 int p2, /* The P2 operand */
000481 int p3, /* The P3 operand */
000482 int p4 /* The P4 operand as an integer */
000483 ){
000484 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
000485 if( p->db->mallocFailed==0 ){
000486 VdbeOp *pOp = &p->aOp[addr];
000487 pOp->p4type = P4_INT32;
000488 pOp->p4.i = p4;
000489 }
000490 return addr;
000491 }
000492
000493 /* Insert the end of a co-routine
000494 */
000495 void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
000496 sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
000497
000498 /* Clear the temporary register cache, thereby ensuring that each
000499 ** co-routine has its own independent set of registers, because co-routines
000500 ** might expect their registers to be preserved across an OP_Yield, and
000501 ** that could cause problems if two or more co-routines are using the same
000502 ** temporary register.
000503 */
000504 v->pParse->nTempReg = 0;
000505 v->pParse->nRangeReg = 0;
000506 }
000507
000508 /*
000509 ** Create a new symbolic label for an instruction that has yet to be
000510 ** coded. The symbolic label is really just a negative number. The
000511 ** label can be used as the P2 value of an operation. Later, when
000512 ** the label is resolved to a specific address, the VDBE will scan
000513 ** through its operation list and change all values of P2 which match
000514 ** the label into the resolved address.
000515 **
000516 ** The VDBE knows that a P2 value is a label because labels are
000517 ** always negative and P2 values are suppose to be non-negative.
000518 ** Hence, a negative P2 value is a label that has yet to be resolved.
000519 ** (Later:) This is only true for opcodes that have the OPFLG_JUMP
000520 ** property.
000521 **
000522 ** Variable usage notes:
000523 **
000524 ** Parse.aLabel[x] Stores the address that the x-th label resolves
000525 ** into. For testing (SQLITE_DEBUG), unresolved
000526 ** labels stores -1, but that is not required.
000527 ** Parse.nLabelAlloc Number of slots allocated to Parse.aLabel[]
000528 ** Parse.nLabel The *negative* of the number of labels that have
000529 ** been issued. The negative is stored because
000530 ** that gives a performance improvement over storing
000531 ** the equivalent positive value.
000532 */
000533 int sqlite3VdbeMakeLabel(Parse *pParse){
000534 return --pParse->nLabel;
000535 }
000536
000537 /*
000538 ** Resolve label "x" to be the address of the next instruction to
000539 ** be inserted. The parameter "x" must have been obtained from
000540 ** a prior call to sqlite3VdbeMakeLabel().
000541 */
000542 static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){
000543 int nNewSize = 10 - p->nLabel;
000544 p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
000545 nNewSize*sizeof(p->aLabel[0]));
000546 if( p->aLabel==0 ){
000547 p->nLabelAlloc = 0;
000548 }else{
000549 #ifdef SQLITE_DEBUG
000550 int i;
000551 for(i=p->nLabelAlloc; i<nNewSize; i++) p->aLabel[i] = -1;
000552 #endif
000553 p->nLabelAlloc = nNewSize;
000554 p->aLabel[j] = v->nOp;
000555 }
000556 }
000557 void sqlite3VdbeResolveLabel(Vdbe *v, int x){
000558 Parse *p = v->pParse;
000559 int j = ADDR(x);
000560 assert( v->magic==VDBE_MAGIC_INIT );
000561 assert( j<-p->nLabel );
000562 assert( j>=0 );
000563 #ifdef SQLITE_DEBUG
000564 if( p->db->flags & SQLITE_VdbeAddopTrace ){
000565 printf("RESOLVE LABEL %d to %d\n", x, v->nOp);
000566 }
000567 #endif
000568 if( p->nLabelAlloc + p->nLabel < 0 ){
000569 resizeResolveLabel(p,v,j);
000570 }else{
000571 assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */
000572 p->aLabel[j] = v->nOp;
000573 }
000574 }
000575
000576 /*
000577 ** Mark the VDBE as one that can only be run one time.
000578 */
000579 void sqlite3VdbeRunOnlyOnce(Vdbe *p){
000580 p->runOnlyOnce = 1;
000581 }
000582
000583 /*
000584 ** Mark the VDBE as one that can only be run multiple times.
000585 */
000586 void sqlite3VdbeReusable(Vdbe *p){
000587 p->runOnlyOnce = 0;
000588 }
000589
000590 #ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */
000591
000592 /*
000593 ** The following type and function are used to iterate through all opcodes
000594 ** in a Vdbe main program and each of the sub-programs (triggers) it may
000595 ** invoke directly or indirectly. It should be used as follows:
000596 **
000597 ** Op *pOp;
000598 ** VdbeOpIter sIter;
000599 **
000600 ** memset(&sIter, 0, sizeof(sIter));
000601 ** sIter.v = v; // v is of type Vdbe*
000602 ** while( (pOp = opIterNext(&sIter)) ){
000603 ** // Do something with pOp
000604 ** }
000605 ** sqlite3DbFree(v->db, sIter.apSub);
000606 **
000607 */
000608 typedef struct VdbeOpIter VdbeOpIter;
000609 struct VdbeOpIter {
000610 Vdbe *v; /* Vdbe to iterate through the opcodes of */
000611 SubProgram **apSub; /* Array of subprograms */
000612 int nSub; /* Number of entries in apSub */
000613 int iAddr; /* Address of next instruction to return */
000614 int iSub; /* 0 = main program, 1 = first sub-program etc. */
000615 };
000616 static Op *opIterNext(VdbeOpIter *p){
000617 Vdbe *v = p->v;
000618 Op *pRet = 0;
000619 Op *aOp;
000620 int nOp;
000621
000622 if( p->iSub<=p->nSub ){
000623
000624 if( p->iSub==0 ){
000625 aOp = v->aOp;
000626 nOp = v->nOp;
000627 }else{
000628 aOp = p->apSub[p->iSub-1]->aOp;
000629 nOp = p->apSub[p->iSub-1]->nOp;
000630 }
000631 assert( p->iAddr<nOp );
000632
000633 pRet = &aOp[p->iAddr];
000634 p->iAddr++;
000635 if( p->iAddr==nOp ){
000636 p->iSub++;
000637 p->iAddr = 0;
000638 }
000639
000640 if( pRet->p4type==P4_SUBPROGRAM ){
000641 int nByte = (p->nSub+1)*sizeof(SubProgram*);
000642 int j;
000643 for(j=0; j<p->nSub; j++){
000644 if( p->apSub[j]==pRet->p4.pProgram ) break;
000645 }
000646 if( j==p->nSub ){
000647 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
000648 if( !p->apSub ){
000649 pRet = 0;
000650 }else{
000651 p->apSub[p->nSub++] = pRet->p4.pProgram;
000652 }
000653 }
000654 }
000655 }
000656
000657 return pRet;
000658 }
000659
000660 /*
000661 ** Check if the program stored in the VM associated with pParse may
000662 ** throw an ABORT exception (causing the statement, but not entire transaction
000663 ** to be rolled back). This condition is true if the main program or any
000664 ** sub-programs contains any of the following:
000665 **
000666 ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
000667 ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
000668 ** * OP_Destroy
000669 ** * OP_VUpdate
000670 ** * OP_VCreate
000671 ** * OP_VRename
000672 ** * OP_FkCounter with P2==0 (immediate foreign key constraint)
000673 ** * OP_CreateBtree/BTREE_INTKEY and OP_InitCoroutine
000674 ** (for CREATE TABLE AS SELECT ...)
000675 **
000676 ** Then check that the value of Parse.mayAbort is true if an
000677 ** ABORT may be thrown, or false otherwise. Return true if it does
000678 ** match, or false otherwise. This function is intended to be used as
000679 ** part of an assert statement in the compiler. Similar to:
000680 **
000681 ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
000682 */
000683 int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
000684 int hasAbort = 0;
000685 int hasFkCounter = 0;
000686 int hasCreateTable = 0;
000687 int hasCreateIndex = 0;
000688 int hasInitCoroutine = 0;
000689 Op *pOp;
000690 VdbeOpIter sIter;
000691 memset(&sIter, 0, sizeof(sIter));
000692 sIter.v = v;
000693
000694 while( (pOp = opIterNext(&sIter))!=0 ){
000695 int opcode = pOp->opcode;
000696 if( opcode==OP_Destroy || opcode==OP_VUpdate || opcode==OP_VRename
000697 || opcode==OP_VDestroy
000698 || opcode==OP_VCreate
000699 || (opcode==OP_ParseSchema && pOp->p4.z==0)
000700 || ((opcode==OP_Halt || opcode==OP_HaltIfNull)
000701 && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort))
000702 ){
000703 hasAbort = 1;
000704 break;
000705 }
000706 if( opcode==OP_CreateBtree && pOp->p3==BTREE_INTKEY ) hasCreateTable = 1;
000707 if( mayAbort ){
000708 /* hasCreateIndex may also be set for some DELETE statements that use
000709 ** OP_Clear. So this routine may end up returning true in the case
000710 ** where a "DELETE FROM tbl" has a statement-journal but does not
000711 ** require one. This is not so bad - it is an inefficiency, not a bug. */
000712 if( opcode==OP_CreateBtree && pOp->p3==BTREE_BLOBKEY ) hasCreateIndex = 1;
000713 if( opcode==OP_Clear ) hasCreateIndex = 1;
000714 }
000715 if( opcode==OP_InitCoroutine ) hasInitCoroutine = 1;
000716 #ifndef SQLITE_OMIT_FOREIGN_KEY
000717 if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){
000718 hasFkCounter = 1;
000719 }
000720 #endif
000721 }
000722 sqlite3DbFree(v->db, sIter.apSub);
000723
000724 /* Return true if hasAbort==mayAbort. Or if a malloc failure occurred.
000725 ** If malloc failed, then the while() loop above may not have iterated
000726 ** through all opcodes and hasAbort may be set incorrectly. Return
000727 ** true for this case to prevent the assert() in the callers frame
000728 ** from failing. */
000729 return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter
000730 || (hasCreateTable && hasInitCoroutine) || hasCreateIndex
000731 );
000732 }
000733 #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */
000734
000735 #ifdef SQLITE_DEBUG
000736 /*
000737 ** Increment the nWrite counter in the VDBE if the cursor is not an
000738 ** ephemeral cursor, or if the cursor argument is NULL.
000739 */
000740 void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){
000741 if( pC==0
000742 || (pC->eCurType!=CURTYPE_SORTER
000743 && pC->eCurType!=CURTYPE_PSEUDO
000744 && !pC->isEphemeral)
000745 ){
000746 p->nWrite++;
000747 }
000748 }
000749 #endif
000750
000751 #ifdef SQLITE_DEBUG
000752 /*
000753 ** Assert if an Abort at this point in time might result in a corrupt
000754 ** database.
000755 */
000756 void sqlite3VdbeAssertAbortable(Vdbe *p){
000757 assert( p->nWrite==0 || p->usesStmtJournal );
000758 }
000759 #endif
000760
000761 /*
000762 ** This routine is called after all opcodes have been inserted. It loops
000763 ** through all the opcodes and fixes up some details.
000764 **
000765 ** (1) For each jump instruction with a negative P2 value (a label)
000766 ** resolve the P2 value to an actual address.
000767 **
000768 ** (2) Compute the maximum number of arguments used by any SQL function
000769 ** and store that value in *pMaxFuncArgs.
000770 **
000771 ** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately
000772 ** indicate what the prepared statement actually does.
000773 **
000774 ** (4) Initialize the p4.xAdvance pointer on opcodes that use it.
000775 **
000776 ** (5) Reclaim the memory allocated for storing labels.
000777 **
000778 ** This routine will only function correctly if the mkopcodeh.tcl generator
000779 ** script numbers the opcodes correctly. Changes to this routine must be
000780 ** coordinated with changes to mkopcodeh.tcl.
000781 */
000782 static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
000783 int nMaxArgs = *pMaxFuncArgs;
000784 Op *pOp;
000785 Parse *pParse = p->pParse;
000786 int *aLabel = pParse->aLabel;
000787 p->readOnly = 1;
000788 p->bIsReader = 0;
000789 pOp = &p->aOp[p->nOp-1];
000790 while(1){
000791
000792 /* Only JUMP opcodes and the short list of special opcodes in the switch
000793 ** below need to be considered. The mkopcodeh.tcl generator script groups
000794 ** all these opcodes together near the front of the opcode list. Skip
000795 ** any opcode that does not need processing by virtual of the fact that
000796 ** it is larger than SQLITE_MX_JUMP_OPCODE, as a performance optimization.
000797 */
000798 if( pOp->opcode<=SQLITE_MX_JUMP_OPCODE ){
000799 /* NOTE: Be sure to update mkopcodeh.tcl when adding or removing
000800 ** cases from this switch! */
000801 switch( pOp->opcode ){
000802 case OP_Transaction: {
000803 if( pOp->p2!=0 ) p->readOnly = 0;
000804 /* fall thru */
000805 }
000806 case OP_AutoCommit:
000807 case OP_Savepoint: {
000808 p->bIsReader = 1;
000809 break;
000810 }
000811 #ifndef SQLITE_OMIT_WAL
000812 case OP_Checkpoint:
000813 #endif
000814 case OP_Vacuum:
000815 case OP_JournalMode: {
000816 p->readOnly = 0;
000817 p->bIsReader = 1;
000818 break;
000819 }
000820 case OP_Next:
000821 case OP_SorterNext: {
000822 pOp->p4.xAdvance = sqlite3BtreeNext;
000823 pOp->p4type = P4_ADVANCE;
000824 /* The code generator never codes any of these opcodes as a jump
000825 ** to a label. They are always coded as a jump backwards to a
000826 ** known address */
000827 assert( pOp->p2>=0 );
000828 break;
000829 }
000830 case OP_Prev: {
000831 pOp->p4.xAdvance = sqlite3BtreePrevious;
000832 pOp->p4type = P4_ADVANCE;
000833 /* The code generator never codes any of these opcodes as a jump
000834 ** to a label. They are always coded as a jump backwards to a
000835 ** known address */
000836 assert( pOp->p2>=0 );
000837 break;
000838 }
000839 #ifndef SQLITE_OMIT_VIRTUALTABLE
000840 case OP_VUpdate: {
000841 if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
000842 break;
000843 }
000844 case OP_VFilter: {
000845 int n;
000846 assert( (pOp - p->aOp) >= 3 );
000847 assert( pOp[-1].opcode==OP_Integer );
000848 n = pOp[-1].p1;
000849 if( n>nMaxArgs ) nMaxArgs = n;
000850 /* Fall through into the default case */
000851 }
000852 #endif
000853 default: {
000854 if( pOp->p2<0 ){
000855 /* The mkopcodeh.tcl script has so arranged things that the only
000856 ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
000857 ** have non-negative values for P2. */
000858 assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 );
000859 assert( ADDR(pOp->p2)<-pParse->nLabel );
000860 pOp->p2 = aLabel[ADDR(pOp->p2)];
000861 }
000862 break;
000863 }
000864 }
000865 /* The mkopcodeh.tcl script has so arranged things that the only
000866 ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
000867 ** have non-negative values for P2. */
000868 assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0);
000869 }
000870 if( pOp==p->aOp ) break;
000871 pOp--;
000872 }
000873 sqlite3DbFree(p->db, pParse->aLabel);
000874 pParse->aLabel = 0;
000875 pParse->nLabel = 0;
000876 *pMaxFuncArgs = nMaxArgs;
000877 assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) );
000878 }
000879
000880 /*
000881 ** Return the address of the next instruction to be inserted.
000882 */
000883 int sqlite3VdbeCurrentAddr(Vdbe *p){
000884 assert( p->magic==VDBE_MAGIC_INIT );
000885 return p->nOp;
000886 }
000887
000888 /*
000889 ** Verify that at least N opcode slots are available in p without
000890 ** having to malloc for more space (except when compiled using
000891 ** SQLITE_TEST_REALLOC_STRESS). This interface is used during testing
000892 ** to verify that certain calls to sqlite3VdbeAddOpList() can never
000893 ** fail due to a OOM fault and hence that the return value from
000894 ** sqlite3VdbeAddOpList() will always be non-NULL.
000895 */
000896 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
000897 void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N){
000898 assert( p->nOp + N <= p->nOpAlloc );
000899 }
000900 #endif
000901
000902 /*
000903 ** Verify that the VM passed as the only argument does not contain
000904 ** an OP_ResultRow opcode. Fail an assert() if it does. This is used
000905 ** by code in pragma.c to ensure that the implementation of certain
000906 ** pragmas comports with the flags specified in the mkpragmatab.tcl
000907 ** script.
000908 */
000909 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
000910 void sqlite3VdbeVerifyNoResultRow(Vdbe *p){
000911 int i;
000912 for(i=0; i<p->nOp; i++){
000913 assert( p->aOp[i].opcode!=OP_ResultRow );
000914 }
000915 }
000916 #endif
000917
000918 /*
000919 ** Generate code (a single OP_Abortable opcode) that will
000920 ** verify that the VDBE program can safely call Abort in the current
000921 ** context.
000922 */
000923 #if defined(SQLITE_DEBUG)
000924 void sqlite3VdbeVerifyAbortable(Vdbe *p, int onError){
000925 if( onError==OE_Abort ) sqlite3VdbeAddOp0(p, OP_Abortable);
000926 }
000927 #endif
000928
000929 /*
000930 ** This function returns a pointer to the array of opcodes associated with
000931 ** the Vdbe passed as the first argument. It is the callers responsibility
000932 ** to arrange for the returned array to be eventually freed using the
000933 ** vdbeFreeOpArray() function.
000934 **
000935 ** Before returning, *pnOp is set to the number of entries in the returned
000936 ** array. Also, *pnMaxArg is set to the larger of its current value and
000937 ** the number of entries in the Vdbe.apArg[] array required to execute the
000938 ** returned program.
000939 */
000940 VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){
000941 VdbeOp *aOp = p->aOp;
000942 assert( aOp && !p->db->mallocFailed );
000943
000944 /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
000945 assert( DbMaskAllZero(p->btreeMask) );
000946
000947 resolveP2Values(p, pnMaxArg);
000948 *pnOp = p->nOp;
000949 p->aOp = 0;
000950 return aOp;
000951 }
000952
000953 /*
000954 ** Add a whole list of operations to the operation stack. Return a
000955 ** pointer to the first operation inserted.
000956 **
000957 ** Non-zero P2 arguments to jump instructions are automatically adjusted
000958 ** so that the jump target is relative to the first operation inserted.
000959 */
000960 VdbeOp *sqlite3VdbeAddOpList(
000961 Vdbe *p, /* Add opcodes to the prepared statement */
000962 int nOp, /* Number of opcodes to add */
000963 VdbeOpList const *aOp, /* The opcodes to be added */
000964 int iLineno /* Source-file line number of first opcode */
000965 ){
000966 int i;
000967 VdbeOp *pOut, *pFirst;
000968 assert( nOp>0 );
000969 assert( p->magic==VDBE_MAGIC_INIT );
000970 if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){
000971 return 0;
000972 }
000973 pFirst = pOut = &p->aOp[p->nOp];
000974 for(i=0; i<nOp; i++, aOp++, pOut++){
000975 pOut->opcode = aOp->opcode;
000976 pOut->p1 = aOp->p1;
000977 pOut->p2 = aOp->p2;
000978 assert( aOp->p2>=0 );
000979 if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){
000980 pOut->p2 += p->nOp;
000981 }
000982 pOut->p3 = aOp->p3;
000983 pOut->p4type = P4_NOTUSED;
000984 pOut->p4.p = 0;
000985 pOut->p5 = 0;
000986 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
000987 pOut->zComment = 0;
000988 #endif
000989 #ifdef SQLITE_VDBE_COVERAGE
000990 pOut->iSrcLine = iLineno+i;
000991 #else
000992 (void)iLineno;
000993 #endif
000994 #ifdef SQLITE_DEBUG
000995 if( p->db->flags & SQLITE_VdbeAddopTrace ){
000996 sqlite3VdbePrintOp(0, i+p->nOp, &p->aOp[i+p->nOp]);
000997 }
000998 #endif
000999 }
001000 p->nOp += nOp;
001001 return pFirst;
001002 }
001003
001004 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS)
001005 /*
001006 ** Add an entry to the array of counters managed by sqlite3_stmt_scanstatus().
001007 */
001008 void sqlite3VdbeScanStatus(
001009 Vdbe *p, /* VM to add scanstatus() to */
001010 int addrExplain, /* Address of OP_Explain (or 0) */
001011 int addrLoop, /* Address of loop counter */
001012 int addrVisit, /* Address of rows visited counter */
001013 LogEst nEst, /* Estimated number of output rows */
001014 const char *zName /* Name of table or index being scanned */
001015 ){
001016 sqlite3_int64 nByte = (p->nScan+1) * sizeof(ScanStatus);
001017 ScanStatus *aNew;
001018 aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte);
001019 if( aNew ){
001020 ScanStatus *pNew = &aNew[p->nScan++];
001021 pNew->addrExplain = addrExplain;
001022 pNew->addrLoop = addrLoop;
001023 pNew->addrVisit = addrVisit;
001024 pNew->nEst = nEst;
001025 pNew->zName = sqlite3DbStrDup(p->db, zName);
001026 p->aScan = aNew;
001027 }
001028 }
001029 #endif
001030
001031
001032 /*
001033 ** Change the value of the opcode, or P1, P2, P3, or P5 operands
001034 ** for a specific instruction.
001035 */
001036 void sqlite3VdbeChangeOpcode(Vdbe *p, int addr, u8 iNewOpcode){
001037 sqlite3VdbeGetOp(p,addr)->opcode = iNewOpcode;
001038 }
001039 void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){
001040 sqlite3VdbeGetOp(p,addr)->p1 = val;
001041 }
001042 void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){
001043 sqlite3VdbeGetOp(p,addr)->p2 = val;
001044 }
001045 void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){
001046 sqlite3VdbeGetOp(p,addr)->p3 = val;
001047 }
001048 void sqlite3VdbeChangeP5(Vdbe *p, u16 p5){
001049 assert( p->nOp>0 || p->db->mallocFailed );
001050 if( p->nOp>0 ) p->aOp[p->nOp-1].p5 = p5;
001051 }
001052
001053 /*
001054 ** Change the P2 operand of instruction addr so that it points to
001055 ** the address of the next instruction to be coded.
001056 */
001057 void sqlite3VdbeJumpHere(Vdbe *p, int addr){
001058 sqlite3VdbeChangeP2(p, addr, p->nOp);
001059 }
001060
001061
001062 /*
001063 ** If the input FuncDef structure is ephemeral, then free it. If
001064 ** the FuncDef is not ephermal, then do nothing.
001065 */
001066 static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){
001067 if( (pDef->funcFlags & SQLITE_FUNC_EPHEM)!=0 ){
001068 sqlite3DbFreeNN(db, pDef);
001069 }
001070 }
001071
001072 /*
001073 ** Delete a P4 value if necessary.
001074 */
001075 static SQLITE_NOINLINE void freeP4Mem(sqlite3 *db, Mem *p){
001076 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
001077 sqlite3DbFreeNN(db, p);
001078 }
001079 static SQLITE_NOINLINE void freeP4FuncCtx(sqlite3 *db, sqlite3_context *p){
001080 freeEphemeralFunction(db, p->pFunc);
001081 sqlite3DbFreeNN(db, p);
001082 }
001083 static void freeP4(sqlite3 *db, int p4type, void *p4){
001084 assert( db );
001085 switch( p4type ){
001086 case P4_FUNCCTX: {
001087 freeP4FuncCtx(db, (sqlite3_context*)p4);
001088 break;
001089 }
001090 case P4_REAL:
001091 case P4_INT64:
001092 case P4_DYNAMIC:
001093 case P4_DYNBLOB:
001094 case P4_INTARRAY: {
001095 sqlite3DbFree(db, p4);
001096 break;
001097 }
001098 case P4_KEYINFO: {
001099 if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4);
001100 break;
001101 }
001102 #ifdef SQLITE_ENABLE_CURSOR_HINTS
001103 case P4_EXPR: {
001104 sqlite3ExprDelete(db, (Expr*)p4);
001105 break;
001106 }
001107 #endif
001108 case P4_FUNCDEF: {
001109 freeEphemeralFunction(db, (FuncDef*)p4);
001110 break;
001111 }
001112 case P4_MEM: {
001113 if( db->pnBytesFreed==0 ){
001114 sqlite3ValueFree((sqlite3_value*)p4);
001115 }else{
001116 freeP4Mem(db, (Mem*)p4);
001117 }
001118 break;
001119 }
001120 case P4_VTAB : {
001121 if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4);
001122 break;
001123 }
001124 }
001125 }
001126
001127 /*
001128 ** Free the space allocated for aOp and any p4 values allocated for the
001129 ** opcodes contained within. If aOp is not NULL it is assumed to contain
001130 ** nOp entries.
001131 */
001132 static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
001133 if( aOp ){
001134 Op *pOp;
001135 for(pOp=&aOp[nOp-1]; pOp>=aOp; pOp--){
001136 if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p);
001137 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
001138 sqlite3DbFree(db, pOp->zComment);
001139 #endif
001140 }
001141 sqlite3DbFreeNN(db, aOp);
001142 }
001143 }
001144
001145 /*
001146 ** Link the SubProgram object passed as the second argument into the linked
001147 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
001148 ** objects when the VM is no longer required.
001149 */
001150 void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){
001151 p->pNext = pVdbe->pProgram;
001152 pVdbe->pProgram = p;
001153 }
001154
001155 /*
001156 ** Return true if the given Vdbe has any SubPrograms.
001157 */
001158 int sqlite3VdbeHasSubProgram(Vdbe *pVdbe){
001159 return pVdbe->pProgram!=0;
001160 }
001161
001162 /*
001163 ** Change the opcode at addr into OP_Noop
001164 */
001165 int sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
001166 VdbeOp *pOp;
001167 if( p->db->mallocFailed ) return 0;
001168 assert( addr>=0 && addr<p->nOp );
001169 pOp = &p->aOp[addr];
001170 freeP4(p->db, pOp->p4type, pOp->p4.p);
001171 pOp->p4type = P4_NOTUSED;
001172 pOp->p4.z = 0;
001173 pOp->opcode = OP_Noop;
001174 return 1;
001175 }
001176
001177 /*
001178 ** If the last opcode is "op" and it is not a jump destination,
001179 ** then remove it. Return true if and only if an opcode was removed.
001180 */
001181 int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){
001182 if( p->nOp>0 && p->aOp[p->nOp-1].opcode==op ){
001183 return sqlite3VdbeChangeToNoop(p, p->nOp-1);
001184 }else{
001185 return 0;
001186 }
001187 }
001188
001189 #ifdef SQLITE_DEBUG
001190 /*
001191 ** Generate an OP_ReleaseReg opcode to indicate that a range of
001192 ** registers, except any identified by mask, are no longer in use.
001193 */
001194 void sqlite3VdbeReleaseRegisters(Parse *pParse, int iFirst, int N, u32 mask){
001195 assert( pParse->pVdbe );
001196 while( N>0 && (mask&1)!=0 ){
001197 mask >>= 1;
001198 iFirst++;
001199 N--;
001200 }
001201 while( N>0 && N<=32 && (mask & MASKBIT32(N-1))!=0 ){
001202 mask &= ~MASKBIT32(N-1);
001203 N--;
001204 }
001205 if( N>0 ){
001206 sqlite3VdbeAddOp3(pParse->pVdbe, OP_ReleaseReg, iFirst, N, *(int*)&mask);
001207 }
001208 }
001209 #endif /* SQLITE_DEBUG */
001210
001211
001212 /*
001213 ** Change the value of the P4 operand for a specific instruction.
001214 ** This routine is useful when a large program is loaded from a
001215 ** static array using sqlite3VdbeAddOpList but we want to make a
001216 ** few minor changes to the program.
001217 **
001218 ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
001219 ** the string is made into memory obtained from sqlite3_malloc().
001220 ** A value of n==0 means copy bytes of zP4 up to and including the
001221 ** first null byte. If n>0 then copy n+1 bytes of zP4.
001222 **
001223 ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
001224 ** to a string or structure that is guaranteed to exist for the lifetime of
001225 ** the Vdbe. In these cases we can just copy the pointer.
001226 **
001227 ** If addr<0 then change P4 on the most recently inserted instruction.
001228 */
001229 static void SQLITE_NOINLINE vdbeChangeP4Full(
001230 Vdbe *p,
001231 Op *pOp,
001232 const char *zP4,
001233 int n
001234 ){
001235 if( pOp->p4type ){
001236 freeP4(p->db, pOp->p4type, pOp->p4.p);
001237 pOp->p4type = 0;
001238 pOp->p4.p = 0;
001239 }
001240 if( n<0 ){
001241 sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n);
001242 }else{
001243 if( n==0 ) n = sqlite3Strlen30(zP4);
001244 pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
001245 pOp->p4type = P4_DYNAMIC;
001246 }
001247 }
001248 void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
001249 Op *pOp;
001250 sqlite3 *db;
001251 assert( p!=0 );
001252 db = p->db;
001253 assert( p->magic==VDBE_MAGIC_INIT );
001254 assert( p->aOp!=0 || db->mallocFailed );
001255 if( db->mallocFailed ){
001256 if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4);
001257 return;
001258 }
001259 assert( p->nOp>0 );
001260 assert( addr<p->nOp );
001261 if( addr<0 ){
001262 addr = p->nOp - 1;
001263 }
001264 pOp = &p->aOp[addr];
001265 if( n>=0 || pOp->p4type ){
001266 vdbeChangeP4Full(p, pOp, zP4, n);
001267 return;
001268 }
001269 if( n==P4_INT32 ){
001270 /* Note: this cast is safe, because the origin data point was an int
001271 ** that was cast to a (const char *). */
001272 pOp->p4.i = SQLITE_PTR_TO_INT(zP4);
001273 pOp->p4type = P4_INT32;
001274 }else if( zP4!=0 ){
001275 assert( n<0 );
001276 pOp->p4.p = (void*)zP4;
001277 pOp->p4type = (signed char)n;
001278 if( n==P4_VTAB ) sqlite3VtabLock((VTable*)zP4);
001279 }
001280 }
001281
001282 /*
001283 ** Change the P4 operand of the most recently coded instruction
001284 ** to the value defined by the arguments. This is a high-speed
001285 ** version of sqlite3VdbeChangeP4().
001286 **
001287 ** The P4 operand must not have been previously defined. And the new
001288 ** P4 must not be P4_INT32. Use sqlite3VdbeChangeP4() in either of
001289 ** those cases.
001290 */
001291 void sqlite3VdbeAppendP4(Vdbe *p, void *pP4, int n){
001292 VdbeOp *pOp;
001293 assert( n!=P4_INT32 && n!=P4_VTAB );
001294 assert( n<=0 );
001295 if( p->db->mallocFailed ){
001296 freeP4(p->db, n, pP4);
001297 }else{
001298 assert( pP4!=0 );
001299 assert( p->nOp>0 );
001300 pOp = &p->aOp[p->nOp-1];
001301 assert( pOp->p4type==P4_NOTUSED );
001302 pOp->p4type = n;
001303 pOp->p4.p = pP4;
001304 }
001305 }
001306
001307 /*
001308 ** Set the P4 on the most recently added opcode to the KeyInfo for the
001309 ** index given.
001310 */
001311 void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){
001312 Vdbe *v = pParse->pVdbe;
001313 KeyInfo *pKeyInfo;
001314 assert( v!=0 );
001315 assert( pIdx!=0 );
001316 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx);
001317 if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
001318 }
001319
001320 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
001321 /*
001322 ** Change the comment on the most recently coded instruction. Or
001323 ** insert a No-op and add the comment to that new instruction. This
001324 ** makes the code easier to read during debugging. None of this happens
001325 ** in a production build.
001326 */
001327 static void vdbeVComment(Vdbe *p, const char *zFormat, va_list ap){
001328 assert( p->nOp>0 || p->aOp==0 );
001329 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed
001330 || p->pParse->nErr>0 );
001331 if( p->nOp ){
001332 assert( p->aOp );
001333 sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment);
001334 p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap);
001335 }
001336 }
001337 void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
001338 va_list ap;
001339 if( p ){
001340 va_start(ap, zFormat);
001341 vdbeVComment(p, zFormat, ap);
001342 va_end(ap);
001343 }
001344 }
001345 void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){
001346 va_list ap;
001347 if( p ){
001348 sqlite3VdbeAddOp0(p, OP_Noop);
001349 va_start(ap, zFormat);
001350 vdbeVComment(p, zFormat, ap);
001351 va_end(ap);
001352 }
001353 }
001354 #endif /* NDEBUG */
001355
001356 #ifdef SQLITE_VDBE_COVERAGE
001357 /*
001358 ** Set the value if the iSrcLine field for the previously coded instruction.
001359 */
001360 void sqlite3VdbeSetLineNumber(Vdbe *v, int iLine){
001361 sqlite3VdbeGetOp(v,-1)->iSrcLine = iLine;
001362 }
001363 #endif /* SQLITE_VDBE_COVERAGE */
001364
001365 /*
001366 ** Return the opcode for a given address. If the address is -1, then
001367 ** return the most recently inserted opcode.
001368 **
001369 ** If a memory allocation error has occurred prior to the calling of this
001370 ** routine, then a pointer to a dummy VdbeOp will be returned. That opcode
001371 ** is readable but not writable, though it is cast to a writable value.
001372 ** The return of a dummy opcode allows the call to continue functioning
001373 ** after an OOM fault without having to check to see if the return from
001374 ** this routine is a valid pointer. But because the dummy.opcode is 0,
001375 ** dummy will never be written to. This is verified by code inspection and
001376 ** by running with Valgrind.
001377 */
001378 VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
001379 /* C89 specifies that the constant "dummy" will be initialized to all
001380 ** zeros, which is correct. MSVC generates a warning, nevertheless. */
001381 static VdbeOp dummy; /* Ignore the MSVC warning about no initializer */
001382 assert( p->magic==VDBE_MAGIC_INIT );
001383 if( addr<0 ){
001384 addr = p->nOp - 1;
001385 }
001386 assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
001387 if( p->db->mallocFailed ){
001388 return (VdbeOp*)&dummy;
001389 }else{
001390 return &p->aOp[addr];
001391 }
001392 }
001393
001394 #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS)
001395 /*
001396 ** Return an integer value for one of the parameters to the opcode pOp
001397 ** determined by character c.
001398 */
001399 static int translateP(char c, const Op *pOp){
001400 if( c=='1' ) return pOp->p1;
001401 if( c=='2' ) return pOp->p2;
001402 if( c=='3' ) return pOp->p3;
001403 if( c=='4' ) return pOp->p4.i;
001404 return pOp->p5;
001405 }
001406
001407 /*
001408 ** Compute a string for the "comment" field of a VDBE opcode listing.
001409 **
001410 ** The Synopsis: field in comments in the vdbe.c source file gets converted
001411 ** to an extra string that is appended to the sqlite3OpcodeName(). In the
001412 ** absence of other comments, this synopsis becomes the comment on the opcode.
001413 ** Some translation occurs:
001414 **
001415 ** "PX" -> "r[X]"
001416 ** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1
001417 ** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0
001418 ** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x
001419 */
001420 static int displayComment(
001421 const Op *pOp, /* The opcode to be commented */
001422 const char *zP4, /* Previously obtained value for P4 */
001423 char *zTemp, /* Write result here */
001424 int nTemp /* Space available in zTemp[] */
001425 ){
001426 const char *zOpName;
001427 const char *zSynopsis;
001428 int nOpName;
001429 int ii, jj;
001430 char zAlt[50];
001431 zOpName = sqlite3OpcodeName(pOp->opcode);
001432 nOpName = sqlite3Strlen30(zOpName);
001433 if( zOpName[nOpName+1] ){
001434 int seenCom = 0;
001435 char c;
001436 zSynopsis = zOpName += nOpName + 1;
001437 if( strncmp(zSynopsis,"IF ",3)==0 ){
001438 if( pOp->p5 & SQLITE_STOREP2 ){
001439 sqlite3_snprintf(sizeof(zAlt), zAlt, "r[P2] = (%s)", zSynopsis+3);
001440 }else{
001441 sqlite3_snprintf(sizeof(zAlt), zAlt, "if %s goto P2", zSynopsis+3);
001442 }
001443 zSynopsis = zAlt;
001444 }
001445 for(ii=jj=0; jj<nTemp-1 && (c = zSynopsis[ii])!=0; ii++){
001446 if( c=='P' ){
001447 c = zSynopsis[++ii];
001448 if( c=='4' ){
001449 sqlite3_snprintf(nTemp-jj, zTemp+jj, "%s", zP4);
001450 }else if( c=='X' ){
001451 sqlite3_snprintf(nTemp-jj, zTemp+jj, "%s", pOp->zComment);
001452 seenCom = 1;
001453 }else{
001454 int v1 = translateP(c, pOp);
001455 int v2;
001456 sqlite3_snprintf(nTemp-jj, zTemp+jj, "%d", v1);
001457 if( strncmp(zSynopsis+ii+1, "@P", 2)==0 ){
001458 ii += 3;
001459 jj += sqlite3Strlen30(zTemp+jj);
001460 v2 = translateP(zSynopsis[ii], pOp);
001461 if( strncmp(zSynopsis+ii+1,"+1",2)==0 ){
001462 ii += 2;
001463 v2++;
001464 }
001465 if( v2>1 ){
001466 sqlite3_snprintf(nTemp-jj, zTemp+jj, "..%d", v1+v2-1);
001467 }
001468 }else if( strncmp(zSynopsis+ii+1, "..P3", 4)==0 && pOp->p3==0 ){
001469 ii += 4;
001470 }
001471 }
001472 jj += sqlite3Strlen30(zTemp+jj);
001473 }else{
001474 zTemp[jj++] = c;
001475 }
001476 }
001477 if( !seenCom && jj<nTemp-5 && pOp->zComment ){
001478 sqlite3_snprintf(nTemp-jj, zTemp+jj, "; %s", pOp->zComment);
001479 jj += sqlite3Strlen30(zTemp+jj);
001480 }
001481 if( jj<nTemp ) zTemp[jj] = 0;
001482 }else if( pOp->zComment ){
001483 sqlite3_snprintf(nTemp, zTemp, "%s", pOp->zComment);
001484 jj = sqlite3Strlen30(zTemp);
001485 }else{
001486 zTemp[0] = 0;
001487 jj = 0;
001488 }
001489 return jj;
001490 }
001491 #endif /* SQLITE_DEBUG */
001492
001493 #if VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS)
001494 /*
001495 ** Translate the P4.pExpr value for an OP_CursorHint opcode into text
001496 ** that can be displayed in the P4 column of EXPLAIN output.
001497 */
001498 static void displayP4Expr(StrAccum *p, Expr *pExpr){
001499 const char *zOp = 0;
001500 switch( pExpr->op ){
001501 case TK_STRING:
001502 sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
001503 break;
001504 case TK_INTEGER:
001505 sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
001506 break;
001507 case TK_NULL:
001508 sqlite3_str_appendf(p, "NULL");
001509 break;
001510 case TK_REGISTER: {
001511 sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
001512 break;
001513 }
001514 case TK_COLUMN: {
001515 if( pExpr->iColumn<0 ){
001516 sqlite3_str_appendf(p, "rowid");
001517 }else{
001518 sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
001519 }
001520 break;
001521 }
001522 case TK_LT: zOp = "LT"; break;
001523 case TK_LE: zOp = "LE"; break;
001524 case TK_GT: zOp = "GT"; break;
001525 case TK_GE: zOp = "GE"; break;
001526 case TK_NE: zOp = "NE"; break;
001527 case TK_EQ: zOp = "EQ"; break;
001528 case TK_IS: zOp = "IS"; break;
001529 case TK_ISNOT: zOp = "ISNOT"; break;
001530 case TK_AND: zOp = "AND"; break;
001531 case TK_OR: zOp = "OR"; break;
001532 case TK_PLUS: zOp = "ADD"; break;
001533 case TK_STAR: zOp = "MUL"; break;
001534 case TK_MINUS: zOp = "SUB"; break;
001535 case TK_REM: zOp = "REM"; break;
001536 case TK_BITAND: zOp = "BITAND"; break;
001537 case TK_BITOR: zOp = "BITOR"; break;
001538 case TK_SLASH: zOp = "DIV"; break;
001539 case TK_LSHIFT: zOp = "LSHIFT"; break;
001540 case TK_RSHIFT: zOp = "RSHIFT"; break;
001541 case TK_CONCAT: zOp = "CONCAT"; break;
001542 case TK_UMINUS: zOp = "MINUS"; break;
001543 case TK_UPLUS: zOp = "PLUS"; break;
001544 case TK_BITNOT: zOp = "BITNOT"; break;
001545 case TK_NOT: zOp = "NOT"; break;
001546 case TK_ISNULL: zOp = "ISNULL"; break;
001547 case TK_NOTNULL: zOp = "NOTNULL"; break;
001548
001549 default:
001550 sqlite3_str_appendf(p, "%s", "expr");
001551 break;
001552 }
001553
001554 if( zOp ){
001555 sqlite3_str_appendf(p, "%s(", zOp);
001556 displayP4Expr(p, pExpr->pLeft);
001557 if( pExpr->pRight ){
001558 sqlite3_str_append(p, ",", 1);
001559 displayP4Expr(p, pExpr->pRight);
001560 }
001561 sqlite3_str_append(p, ")", 1);
001562 }
001563 }
001564 #endif /* VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) */
001565
001566
001567 #if VDBE_DISPLAY_P4
001568 /*
001569 ** Compute a string that describes the P4 parameter for an opcode.
001570 ** Use zTemp for any required temporary buffer space.
001571 */
001572 static char *displayP4(Op *pOp, char *zTemp, int nTemp){
001573 char *zP4 = zTemp;
001574 StrAccum x;
001575 assert( nTemp>=20 );
001576 sqlite3StrAccumInit(&x, 0, zTemp, nTemp, 0);
001577 switch( pOp->p4type ){
001578 case P4_KEYINFO: {
001579 int j;
001580 KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
001581 assert( pKeyInfo->aSortFlags!=0 );
001582 sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField);
001583 for(j=0; j<pKeyInfo->nKeyField; j++){
001584 CollSeq *pColl = pKeyInfo->aColl[j];
001585 const char *zColl = pColl ? pColl->zName : "";
001586 if( strcmp(zColl, "BINARY")==0 ) zColl = "B";
001587 sqlite3_str_appendf(&x, ",%s%s%s",
001588 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_DESC) ? "-" : "",
001589 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "",
001590 zColl);
001591 }
001592 sqlite3_str_append(&x, ")", 1);
001593 break;
001594 }
001595 #ifdef SQLITE_ENABLE_CURSOR_HINTS
001596 case P4_EXPR: {
001597 displayP4Expr(&x, pOp->p4.pExpr);
001598 break;
001599 }
001600 #endif
001601 case P4_COLLSEQ: {
001602 CollSeq *pColl = pOp->p4.pColl;
001603 sqlite3_str_appendf(&x, "(%.20s)", pColl->zName);
001604 break;
001605 }
001606 case P4_FUNCDEF: {
001607 FuncDef *pDef = pOp->p4.pFunc;
001608 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
001609 break;
001610 }
001611 case P4_FUNCCTX: {
001612 FuncDef *pDef = pOp->p4.pCtx->pFunc;
001613 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
001614 break;
001615 }
001616 case P4_INT64: {
001617 sqlite3_str_appendf(&x, "%lld", *pOp->p4.pI64);
001618 break;
001619 }
001620 case P4_INT32: {
001621 sqlite3_str_appendf(&x, "%d", pOp->p4.i);
001622 break;
001623 }
001624 case P4_REAL: {
001625 sqlite3_str_appendf(&x, "%.16g", *pOp->p4.pReal);
001626 break;
001627 }
001628 case P4_MEM: {
001629 Mem *pMem = pOp->p4.pMem;
001630 if( pMem->flags & MEM_Str ){
001631 zP4 = pMem->z;
001632 }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
001633 sqlite3_str_appendf(&x, "%lld", pMem->u.i);
001634 }else if( pMem->flags & MEM_Real ){
001635 sqlite3_str_appendf(&x, "%.16g", pMem->u.r);
001636 }else if( pMem->flags & MEM_Null ){
001637 zP4 = "NULL";
001638 }else{
001639 assert( pMem->flags & MEM_Blob );
001640 zP4 = "(blob)";
001641 }
001642 break;
001643 }
001644 #ifndef SQLITE_OMIT_VIRTUALTABLE
001645 case P4_VTAB: {
001646 sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab;
001647 sqlite3_str_appendf(&x, "vtab:%p", pVtab);
001648 break;
001649 }
001650 #endif
001651 case P4_INTARRAY: {
001652 int i;
001653 int *ai = pOp->p4.ai;
001654 int n = ai[0]; /* The first element of an INTARRAY is always the
001655 ** count of the number of elements to follow */
001656 for(i=1; i<=n; i++){
001657 sqlite3_str_appendf(&x, ",%d", ai[i]);
001658 }
001659 zTemp[0] = '[';
001660 sqlite3_str_append(&x, "]", 1);
001661 break;
001662 }
001663 case P4_SUBPROGRAM: {
001664 sqlite3_str_appendf(&x, "program");
001665 break;
001666 }
001667 case P4_DYNBLOB:
001668 case P4_ADVANCE: {
001669 zTemp[0] = 0;
001670 break;
001671 }
001672 case P4_TABLE: {
001673 sqlite3_str_appendf(&x, "%s", pOp->p4.pTab->zName);
001674 break;
001675 }
001676 default: {
001677 zP4 = pOp->p4.z;
001678 if( zP4==0 ){
001679 zP4 = zTemp;
001680 zTemp[0] = 0;
001681 }
001682 }
001683 }
001684 sqlite3StrAccumFinish(&x);
001685 assert( zP4!=0 );
001686 return zP4;
001687 }
001688 #endif /* VDBE_DISPLAY_P4 */
001689
001690 /*
001691 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
001692 **
001693 ** The prepared statements need to know in advance the complete set of
001694 ** attached databases that will be use. A mask of these databases
001695 ** is maintained in p->btreeMask. The p->lockMask value is the subset of
001696 ** p->btreeMask of databases that will require a lock.
001697 */
001698 void sqlite3VdbeUsesBtree(Vdbe *p, int i){
001699 assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
001700 assert( i<(int)sizeof(p->btreeMask)*8 );
001701 DbMaskSet(p->btreeMask, i);
001702 if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
001703 DbMaskSet(p->lockMask, i);
001704 }
001705 }
001706
001707 #if !defined(SQLITE_OMIT_SHARED_CACHE)
001708 /*
001709 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
001710 ** this routine obtains the mutex associated with each BtShared structure
001711 ** that may be accessed by the VM passed as an argument. In doing so it also
001712 ** sets the BtShared.db member of each of the BtShared structures, ensuring
001713 ** that the correct busy-handler callback is invoked if required.
001714 **
001715 ** If SQLite is not threadsafe but does support shared-cache mode, then
001716 ** sqlite3BtreeEnter() is invoked to set the BtShared.db variables
001717 ** of all of BtShared structures accessible via the database handle
001718 ** associated with the VM.
001719 **
001720 ** If SQLite is not threadsafe and does not support shared-cache mode, this
001721 ** function is a no-op.
001722 **
001723 ** The p->btreeMask field is a bitmask of all btrees that the prepared
001724 ** statement p will ever use. Let N be the number of bits in p->btreeMask
001725 ** corresponding to btrees that use shared cache. Then the runtime of
001726 ** this routine is N*N. But as N is rarely more than 1, this should not
001727 ** be a problem.
001728 */
001729 void sqlite3VdbeEnter(Vdbe *p){
001730 int i;
001731 sqlite3 *db;
001732 Db *aDb;
001733 int nDb;
001734 if( DbMaskAllZero(p->lockMask) ) return; /* The common case */
001735 db = p->db;
001736 aDb = db->aDb;
001737 nDb = db->nDb;
001738 for(i=0; i<nDb; i++){
001739 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
001740 sqlite3BtreeEnter(aDb[i].pBt);
001741 }
001742 }
001743 }
001744 #endif
001745
001746 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
001747 /*
001748 ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter().
001749 */
001750 static SQLITE_NOINLINE void vdbeLeave(Vdbe *p){
001751 int i;
001752 sqlite3 *db;
001753 Db *aDb;
001754 int nDb;
001755 db = p->db;
001756 aDb = db->aDb;
001757 nDb = db->nDb;
001758 for(i=0; i<nDb; i++){
001759 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
001760 sqlite3BtreeLeave(aDb[i].pBt);
001761 }
001762 }
001763 }
001764 void sqlite3VdbeLeave(Vdbe *p){
001765 if( DbMaskAllZero(p->lockMask) ) return; /* The common case */
001766 vdbeLeave(p);
001767 }
001768 #endif
001769
001770 #if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
001771 /*
001772 ** Print a single opcode. This routine is used for debugging only.
001773 */
001774 void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){
001775 char *zP4;
001776 char zPtr[50];
001777 char zCom[100];
001778 static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-13s %.2X %s\n";
001779 if( pOut==0 ) pOut = stdout;
001780 zP4 = displayP4(pOp, zPtr, sizeof(zPtr));
001781 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
001782 displayComment(pOp, zP4, zCom, sizeof(zCom));
001783 #else
001784 zCom[0] = 0;
001785 #endif
001786 /* NB: The sqlite3OpcodeName() function is implemented by code created
001787 ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the
001788 ** information from the vdbe.c source text */
001789 fprintf(pOut, zFormat1, pc,
001790 sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5,
001791 zCom
001792 );
001793 fflush(pOut);
001794 }
001795 #endif
001796
001797 /*
001798 ** Initialize an array of N Mem element.
001799 */
001800 static void initMemArray(Mem *p, int N, sqlite3 *db, u16 flags){
001801 while( (N--)>0 ){
001802 p->db = db;
001803 p->flags = flags;
001804 p->szMalloc = 0;
001805 #ifdef SQLITE_DEBUG
001806 p->pScopyFrom = 0;
001807 #endif
001808 p++;
001809 }
001810 }
001811
001812 /*
001813 ** Release an array of N Mem elements
001814 */
001815 static void releaseMemArray(Mem *p, int N){
001816 if( p && N ){
001817 Mem *pEnd = &p[N];
001818 sqlite3 *db = p->db;
001819 if( db->pnBytesFreed ){
001820 do{
001821 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
001822 }while( (++p)<pEnd );
001823 return;
001824 }
001825 do{
001826 assert( (&p[1])==pEnd || p[0].db==p[1].db );
001827 assert( sqlite3VdbeCheckMemInvariants(p) );
001828
001829 /* This block is really an inlined version of sqlite3VdbeMemRelease()
001830 ** that takes advantage of the fact that the memory cell value is
001831 ** being set to NULL after releasing any dynamic resources.
001832 **
001833 ** The justification for duplicating code is that according to
001834 ** callgrind, this causes a certain test case to hit the CPU 4.7
001835 ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
001836 ** sqlite3MemRelease() were called from here. With -O2, this jumps
001837 ** to 6.6 percent. The test case is inserting 1000 rows into a table
001838 ** with no indexes using a single prepared INSERT statement, bind()
001839 ** and reset(). Inserts are grouped into a transaction.
001840 */
001841 testcase( p->flags & MEM_Agg );
001842 testcase( p->flags & MEM_Dyn );
001843 testcase( p->xDel==sqlite3VdbeFrameMemDel );
001844 if( p->flags&(MEM_Agg|MEM_Dyn) ){
001845 sqlite3VdbeMemRelease(p);
001846 }else if( p->szMalloc ){
001847 sqlite3DbFreeNN(db, p->zMalloc);
001848 p->szMalloc = 0;
001849 }
001850
001851 p->flags = MEM_Undefined;
001852 }while( (++p)<pEnd );
001853 }
001854 }
001855
001856 #ifdef SQLITE_DEBUG
001857 /*
001858 ** Verify that pFrame is a valid VdbeFrame pointer. Return true if it is
001859 ** and false if something is wrong.
001860 **
001861 ** This routine is intended for use inside of assert() statements only.
001862 */
001863 int sqlite3VdbeFrameIsValid(VdbeFrame *pFrame){
001864 if( pFrame->iFrameMagic!=SQLITE_FRAME_MAGIC ) return 0;
001865 return 1;
001866 }
001867 #endif
001868
001869
001870 /*
001871 ** This is a destructor on a Mem object (which is really an sqlite3_value)
001872 ** that deletes the Frame object that is attached to it as a blob.
001873 **
001874 ** This routine does not delete the Frame right away. It merely adds the
001875 ** frame to a list of frames to be deleted when the Vdbe halts.
001876 */
001877 void sqlite3VdbeFrameMemDel(void *pArg){
001878 VdbeFrame *pFrame = (VdbeFrame*)pArg;
001879 assert( sqlite3VdbeFrameIsValid(pFrame) );
001880 pFrame->pParent = pFrame->v->pDelFrame;
001881 pFrame->v->pDelFrame = pFrame;
001882 }
001883
001884
001885 /*
001886 ** Delete a VdbeFrame object and its contents. VdbeFrame objects are
001887 ** allocated by the OP_Program opcode in sqlite3VdbeExec().
001888 */
001889 void sqlite3VdbeFrameDelete(VdbeFrame *p){
001890 int i;
001891 Mem *aMem = VdbeFrameMem(p);
001892 VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem];
001893 assert( sqlite3VdbeFrameIsValid(p) );
001894 for(i=0; i<p->nChildCsr; i++){
001895 sqlite3VdbeFreeCursor(p->v, apCsr[i]);
001896 }
001897 releaseMemArray(aMem, p->nChildMem);
001898 sqlite3VdbeDeleteAuxData(p->v->db, &p->pAuxData, -1, 0);
001899 sqlite3DbFree(p->v->db, p);
001900 }
001901
001902 #ifndef SQLITE_OMIT_EXPLAIN
001903 /*
001904 ** Give a listing of the program in the virtual machine.
001905 **
001906 ** The interface is the same as sqlite3VdbeExec(). But instead of
001907 ** running the code, it invokes the callback once for each instruction.
001908 ** This feature is used to implement "EXPLAIN".
001909 **
001910 ** When p->explain==1, each instruction is listed. When
001911 ** p->explain==2, only OP_Explain instructions are listed and these
001912 ** are shown in a different format. p->explain==2 is used to implement
001913 ** EXPLAIN QUERY PLAN.
001914 ** 2018-04-24: In p->explain==2 mode, the OP_Init opcodes of triggers
001915 ** are also shown, so that the boundaries between the main program and
001916 ** each trigger are clear.
001917 **
001918 ** When p->explain==1, first the main program is listed, then each of
001919 ** the trigger subprograms are listed one by one.
001920 */
001921 int sqlite3VdbeList(
001922 Vdbe *p /* The VDBE */
001923 ){
001924 int nRow; /* Stop when row count reaches this */
001925 int nSub = 0; /* Number of sub-vdbes seen so far */
001926 SubProgram **apSub = 0; /* Array of sub-vdbes */
001927 Mem *pSub = 0; /* Memory cell hold array of subprogs */
001928 sqlite3 *db = p->db; /* The database connection */
001929 int i; /* Loop counter */
001930 int rc = SQLITE_OK; /* Return code */
001931 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
001932 int bListSubprogs = (p->explain==1 || (db->flags & SQLITE_TriggerEQP)!=0);
001933 Op *pOp = 0;
001934
001935 assert( p->explain );
001936 assert( p->magic==VDBE_MAGIC_RUN );
001937 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
001938
001939 /* Even though this opcode does not use dynamic strings for
001940 ** the result, result columns may become dynamic if the user calls
001941 ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
001942 */
001943 releaseMemArray(pMem, 8);
001944 p->pResultSet = 0;
001945
001946 if( p->rc==SQLITE_NOMEM ){
001947 /* This happens if a malloc() inside a call to sqlite3_column_text() or
001948 ** sqlite3_column_text16() failed. */
001949 sqlite3OomFault(db);
001950 return SQLITE_ERROR;
001951 }
001952
001953 /* When the number of output rows reaches nRow, that means the
001954 ** listing has finished and sqlite3_step() should return SQLITE_DONE.
001955 ** nRow is the sum of the number of rows in the main program, plus
001956 ** the sum of the number of rows in all trigger subprograms encountered
001957 ** so far. The nRow value will increase as new trigger subprograms are
001958 ** encountered, but p->pc will eventually catch up to nRow.
001959 */
001960 nRow = p->nOp;
001961 if( bListSubprogs ){
001962 /* The first 8 memory cells are used for the result set. So we will
001963 ** commandeer the 9th cell to use as storage for an array of pointers
001964 ** to trigger subprograms. The VDBE is guaranteed to have at least 9
001965 ** cells. */
001966 assert( p->nMem>9 );
001967 pSub = &p->aMem[9];
001968 if( pSub->flags&MEM_Blob ){
001969 /* On the first call to sqlite3_step(), pSub will hold a NULL. It is
001970 ** initialized to a BLOB by the P4_SUBPROGRAM processing logic below */
001971 nSub = pSub->n/sizeof(Vdbe*);
001972 apSub = (SubProgram **)pSub->z;
001973 }
001974 for(i=0; i<nSub; i++){
001975 nRow += apSub[i]->nOp;
001976 }
001977 }
001978
001979 while(1){ /* Loop exits via break */
001980 i = p->pc++;
001981 if( i>=nRow ){
001982 p->rc = SQLITE_OK;
001983 rc = SQLITE_DONE;
001984 break;
001985 }
001986 if( i<p->nOp ){
001987 /* The output line number is small enough that we are still in the
001988 ** main program. */
001989 pOp = &p->aOp[i];
001990 }else{
001991 /* We are currently listing subprograms. Figure out which one and
001992 ** pick up the appropriate opcode. */
001993 int j;
001994 i -= p->nOp;
001995 assert( apSub!=0 );
001996 assert( nSub>0 );
001997 for(j=0; i>=apSub[j]->nOp; j++){
001998 i -= apSub[j]->nOp;
001999 assert( i<apSub[j]->nOp || j+1<nSub );
002000 }
002001 pOp = &apSub[j]->aOp[i];
002002 }
002003
002004 /* When an OP_Program opcode is encounter (the only opcode that has
002005 ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms
002006 ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
002007 ** has not already been seen.
002008 */
002009 if( bListSubprogs && pOp->p4type==P4_SUBPROGRAM ){
002010 int nByte = (nSub+1)*sizeof(SubProgram*);
002011 int j;
002012 for(j=0; j<nSub; j++){
002013 if( apSub[j]==pOp->p4.pProgram ) break;
002014 }
002015 if( j==nSub ){
002016 p->rc = sqlite3VdbeMemGrow(pSub, nByte, nSub!=0);
002017 if( p->rc!=SQLITE_OK ){
002018 rc = SQLITE_ERROR;
002019 break;
002020 }
002021 apSub = (SubProgram **)pSub->z;
002022 apSub[nSub++] = pOp->p4.pProgram;
002023 pSub->flags |= MEM_Blob;
002024 pSub->n = nSub*sizeof(SubProgram*);
002025 nRow += pOp->p4.pProgram->nOp;
002026 }
002027 }
002028 if( p->explain<2 ) break;
002029 if( pOp->opcode==OP_Explain ) break;
002030 if( pOp->opcode==OP_Init && p->pc>1 ) break;
002031 }
002032
002033 if( rc==SQLITE_OK ){
002034 if( db->u1.isInterrupted ){
002035 p->rc = SQLITE_INTERRUPT;
002036 rc = SQLITE_ERROR;
002037 sqlite3VdbeError(p, sqlite3ErrStr(p->rc));
002038 }else{
002039 char *zP4;
002040 if( p->explain==1 ){
002041 pMem->flags = MEM_Int;
002042 pMem->u.i = i; /* Program counter */
002043 pMem++;
002044
002045 pMem->flags = MEM_Static|MEM_Str|MEM_Term;
002046 pMem->z = (char*)sqlite3OpcodeName(pOp->opcode); /* Opcode */
002047 assert( pMem->z!=0 );
002048 pMem->n = sqlite3Strlen30(pMem->z);
002049 pMem->enc = SQLITE_UTF8;
002050 pMem++;
002051 }
002052
002053 pMem->flags = MEM_Int;
002054 pMem->u.i = pOp->p1; /* P1 */
002055 pMem++;
002056
002057 pMem->flags = MEM_Int;
002058 pMem->u.i = pOp->p2; /* P2 */
002059 pMem++;
002060
002061 pMem->flags = MEM_Int;
002062 pMem->u.i = pOp->p3; /* P3 */
002063 pMem++;
002064
002065 if( sqlite3VdbeMemClearAndResize(pMem, 100) ){ /* P4 */
002066 assert( p->db->mallocFailed );
002067 return SQLITE_ERROR;
002068 }
002069 pMem->flags = MEM_Str|MEM_Term;
002070 zP4 = displayP4(pOp, pMem->z, pMem->szMalloc);
002071 if( zP4!=pMem->z ){
002072 pMem->n = 0;
002073 sqlite3VdbeMemSetStr(pMem, zP4, -1, SQLITE_UTF8, 0);
002074 }else{
002075 assert( pMem->z!=0 );
002076 pMem->n = sqlite3Strlen30(pMem->z);
002077 pMem->enc = SQLITE_UTF8;
002078 }
002079 pMem++;
002080
002081 if( p->explain==1 ){
002082 if( sqlite3VdbeMemClearAndResize(pMem, 4) ){
002083 assert( p->db->mallocFailed );
002084 return SQLITE_ERROR;
002085 }
002086 pMem->flags = MEM_Str|MEM_Term;
002087 pMem->n = 2;
002088 sqlite3_snprintf(3, pMem->z, "%.2x", pOp->p5); /* P5 */
002089 pMem->enc = SQLITE_UTF8;
002090 pMem++;
002091
002092 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
002093 if( sqlite3VdbeMemClearAndResize(pMem, 500) ){
002094 assert( p->db->mallocFailed );
002095 return SQLITE_ERROR;
002096 }
002097 pMem->flags = MEM_Str|MEM_Term;
002098 pMem->n = displayComment(pOp, zP4, pMem->z, 500);
002099 pMem->enc = SQLITE_UTF8;
002100 #else
002101 pMem->flags = MEM_Null; /* Comment */
002102 #endif
002103 }
002104
002105 p->nResColumn = 8 - 4*(p->explain-1);
002106 p->pResultSet = &p->aMem[1];
002107 p->rc = SQLITE_OK;
002108 rc = SQLITE_ROW;
002109 }
002110 }
002111 return rc;
002112 }
002113 #endif /* SQLITE_OMIT_EXPLAIN */
002114
002115 #ifdef SQLITE_DEBUG
002116 /*
002117 ** Print the SQL that was used to generate a VDBE program.
002118 */
002119 void sqlite3VdbePrintSql(Vdbe *p){
002120 const char *z = 0;
002121 if( p->zSql ){
002122 z = p->zSql;
002123 }else if( p->nOp>=1 ){
002124 const VdbeOp *pOp = &p->aOp[0];
002125 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
002126 z = pOp->p4.z;
002127 while( sqlite3Isspace(*z) ) z++;
002128 }
002129 }
002130 if( z ) printf("SQL: [%s]\n", z);
002131 }
002132 #endif
002133
002134 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
002135 /*
002136 ** Print an IOTRACE message showing SQL content.
002137 */
002138 void sqlite3VdbeIOTraceSql(Vdbe *p){
002139 int nOp = p->nOp;
002140 VdbeOp *pOp;
002141 if( sqlite3IoTrace==0 ) return;
002142 if( nOp<1 ) return;
002143 pOp = &p->aOp[0];
002144 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
002145 int i, j;
002146 char z[1000];
002147 sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
002148 for(i=0; sqlite3Isspace(z[i]); i++){}
002149 for(j=0; z[i]; i++){
002150 if( sqlite3Isspace(z[i]) ){
002151 if( z[i-1]!=' ' ){
002152 z[j++] = ' ';
002153 }
002154 }else{
002155 z[j++] = z[i];
002156 }
002157 }
002158 z[j] = 0;
002159 sqlite3IoTrace("SQL %s\n", z);
002160 }
002161 }
002162 #endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */
002163
002164 /* An instance of this object describes bulk memory available for use
002165 ** by subcomponents of a prepared statement. Space is allocated out
002166 ** of a ReusableSpace object by the allocSpace() routine below.
002167 */
002168 struct ReusableSpace {
002169 u8 *pSpace; /* Available memory */
002170 sqlite3_int64 nFree; /* Bytes of available memory */
002171 sqlite3_int64 nNeeded; /* Total bytes that could not be allocated */
002172 };
002173
002174 /* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf
002175 ** from the ReusableSpace object. Return a pointer to the allocated
002176 ** memory on success. If insufficient memory is available in the
002177 ** ReusableSpace object, increase the ReusableSpace.nNeeded
002178 ** value by the amount needed and return NULL.
002179 **
002180 ** If pBuf is not initially NULL, that means that the memory has already
002181 ** been allocated by a prior call to this routine, so just return a copy
002182 ** of pBuf and leave ReusableSpace unchanged.
002183 **
002184 ** This allocator is employed to repurpose unused slots at the end of the
002185 ** opcode array of prepared state for other memory needs of the prepared
002186 ** statement.
002187 */
002188 static void *allocSpace(
002189 struct ReusableSpace *p, /* Bulk memory available for allocation */
002190 void *pBuf, /* Pointer to a prior allocation */
002191 sqlite3_int64 nByte /* Bytes of memory needed */
002192 ){
002193 assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) );
002194 if( pBuf==0 ){
002195 nByte = ROUND8(nByte);
002196 if( nByte <= p->nFree ){
002197 p->nFree -= nByte;
002198 pBuf = &p->pSpace[p->nFree];
002199 }else{
002200 p->nNeeded += nByte;
002201 }
002202 }
002203 assert( EIGHT_BYTE_ALIGNMENT(pBuf) );
002204 return pBuf;
002205 }
002206
002207 /*
002208 ** Rewind the VDBE back to the beginning in preparation for
002209 ** running it.
002210 */
002211 void sqlite3VdbeRewind(Vdbe *p){
002212 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
002213 int i;
002214 #endif
002215 assert( p!=0 );
002216 assert( p->magic==VDBE_MAGIC_INIT || p->magic==VDBE_MAGIC_RESET );
002217
002218 /* There should be at least one opcode.
002219 */
002220 assert( p->nOp>0 );
002221
002222 /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */
002223 p->magic = VDBE_MAGIC_RUN;
002224
002225 #ifdef SQLITE_DEBUG
002226 for(i=0; i<p->nMem; i++){
002227 assert( p->aMem[i].db==p->db );
002228 }
002229 #endif
002230 p->pc = -1;
002231 p->rc = SQLITE_OK;
002232 p->errorAction = OE_Abort;
002233 p->nChange = 0;
002234 p->cacheCtr = 1;
002235 p->minWriteFileFormat = 255;
002236 p->iStatement = 0;
002237 p->nFkConstraint = 0;
002238 #ifdef VDBE_PROFILE
002239 for(i=0; i<p->nOp; i++){
002240 p->aOp[i].cnt = 0;
002241 p->aOp[i].cycles = 0;
002242 }
002243 #endif
002244 }
002245
002246 /*
002247 ** Prepare a virtual machine for execution for the first time after
002248 ** creating the virtual machine. This involves things such
002249 ** as allocating registers and initializing the program counter.
002250 ** After the VDBE has be prepped, it can be executed by one or more
002251 ** calls to sqlite3VdbeExec().
002252 **
002253 ** This function may be called exactly once on each virtual machine.
002254 ** After this routine is called the VM has been "packaged" and is ready
002255 ** to run. After this routine is called, further calls to
002256 ** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects
002257 ** the Vdbe from the Parse object that helped generate it so that the
002258 ** the Vdbe becomes an independent entity and the Parse object can be
002259 ** destroyed.
002260 **
002261 ** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back
002262 ** to its initial state after it has been run.
002263 */
002264 void sqlite3VdbeMakeReady(
002265 Vdbe *p, /* The VDBE */
002266 Parse *pParse /* Parsing context */
002267 ){
002268 sqlite3 *db; /* The database connection */
002269 int nVar; /* Number of parameters */
002270 int nMem; /* Number of VM memory registers */
002271 int nCursor; /* Number of cursors required */
002272 int nArg; /* Number of arguments in subprograms */
002273 int n; /* Loop counter */
002274 struct ReusableSpace x; /* Reusable bulk memory */
002275
002276 assert( p!=0 );
002277 assert( p->nOp>0 );
002278 assert( pParse!=0 );
002279 assert( p->magic==VDBE_MAGIC_INIT );
002280 assert( pParse==p->pParse );
002281 db = p->db;
002282 assert( db->mallocFailed==0 );
002283 nVar = pParse->nVar;
002284 nMem = pParse->nMem;
002285 nCursor = pParse->nTab;
002286 nArg = pParse->nMaxArg;
002287
002288 /* Each cursor uses a memory cell. The first cursor (cursor 0) can
002289 ** use aMem[0] which is not otherwise used by the VDBE program. Allocate
002290 ** space at the end of aMem[] for cursors 1 and greater.
002291 ** See also: allocateCursor().
002292 */
002293 nMem += nCursor;
002294 if( nCursor==0 && nMem>0 ) nMem++; /* Space for aMem[0] even if not used */
002295
002296 /* Figure out how much reusable memory is available at the end of the
002297 ** opcode array. This extra memory will be reallocated for other elements
002298 ** of the prepared statement.
002299 */
002300 n = ROUND8(sizeof(Op)*p->nOp); /* Bytes of opcode memory used */
002301 x.pSpace = &((u8*)p->aOp)[n]; /* Unused opcode memory */
002302 assert( EIGHT_BYTE_ALIGNMENT(x.pSpace) );
002303 x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n); /* Bytes of unused memory */
002304 assert( x.nFree>=0 );
002305 assert( EIGHT_BYTE_ALIGNMENT(&x.pSpace[x.nFree]) );
002306
002307 resolveP2Values(p, &nArg);
002308 p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
002309 if( pParse->explain ){
002310 static const char * const azColName[] = {
002311 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
002312 "id", "parent", "notused", "detail"
002313 };
002314 int iFirst, mx, i;
002315 if( nMem<10 ) nMem = 10;
002316 if( pParse->explain==2 ){
002317 sqlite3VdbeSetNumCols(p, 4);
002318 iFirst = 8;
002319 mx = 12;
002320 }else{
002321 sqlite3VdbeSetNumCols(p, 8);
002322 iFirst = 0;
002323 mx = 8;
002324 }
002325 for(i=iFirst; i<mx; i++){
002326 sqlite3VdbeSetColName(p, i-iFirst, COLNAME_NAME,
002327 azColName[i], SQLITE_STATIC);
002328 }
002329 }
002330 p->expired = 0;
002331
002332 /* Memory for registers, parameters, cursor, etc, is allocated in one or two
002333 ** passes. On the first pass, we try to reuse unused memory at the
002334 ** end of the opcode array. If we are unable to satisfy all memory
002335 ** requirements by reusing the opcode array tail, then the second
002336 ** pass will fill in the remainder using a fresh memory allocation.
002337 **
002338 ** This two-pass approach that reuses as much memory as possible from
002339 ** the leftover memory at the end of the opcode array. This can significantly
002340 ** reduce the amount of memory held by a prepared statement.
002341 */
002342 x.nNeeded = 0;
002343 p->aMem = allocSpace(&x, 0, nMem*sizeof(Mem));
002344 p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem));
002345 p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*));
002346 p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*));
002347 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
002348 p->anExec = allocSpace(&x, 0, p->nOp*sizeof(i64));
002349 #endif
002350 if( x.nNeeded ){
002351 x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded);
002352 x.nFree = x.nNeeded;
002353 if( !db->mallocFailed ){
002354 p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem));
002355 p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem));
002356 p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*));
002357 p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*));
002358 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
002359 p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64));
002360 #endif
002361 }
002362 }
002363
002364 p->pVList = pParse->pVList;
002365 pParse->pVList = 0;
002366 p->explain = pParse->explain;
002367 if( db->mallocFailed ){
002368 p->nVar = 0;
002369 p->nCursor = 0;
002370 p->nMem = 0;
002371 }else{
002372 p->nCursor = nCursor;
002373 p->nVar = (ynVar)nVar;
002374 initMemArray(p->aVar, nVar, db, MEM_Null);
002375 p->nMem = nMem;
002376 initMemArray(p->aMem, nMem, db, MEM_Undefined);
002377 memset(p->apCsr, 0, nCursor*sizeof(VdbeCursor*));
002378 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
002379 memset(p->anExec, 0, p->nOp*sizeof(i64));
002380 #endif
002381 }
002382 sqlite3VdbeRewind(p);
002383 }
002384
002385 /*
002386 ** Close a VDBE cursor and release all the resources that cursor
002387 ** happens to hold.
002388 */
002389 void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
002390 if( pCx==0 ){
002391 return;
002392 }
002393 assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE );
002394 switch( pCx->eCurType ){
002395 case CURTYPE_SORTER: {
002396 sqlite3VdbeSorterClose(p->db, pCx);
002397 break;
002398 }
002399 case CURTYPE_BTREE: {
002400 if( pCx->isEphemeral ){
002401 if( pCx->pBtx ) sqlite3BtreeClose(pCx->pBtx);
002402 /* The pCx->pCursor will be close automatically, if it exists, by
002403 ** the call above. */
002404 }else{
002405 assert( pCx->uc.pCursor!=0 );
002406 sqlite3BtreeCloseCursor(pCx->uc.pCursor);
002407 }
002408 break;
002409 }
002410 #ifndef SQLITE_OMIT_VIRTUALTABLE
002411 case CURTYPE_VTAB: {
002412 sqlite3_vtab_cursor *pVCur = pCx->uc.pVCur;
002413 const sqlite3_module *pModule = pVCur->pVtab->pModule;
002414 assert( pVCur->pVtab->nRef>0 );
002415 pVCur->pVtab->nRef--;
002416 pModule->xClose(pVCur);
002417 break;
002418 }
002419 #endif
002420 }
002421 }
002422
002423 /*
002424 ** Close all cursors in the current frame.
002425 */
002426 static void closeCursorsInFrame(Vdbe *p){
002427 if( p->apCsr ){
002428 int i;
002429 for(i=0; i<p->nCursor; i++){
002430 VdbeCursor *pC = p->apCsr[i];
002431 if( pC ){
002432 sqlite3VdbeFreeCursor(p, pC);
002433 p->apCsr[i] = 0;
002434 }
002435 }
002436 }
002437 }
002438
002439 /*
002440 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
002441 ** is used, for example, when a trigger sub-program is halted to restore
002442 ** control to the main program.
002443 */
002444 int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){
002445 Vdbe *v = pFrame->v;
002446 closeCursorsInFrame(v);
002447 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
002448 v->anExec = pFrame->anExec;
002449 #endif
002450 v->aOp = pFrame->aOp;
002451 v->nOp = pFrame->nOp;
002452 v->aMem = pFrame->aMem;
002453 v->nMem = pFrame->nMem;
002454 v->apCsr = pFrame->apCsr;
002455 v->nCursor = pFrame->nCursor;
002456 v->db->lastRowid = pFrame->lastRowid;
002457 v->nChange = pFrame->nChange;
002458 v->db->nChange = pFrame->nDbChange;
002459 sqlite3VdbeDeleteAuxData(v->db, &v->pAuxData, -1, 0);
002460 v->pAuxData = pFrame->pAuxData;
002461 pFrame->pAuxData = 0;
002462 return pFrame->pc;
002463 }
002464
002465 /*
002466 ** Close all cursors.
002467 **
002468 ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory
002469 ** cell array. This is necessary as the memory cell array may contain
002470 ** pointers to VdbeFrame objects, which may in turn contain pointers to
002471 ** open cursors.
002472 */
002473 static void closeAllCursors(Vdbe *p){
002474 if( p->pFrame ){
002475 VdbeFrame *pFrame;
002476 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
002477 sqlite3VdbeFrameRestore(pFrame);
002478 p->pFrame = 0;
002479 p->nFrame = 0;
002480 }
002481 assert( p->nFrame==0 );
002482 closeCursorsInFrame(p);
002483 if( p->aMem ){
002484 releaseMemArray(p->aMem, p->nMem);
002485 }
002486 while( p->pDelFrame ){
002487 VdbeFrame *pDel = p->pDelFrame;
002488 p->pDelFrame = pDel->pParent;
002489 sqlite3VdbeFrameDelete(pDel);
002490 }
002491
002492 /* Delete any auxdata allocations made by the VM */
002493 if( p->pAuxData ) sqlite3VdbeDeleteAuxData(p->db, &p->pAuxData, -1, 0);
002494 assert( p->pAuxData==0 );
002495 }
002496
002497 /*
002498 ** Set the number of result columns that will be returned by this SQL
002499 ** statement. This is now set at compile time, rather than during
002500 ** execution of the vdbe program so that sqlite3_column_count() can
002501 ** be called on an SQL statement before sqlite3_step().
002502 */
002503 void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
002504 int n;
002505 sqlite3 *db = p->db;
002506
002507 if( p->nResColumn ){
002508 releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
002509 sqlite3DbFree(db, p->aColName);
002510 }
002511 n = nResColumn*COLNAME_N;
002512 p->nResColumn = (u16)nResColumn;
002513 p->aColName = (Mem*)sqlite3DbMallocRawNN(db, sizeof(Mem)*n );
002514 if( p->aColName==0 ) return;
002515 initMemArray(p->aColName, n, db, MEM_Null);
002516 }
002517
002518 /*
002519 ** Set the name of the idx'th column to be returned by the SQL statement.
002520 ** zName must be a pointer to a nul terminated string.
002521 **
002522 ** This call must be made after a call to sqlite3VdbeSetNumCols().
002523 **
002524 ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
002525 ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
002526 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
002527 */
002528 int sqlite3VdbeSetColName(
002529 Vdbe *p, /* Vdbe being configured */
002530 int idx, /* Index of column zName applies to */
002531 int var, /* One of the COLNAME_* constants */
002532 const char *zName, /* Pointer to buffer containing name */
002533 void (*xDel)(void*) /* Memory management strategy for zName */
002534 ){
002535 int rc;
002536 Mem *pColName;
002537 assert( idx<p->nResColumn );
002538 assert( var<COLNAME_N );
002539 if( p->db->mallocFailed ){
002540 assert( !zName || xDel!=SQLITE_DYNAMIC );
002541 return SQLITE_NOMEM_BKPT;
002542 }
002543 assert( p->aColName!=0 );
002544 pColName = &(p->aColName[idx+var*p->nResColumn]);
002545 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
002546 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
002547 return rc;
002548 }
002549
002550 /*
002551 ** A read or write transaction may or may not be active on database handle
002552 ** db. If a transaction is active, commit it. If there is a
002553 ** write-transaction spanning more than one database file, this routine
002554 ** takes care of the master journal trickery.
002555 */
002556 static int vdbeCommit(sqlite3 *db, Vdbe *p){
002557 int i;
002558 int nTrans = 0; /* Number of databases with an active write-transaction
002559 ** that are candidates for a two-phase commit using a
002560 ** master-journal */
002561 int rc = SQLITE_OK;
002562 int needXcommit = 0;
002563
002564 #ifdef SQLITE_OMIT_VIRTUALTABLE
002565 /* With this option, sqlite3VtabSync() is defined to be simply
002566 ** SQLITE_OK so p is not used.
002567 */
002568 UNUSED_PARAMETER(p);
002569 #endif
002570
002571 /* Before doing anything else, call the xSync() callback for any
002572 ** virtual module tables written in this transaction. This has to
002573 ** be done before determining whether a master journal file is
002574 ** required, as an xSync() callback may add an attached database
002575 ** to the transaction.
002576 */
002577 rc = sqlite3VtabSync(db, p);
002578
002579 /* This loop determines (a) if the commit hook should be invoked and
002580 ** (b) how many database files have open write transactions, not
002581 ** including the temp database. (b) is important because if more than
002582 ** one database file has an open write transaction, a master journal
002583 ** file is required for an atomic commit.
002584 */
002585 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
002586 Btree *pBt = db->aDb[i].pBt;
002587 if( sqlite3BtreeIsInTrans(pBt) ){
002588 /* Whether or not a database might need a master journal depends upon
002589 ** its journal mode (among other things). This matrix determines which
002590 ** journal modes use a master journal and which do not */
002591 static const u8 aMJNeeded[] = {
002592 /* DELETE */ 1,
002593 /* PERSIST */ 1,
002594 /* OFF */ 0,
002595 /* TRUNCATE */ 1,
002596 /* MEMORY */ 0,
002597 /* WAL */ 0
002598 };
002599 Pager *pPager; /* Pager associated with pBt */
002600 needXcommit = 1;
002601 sqlite3BtreeEnter(pBt);
002602 pPager = sqlite3BtreePager(pBt);
002603 if( db->aDb[i].safety_level!=PAGER_SYNCHRONOUS_OFF
002604 && aMJNeeded[sqlite3PagerGetJournalMode(pPager)]
002605 && sqlite3PagerIsMemdb(pPager)==0
002606 ){
002607 assert( i!=1 );
002608 nTrans++;
002609 }
002610 rc = sqlite3PagerExclusiveLock(pPager);
002611 sqlite3BtreeLeave(pBt);
002612 }
002613 }
002614 if( rc!=SQLITE_OK ){
002615 return rc;
002616 }
002617
002618 /* If there are any write-transactions at all, invoke the commit hook */
002619 if( needXcommit && db->xCommitCallback ){
002620 rc = db->xCommitCallback(db->pCommitArg);
002621 if( rc ){
002622 return SQLITE_CONSTRAINT_COMMITHOOK;
002623 }
002624 }
002625
002626 /* The simple case - no more than one database file (not counting the
002627 ** TEMP database) has a transaction active. There is no need for the
002628 ** master-journal.
002629 **
002630 ** If the return value of sqlite3BtreeGetFilename() is a zero length
002631 ** string, it means the main database is :memory: or a temp file. In
002632 ** that case we do not support atomic multi-file commits, so use the
002633 ** simple case then too.
002634 */
002635 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
002636 || nTrans<=1
002637 ){
002638 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
002639 Btree *pBt = db->aDb[i].pBt;
002640 if( pBt ){
002641 rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
002642 }
002643 }
002644
002645 /* Do the commit only if all databases successfully complete phase 1.
002646 ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
002647 ** IO error while deleting or truncating a journal file. It is unlikely,
002648 ** but could happen. In this case abandon processing and return the error.
002649 */
002650 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
002651 Btree *pBt = db->aDb[i].pBt;
002652 if( pBt ){
002653 rc = sqlite3BtreeCommitPhaseTwo(pBt, 0);
002654 }
002655 }
002656 if( rc==SQLITE_OK ){
002657 sqlite3VtabCommit(db);
002658 }
002659 }
002660
002661 /* The complex case - There is a multi-file write-transaction active.
002662 ** This requires a master journal file to ensure the transaction is
002663 ** committed atomically.
002664 */
002665 #ifndef SQLITE_OMIT_DISKIO
002666 else{
002667 sqlite3_vfs *pVfs = db->pVfs;
002668 char *zMaster = 0; /* File-name for the master journal */
002669 char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
002670 sqlite3_file *pMaster = 0;
002671 i64 offset = 0;
002672 int res;
002673 int retryCount = 0;
002674 int nMainFile;
002675
002676 /* Select a master journal file name */
002677 nMainFile = sqlite3Strlen30(zMainFile);
002678 zMaster = sqlite3MPrintf(db, "%s-mjXXXXXX9XXz%c%c", zMainFile, 0, 0);
002679 if( zMaster==0 ) return SQLITE_NOMEM_BKPT;
002680 do {
002681 u32 iRandom;
002682 if( retryCount ){
002683 if( retryCount>100 ){
002684 sqlite3_log(SQLITE_FULL, "MJ delete: %s", zMaster);
002685 sqlite3OsDelete(pVfs, zMaster, 0);
002686 break;
002687 }else if( retryCount==1 ){
002688 sqlite3_log(SQLITE_FULL, "MJ collide: %s", zMaster);
002689 }
002690 }
002691 retryCount++;
002692 sqlite3_randomness(sizeof(iRandom), &iRandom);
002693 sqlite3_snprintf(13, &zMaster[nMainFile], "-mj%06X9%02X",
002694 (iRandom>>8)&0xffffff, iRandom&0xff);
002695 /* The antipenultimate character of the master journal name must
002696 ** be "9" to avoid name collisions when using 8+3 filenames. */
002697 assert( zMaster[sqlite3Strlen30(zMaster)-3]=='9' );
002698 sqlite3FileSuffix3(zMainFile, zMaster);
002699 rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res);
002700 }while( rc==SQLITE_OK && res );
002701 if( rc==SQLITE_OK ){
002702 /* Open the master journal. */
002703 rc = sqlite3OsOpenMalloc(pVfs, zMaster, &pMaster,
002704 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
002705 SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_MASTER_JOURNAL, 0
002706 );
002707 }
002708 if( rc!=SQLITE_OK ){
002709 sqlite3DbFree(db, zMaster);
002710 return rc;
002711 }
002712
002713 /* Write the name of each database file in the transaction into the new
002714 ** master journal file. If an error occurs at this point close
002715 ** and delete the master journal file. All the individual journal files
002716 ** still have 'null' as the master journal pointer, so they will roll
002717 ** back independently if a failure occurs.
002718 */
002719 for(i=0; i<db->nDb; i++){
002720 Btree *pBt = db->aDb[i].pBt;
002721 if( sqlite3BtreeIsInTrans(pBt) ){
002722 char const *zFile = sqlite3BtreeGetJournalname(pBt);
002723 if( zFile==0 ){
002724 continue; /* Ignore TEMP and :memory: databases */
002725 }
002726 assert( zFile[0]!=0 );
002727 rc = sqlite3OsWrite(pMaster, zFile, sqlite3Strlen30(zFile)+1, offset);
002728 offset += sqlite3Strlen30(zFile)+1;
002729 if( rc!=SQLITE_OK ){
002730 sqlite3OsCloseFree(pMaster);
002731 sqlite3OsDelete(pVfs, zMaster, 0);
002732 sqlite3DbFree(db, zMaster);
002733 return rc;
002734 }
002735 }
002736 }
002737
002738 /* Sync the master journal file. If the IOCAP_SEQUENTIAL device
002739 ** flag is set this is not required.
002740 */
002741 if( 0==(sqlite3OsDeviceCharacteristics(pMaster)&SQLITE_IOCAP_SEQUENTIAL)
002742 && SQLITE_OK!=(rc = sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL))
002743 ){
002744 sqlite3OsCloseFree(pMaster);
002745 sqlite3OsDelete(pVfs, zMaster, 0);
002746 sqlite3DbFree(db, zMaster);
002747 return rc;
002748 }
002749
002750 /* Sync all the db files involved in the transaction. The same call
002751 ** sets the master journal pointer in each individual journal. If
002752 ** an error occurs here, do not delete the master journal file.
002753 **
002754 ** If the error occurs during the first call to
002755 ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
002756 ** master journal file will be orphaned. But we cannot delete it,
002757 ** in case the master journal file name was written into the journal
002758 ** file before the failure occurred.
002759 */
002760 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
002761 Btree *pBt = db->aDb[i].pBt;
002762 if( pBt ){
002763 rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster);
002764 }
002765 }
002766 sqlite3OsCloseFree(pMaster);
002767 assert( rc!=SQLITE_BUSY );
002768 if( rc!=SQLITE_OK ){
002769 sqlite3DbFree(db, zMaster);
002770 return rc;
002771 }
002772
002773 /* Delete the master journal file. This commits the transaction. After
002774 ** doing this the directory is synced again before any individual
002775 ** transaction files are deleted.
002776 */
002777 rc = sqlite3OsDelete(pVfs, zMaster, 1);
002778 sqlite3DbFree(db, zMaster);
002779 zMaster = 0;
002780 if( rc ){
002781 return rc;
002782 }
002783
002784 /* All files and directories have already been synced, so the following
002785 ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
002786 ** deleting or truncating journals. If something goes wrong while
002787 ** this is happening we don't really care. The integrity of the
002788 ** transaction is already guaranteed, but some stray 'cold' journals
002789 ** may be lying around. Returning an error code won't help matters.
002790 */
002791 disable_simulated_io_errors();
002792 sqlite3BeginBenignMalloc();
002793 for(i=0; i<db->nDb; i++){
002794 Btree *pBt = db->aDb[i].pBt;
002795 if( pBt ){
002796 sqlite3BtreeCommitPhaseTwo(pBt, 1);
002797 }
002798 }
002799 sqlite3EndBenignMalloc();
002800 enable_simulated_io_errors();
002801
002802 sqlite3VtabCommit(db);
002803 }
002804 #endif
002805
002806 return rc;
002807 }
002808
002809 /*
002810 ** This routine checks that the sqlite3.nVdbeActive count variable
002811 ** matches the number of vdbe's in the list sqlite3.pVdbe that are
002812 ** currently active. An assertion fails if the two counts do not match.
002813 ** This is an internal self-check only - it is not an essential processing
002814 ** step.
002815 **
002816 ** This is a no-op if NDEBUG is defined.
002817 */
002818 #ifndef NDEBUG
002819 static void checkActiveVdbeCnt(sqlite3 *db){
002820 Vdbe *p;
002821 int cnt = 0;
002822 int nWrite = 0;
002823 int nRead = 0;
002824 p = db->pVdbe;
002825 while( p ){
002826 if( sqlite3_stmt_busy((sqlite3_stmt*)p) ){
002827 cnt++;
002828 if( p->readOnly==0 ) nWrite++;
002829 if( p->bIsReader ) nRead++;
002830 }
002831 p = p->pNext;
002832 }
002833 assert( cnt==db->nVdbeActive );
002834 assert( nWrite==db->nVdbeWrite );
002835 assert( nRead==db->nVdbeRead );
002836 }
002837 #else
002838 #define checkActiveVdbeCnt(x)
002839 #endif
002840
002841 /*
002842 ** If the Vdbe passed as the first argument opened a statement-transaction,
002843 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
002844 ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
002845 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
002846 ** statement transaction is committed.
002847 **
002848 ** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned.
002849 ** Otherwise SQLITE_OK.
002850 */
002851 static SQLITE_NOINLINE int vdbeCloseStatement(Vdbe *p, int eOp){
002852 sqlite3 *const db = p->db;
002853 int rc = SQLITE_OK;
002854 int i;
002855 const int iSavepoint = p->iStatement-1;
002856
002857 assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
002858 assert( db->nStatement>0 );
002859 assert( p->iStatement==(db->nStatement+db->nSavepoint) );
002860
002861 for(i=0; i<db->nDb; i++){
002862 int rc2 = SQLITE_OK;
002863 Btree *pBt = db->aDb[i].pBt;
002864 if( pBt ){
002865 if( eOp==SAVEPOINT_ROLLBACK ){
002866 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
002867 }
002868 if( rc2==SQLITE_OK ){
002869 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
002870 }
002871 if( rc==SQLITE_OK ){
002872 rc = rc2;
002873 }
002874 }
002875 }
002876 db->nStatement--;
002877 p->iStatement = 0;
002878
002879 if( rc==SQLITE_OK ){
002880 if( eOp==SAVEPOINT_ROLLBACK ){
002881 rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint);
002882 }
002883 if( rc==SQLITE_OK ){
002884 rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint);
002885 }
002886 }
002887
002888 /* If the statement transaction is being rolled back, also restore the
002889 ** database handles deferred constraint counter to the value it had when
002890 ** the statement transaction was opened. */
002891 if( eOp==SAVEPOINT_ROLLBACK ){
002892 db->nDeferredCons = p->nStmtDefCons;
002893 db->nDeferredImmCons = p->nStmtDefImmCons;
002894 }
002895 return rc;
002896 }
002897 int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){
002898 if( p->db->nStatement && p->iStatement ){
002899 return vdbeCloseStatement(p, eOp);
002900 }
002901 return SQLITE_OK;
002902 }
002903
002904
002905 /*
002906 ** This function is called when a transaction opened by the database
002907 ** handle associated with the VM passed as an argument is about to be
002908 ** committed. If there are outstanding deferred foreign key constraint
002909 ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
002910 **
002911 ** If there are outstanding FK violations and this function returns
002912 ** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY
002913 ** and write an error message to it. Then return SQLITE_ERROR.
002914 */
002915 #ifndef SQLITE_OMIT_FOREIGN_KEY
002916 int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
002917 sqlite3 *db = p->db;
002918 if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0)
002919 || (!deferred && p->nFkConstraint>0)
002920 ){
002921 p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;
002922 p->errorAction = OE_Abort;
002923 sqlite3VdbeError(p, "FOREIGN KEY constraint failed");
002924 return SQLITE_ERROR;
002925 }
002926 return SQLITE_OK;
002927 }
002928 #endif
002929
002930 /*
002931 ** This routine is called the when a VDBE tries to halt. If the VDBE
002932 ** has made changes and is in autocommit mode, then commit those
002933 ** changes. If a rollback is needed, then do the rollback.
002934 **
002935 ** This routine is the only way to move the state of a VM from
002936 ** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to
002937 ** call this on a VM that is in the SQLITE_MAGIC_HALT state.
002938 **
002939 ** Return an error code. If the commit could not complete because of
002940 ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it
002941 ** means the close did not happen and needs to be repeated.
002942 */
002943 int sqlite3VdbeHalt(Vdbe *p){
002944 int rc; /* Used to store transient return codes */
002945 sqlite3 *db = p->db;
002946
002947 /* This function contains the logic that determines if a statement or
002948 ** transaction will be committed or rolled back as a result of the
002949 ** execution of this virtual machine.
002950 **
002951 ** If any of the following errors occur:
002952 **
002953 ** SQLITE_NOMEM
002954 ** SQLITE_IOERR
002955 ** SQLITE_FULL
002956 ** SQLITE_INTERRUPT
002957 **
002958 ** Then the internal cache might have been left in an inconsistent
002959 ** state. We need to rollback the statement transaction, if there is
002960 ** one, or the complete transaction if there is no statement transaction.
002961 */
002962
002963 if( p->magic!=VDBE_MAGIC_RUN ){
002964 return SQLITE_OK;
002965 }
002966 if( db->mallocFailed ){
002967 p->rc = SQLITE_NOMEM_BKPT;
002968 }
002969 closeAllCursors(p);
002970 checkActiveVdbeCnt(db);
002971
002972 /* No commit or rollback needed if the program never started or if the
002973 ** SQL statement does not read or write a database file. */
002974 if( p->pc>=0 && p->bIsReader ){
002975 int mrc; /* Primary error code from p->rc */
002976 int eStatementOp = 0;
002977 int isSpecialError; /* Set to true if a 'special' error */
002978
002979 /* Lock all btrees used by the statement */
002980 sqlite3VdbeEnter(p);
002981
002982 /* Check for one of the special errors */
002983 mrc = p->rc & 0xff;
002984 isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR
002985 || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL;
002986 if( isSpecialError ){
002987 /* If the query was read-only and the error code is SQLITE_INTERRUPT,
002988 ** no rollback is necessary. Otherwise, at least a savepoint
002989 ** transaction must be rolled back to restore the database to a
002990 ** consistent state.
002991 **
002992 ** Even if the statement is read-only, it is important to perform
002993 ** a statement or transaction rollback operation. If the error
002994 ** occurred while writing to the journal, sub-journal or database
002995 ** file as part of an effort to free up cache space (see function
002996 ** pagerStress() in pager.c), the rollback is required to restore
002997 ** the pager to a consistent state.
002998 */
002999 if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){
003000 if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){
003001 eStatementOp = SAVEPOINT_ROLLBACK;
003002 }else{
003003 /* We are forced to roll back the active transaction. Before doing
003004 ** so, abort any other statements this handle currently has active.
003005 */
003006 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
003007 sqlite3CloseSavepoints(db);
003008 db->autoCommit = 1;
003009 p->nChange = 0;
003010 }
003011 }
003012 }
003013
003014 /* Check for immediate foreign key violations. */
003015 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
003016 sqlite3VdbeCheckFk(p, 0);
003017 }
003018
003019 /* If the auto-commit flag is set and this is the only active writer
003020 ** VM, then we do either a commit or rollback of the current transaction.
003021 **
003022 ** Note: This block also runs if one of the special errors handled
003023 ** above has occurred.
003024 */
003025 if( !sqlite3VtabInSync(db)
003026 && db->autoCommit
003027 && db->nVdbeWrite==(p->readOnly==0)
003028 ){
003029 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
003030 rc = sqlite3VdbeCheckFk(p, 1);
003031 if( rc!=SQLITE_OK ){
003032 if( NEVER(p->readOnly) ){
003033 sqlite3VdbeLeave(p);
003034 return SQLITE_ERROR;
003035 }
003036 rc = SQLITE_CONSTRAINT_FOREIGNKEY;
003037 }else{
003038 /* The auto-commit flag is true, the vdbe program was successful
003039 ** or hit an 'OR FAIL' constraint and there are no deferred foreign
003040 ** key constraints to hold up the transaction. This means a commit
003041 ** is required. */
003042 rc = vdbeCommit(db, p);
003043 }
003044 if( rc==SQLITE_BUSY && p->readOnly ){
003045 sqlite3VdbeLeave(p);
003046 return SQLITE_BUSY;
003047 }else if( rc!=SQLITE_OK ){
003048 p->rc = rc;
003049 sqlite3RollbackAll(db, SQLITE_OK);
003050 p->nChange = 0;
003051 }else{
003052 db->nDeferredCons = 0;
003053 db->nDeferredImmCons = 0;
003054 db->flags &= ~(u64)SQLITE_DeferFKs;
003055 sqlite3CommitInternalChanges(db);
003056 }
003057 }else{
003058 sqlite3RollbackAll(db, SQLITE_OK);
003059 p->nChange = 0;
003060 }
003061 db->nStatement = 0;
003062 }else if( eStatementOp==0 ){
003063 if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
003064 eStatementOp = SAVEPOINT_RELEASE;
003065 }else if( p->errorAction==OE_Abort ){
003066 eStatementOp = SAVEPOINT_ROLLBACK;
003067 }else{
003068 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
003069 sqlite3CloseSavepoints(db);
003070 db->autoCommit = 1;
003071 p->nChange = 0;
003072 }
003073 }
003074
003075 /* If eStatementOp is non-zero, then a statement transaction needs to
003076 ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to
003077 ** do so. If this operation returns an error, and the current statement
003078 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
003079 ** current statement error code.
003080 */
003081 if( eStatementOp ){
003082 rc = sqlite3VdbeCloseStatement(p, eStatementOp);
003083 if( rc ){
003084 if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
003085 p->rc = rc;
003086 sqlite3DbFree(db, p->zErrMsg);
003087 p->zErrMsg = 0;
003088 }
003089 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
003090 sqlite3CloseSavepoints(db);
003091 db->autoCommit = 1;
003092 p->nChange = 0;
003093 }
003094 }
003095
003096 /* If this was an INSERT, UPDATE or DELETE and no statement transaction
003097 ** has been rolled back, update the database connection change-counter.
003098 */
003099 if( p->changeCntOn ){
003100 if( eStatementOp!=SAVEPOINT_ROLLBACK ){
003101 sqlite3VdbeSetChanges(db, p->nChange);
003102 }else{
003103 sqlite3VdbeSetChanges(db, 0);
003104 }
003105 p->nChange = 0;
003106 }
003107
003108 /* Release the locks */
003109 sqlite3VdbeLeave(p);
003110 }
003111
003112 /* We have successfully halted and closed the VM. Record this fact. */
003113 if( p->pc>=0 ){
003114 db->nVdbeActive--;
003115 if( !p->readOnly ) db->nVdbeWrite--;
003116 if( p->bIsReader ) db->nVdbeRead--;
003117 assert( db->nVdbeActive>=db->nVdbeRead );
003118 assert( db->nVdbeRead>=db->nVdbeWrite );
003119 assert( db->nVdbeWrite>=0 );
003120 }
003121 p->magic = VDBE_MAGIC_HALT;
003122 checkActiveVdbeCnt(db);
003123 if( db->mallocFailed ){
003124 p->rc = SQLITE_NOMEM_BKPT;
003125 }
003126
003127 /* If the auto-commit flag is set to true, then any locks that were held
003128 ** by connection db have now been released. Call sqlite3ConnectionUnlocked()
003129 ** to invoke any required unlock-notify callbacks.
003130 */
003131 if( db->autoCommit ){
003132 sqlite3ConnectionUnlocked(db);
003133 }
003134
003135 assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 );
003136 return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
003137 }
003138
003139
003140 /*
003141 ** Each VDBE holds the result of the most recent sqlite3_step() call
003142 ** in p->rc. This routine sets that result back to SQLITE_OK.
003143 */
003144 void sqlite3VdbeResetStepResult(Vdbe *p){
003145 p->rc = SQLITE_OK;
003146 }
003147
003148 /*
003149 ** Copy the error code and error message belonging to the VDBE passed
003150 ** as the first argument to its database handle (so that they will be
003151 ** returned by calls to sqlite3_errcode() and sqlite3_errmsg()).
003152 **
003153 ** This function does not clear the VDBE error code or message, just
003154 ** copies them to the database handle.
003155 */
003156 int sqlite3VdbeTransferError(Vdbe *p){
003157 sqlite3 *db = p->db;
003158 int rc = p->rc;
003159 if( p->zErrMsg ){
003160 db->bBenignMalloc++;
003161 sqlite3BeginBenignMalloc();
003162 if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
003163 sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
003164 sqlite3EndBenignMalloc();
003165 db->bBenignMalloc--;
003166 }else if( db->pErr ){
003167 sqlite3ValueSetNull(db->pErr);
003168 }
003169 db->errCode = rc;
003170 return rc;
003171 }
003172
003173 #ifdef SQLITE_ENABLE_SQLLOG
003174 /*
003175 ** If an SQLITE_CONFIG_SQLLOG hook is registered and the VM has been run,
003176 ** invoke it.
003177 */
003178 static void vdbeInvokeSqllog(Vdbe *v){
003179 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
003180 char *zExpanded = sqlite3VdbeExpandSql(v, v->zSql);
003181 assert( v->db->init.busy==0 );
003182 if( zExpanded ){
003183 sqlite3GlobalConfig.xSqllog(
003184 sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1
003185 );
003186 sqlite3DbFree(v->db, zExpanded);
003187 }
003188 }
003189 }
003190 #else
003191 # define vdbeInvokeSqllog(x)
003192 #endif
003193
003194 /*
003195 ** Clean up a VDBE after execution but do not delete the VDBE just yet.
003196 ** Write any error messages into *pzErrMsg. Return the result code.
003197 **
003198 ** After this routine is run, the VDBE should be ready to be executed
003199 ** again.
003200 **
003201 ** To look at it another way, this routine resets the state of the
003202 ** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to
003203 ** VDBE_MAGIC_INIT.
003204 */
003205 int sqlite3VdbeReset(Vdbe *p){
003206 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
003207 int i;
003208 #endif
003209
003210 sqlite3 *db;
003211 db = p->db;
003212
003213 /* If the VM did not run to completion or if it encountered an
003214 ** error, then it might not have been halted properly. So halt
003215 ** it now.
003216 */
003217 sqlite3VdbeHalt(p);
003218
003219 /* If the VDBE has been run even partially, then transfer the error code
003220 ** and error message from the VDBE into the main database structure. But
003221 ** if the VDBE has just been set to run but has not actually executed any
003222 ** instructions yet, leave the main database error information unchanged.
003223 */
003224 if( p->pc>=0 ){
003225 vdbeInvokeSqllog(p);
003226 sqlite3VdbeTransferError(p);
003227 if( p->runOnlyOnce ) p->expired = 1;
003228 }else if( p->rc && p->expired ){
003229 /* The expired flag was set on the VDBE before the first call
003230 ** to sqlite3_step(). For consistency (since sqlite3_step() was
003231 ** called), set the database error in this case as well.
003232 */
003233 sqlite3ErrorWithMsg(db, p->rc, p->zErrMsg ? "%s" : 0, p->zErrMsg);
003234 }
003235
003236 /* Reset register contents and reclaim error message memory.
003237 */
003238 #ifdef SQLITE_DEBUG
003239 /* Execute assert() statements to ensure that the Vdbe.apCsr[] and
003240 ** Vdbe.aMem[] arrays have already been cleaned up. */
003241 if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
003242 if( p->aMem ){
003243 for(i=0; i<p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
003244 }
003245 #endif
003246 sqlite3DbFree(db, p->zErrMsg);
003247 p->zErrMsg = 0;
003248 p->pResultSet = 0;
003249 #ifdef SQLITE_DEBUG
003250 p->nWrite = 0;
003251 #endif
003252
003253 /* Save profiling information from this VDBE run.
003254 */
003255 #ifdef VDBE_PROFILE
003256 {
003257 FILE *out = fopen("vdbe_profile.out", "a");
003258 if( out ){
003259 fprintf(out, "---- ");
003260 for(i=0; i<p->nOp; i++){
003261 fprintf(out, "%02x", p->aOp[i].opcode);
003262 }
003263 fprintf(out, "\n");
003264 if( p->zSql ){
003265 char c, pc = 0;
003266 fprintf(out, "-- ");
003267 for(i=0; (c = p->zSql[i])!=0; i++){
003268 if( pc=='\n' ) fprintf(out, "-- ");
003269 putc(c, out);
003270 pc = c;
003271 }
003272 if( pc!='\n' ) fprintf(out, "\n");
003273 }
003274 for(i=0; i<p->nOp; i++){
003275 char zHdr[100];
003276 sqlite3_snprintf(sizeof(zHdr), zHdr, "%6u %12llu %8llu ",
003277 p->aOp[i].cnt,
003278 p->aOp[i].cycles,
003279 p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
003280 );
003281 fprintf(out, "%s", zHdr);
003282 sqlite3VdbePrintOp(out, i, &p->aOp[i]);
003283 }
003284 fclose(out);
003285 }
003286 }
003287 #endif
003288 p->magic = VDBE_MAGIC_RESET;
003289 return p->rc & db->errMask;
003290 }
003291
003292 /*
003293 ** Clean up and delete a VDBE after execution. Return an integer which is
003294 ** the result code. Write any error message text into *pzErrMsg.
003295 */
003296 int sqlite3VdbeFinalize(Vdbe *p){
003297 int rc = SQLITE_OK;
003298 if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){
003299 rc = sqlite3VdbeReset(p);
003300 assert( (rc & p->db->errMask)==rc );
003301 }
003302 sqlite3VdbeDelete(p);
003303 return rc;
003304 }
003305
003306 /*
003307 ** If parameter iOp is less than zero, then invoke the destructor for
003308 ** all auxiliary data pointers currently cached by the VM passed as
003309 ** the first argument.
003310 **
003311 ** Or, if iOp is greater than or equal to zero, then the destructor is
003312 ** only invoked for those auxiliary data pointers created by the user
003313 ** function invoked by the OP_Function opcode at instruction iOp of
003314 ** VM pVdbe, and only then if:
003315 **
003316 ** * the associated function parameter is the 32nd or later (counting
003317 ** from left to right), or
003318 **
003319 ** * the corresponding bit in argument mask is clear (where the first
003320 ** function parameter corresponds to bit 0 etc.).
003321 */
003322 void sqlite3VdbeDeleteAuxData(sqlite3 *db, AuxData **pp, int iOp, int mask){
003323 while( *pp ){
003324 AuxData *pAux = *pp;
003325 if( (iOp<0)
003326 || (pAux->iAuxOp==iOp
003327 && pAux->iAuxArg>=0
003328 && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg))))
003329 ){
003330 testcase( pAux->iAuxArg==31 );
003331 if( pAux->xDeleteAux ){
003332 pAux->xDeleteAux(pAux->pAux);
003333 }
003334 *pp = pAux->pNextAux;
003335 sqlite3DbFree(db, pAux);
003336 }else{
003337 pp= &pAux->pNextAux;
003338 }
003339 }
003340 }
003341
003342 /*
003343 ** Free all memory associated with the Vdbe passed as the second argument,
003344 ** except for object itself, which is preserved.
003345 **
003346 ** The difference between this function and sqlite3VdbeDelete() is that
003347 ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
003348 ** the database connection and frees the object itself.
003349 */
003350 void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
003351 SubProgram *pSub, *pNext;
003352 assert( p->db==0 || p->db==db );
003353 releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
003354 for(pSub=p->pProgram; pSub; pSub=pNext){
003355 pNext = pSub->pNext;
003356 vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
003357 sqlite3DbFree(db, pSub);
003358 }
003359 if( p->magic!=VDBE_MAGIC_INIT ){
003360 releaseMemArray(p->aVar, p->nVar);
003361 sqlite3DbFree(db, p->pVList);
003362 sqlite3DbFree(db, p->pFree);
003363 }
003364 vdbeFreeOpArray(db, p->aOp, p->nOp);
003365 sqlite3DbFree(db, p->aColName);
003366 sqlite3DbFree(db, p->zSql);
003367 #ifdef SQLITE_ENABLE_NORMALIZE
003368 sqlite3DbFree(db, p->zNormSql);
003369 {
003370 DblquoteStr *pThis, *pNext;
003371 for(pThis=p->pDblStr; pThis; pThis=pNext){
003372 pNext = pThis->pNextStr;
003373 sqlite3DbFree(db, pThis);
003374 }
003375 }
003376 #endif
003377 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
003378 {
003379 int i;
003380 for(i=0; i<p->nScan; i++){
003381 sqlite3DbFree(db, p->aScan[i].zName);
003382 }
003383 sqlite3DbFree(db, p->aScan);
003384 }
003385 #endif
003386 }
003387
003388 /*
003389 ** Delete an entire VDBE.
003390 */
003391 void sqlite3VdbeDelete(Vdbe *p){
003392 sqlite3 *db;
003393
003394 assert( p!=0 );
003395 db = p->db;
003396 assert( sqlite3_mutex_held(db->mutex) );
003397 sqlite3VdbeClearObject(db, p);
003398 if( p->pPrev ){
003399 p->pPrev->pNext = p->pNext;
003400 }else{
003401 assert( db->pVdbe==p );
003402 db->pVdbe = p->pNext;
003403 }
003404 if( p->pNext ){
003405 p->pNext->pPrev = p->pPrev;
003406 }
003407 p->magic = VDBE_MAGIC_DEAD;
003408 p->db = 0;
003409 sqlite3DbFreeNN(db, p);
003410 }
003411
003412 /*
003413 ** The cursor "p" has a pending seek operation that has not yet been
003414 ** carried out. Seek the cursor now. If an error occurs, return
003415 ** the appropriate error code.
003416 */
003417 int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor *p){
003418 int res, rc;
003419 #ifdef SQLITE_TEST
003420 extern int sqlite3_search_count;
003421 #endif
003422 assert( p->deferredMoveto );
003423 assert( p->isTable );
003424 assert( p->eCurType==CURTYPE_BTREE );
003425 rc = sqlite3BtreeMovetoUnpacked(p->uc.pCursor, 0, p->movetoTarget, 0, &res);
003426 if( rc ) return rc;
003427 if( res!=0 ) return SQLITE_CORRUPT_BKPT;
003428 #ifdef SQLITE_TEST
003429 sqlite3_search_count++;
003430 #endif
003431 p->deferredMoveto = 0;
003432 p->cacheStatus = CACHE_STALE;
003433 return SQLITE_OK;
003434 }
003435
003436 /*
003437 ** Something has moved cursor "p" out of place. Maybe the row it was
003438 ** pointed to was deleted out from under it. Or maybe the btree was
003439 ** rebalanced. Whatever the cause, try to restore "p" to the place it
003440 ** is supposed to be pointing. If the row was deleted out from under the
003441 ** cursor, set the cursor to point to a NULL row.
003442 */
003443 static int SQLITE_NOINLINE handleMovedCursor(VdbeCursor *p){
003444 int isDifferentRow, rc;
003445 assert( p->eCurType==CURTYPE_BTREE );
003446 assert( p->uc.pCursor!=0 );
003447 assert( sqlite3BtreeCursorHasMoved(p->uc.pCursor) );
003448 rc = sqlite3BtreeCursorRestore(p->uc.pCursor, &isDifferentRow);
003449 p->cacheStatus = CACHE_STALE;
003450 if( isDifferentRow ) p->nullRow = 1;
003451 return rc;
003452 }
003453
003454 /*
003455 ** Check to ensure that the cursor is valid. Restore the cursor
003456 ** if need be. Return any I/O error from the restore operation.
003457 */
003458 int sqlite3VdbeCursorRestore(VdbeCursor *p){
003459 assert( p->eCurType==CURTYPE_BTREE );
003460 if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){
003461 return handleMovedCursor(p);
003462 }
003463 return SQLITE_OK;
003464 }
003465
003466 /*
003467 ** Make sure the cursor p is ready to read or write the row to which it
003468 ** was last positioned. Return an error code if an OOM fault or I/O error
003469 ** prevents us from positioning the cursor to its correct position.
003470 **
003471 ** If a MoveTo operation is pending on the given cursor, then do that
003472 ** MoveTo now. If no move is pending, check to see if the row has been
003473 ** deleted out from under the cursor and if it has, mark the row as
003474 ** a NULL row.
003475 **
003476 ** If the cursor is already pointing to the correct row and that row has
003477 ** not been deleted out from under the cursor, then this routine is a no-op.
003478 */
003479 int sqlite3VdbeCursorMoveto(VdbeCursor **pp, int *piCol){
003480 VdbeCursor *p = *pp;
003481 assert( p->eCurType==CURTYPE_BTREE || p->eCurType==CURTYPE_PSEUDO );
003482 if( p->deferredMoveto ){
003483 int iMap;
003484 if( p->aAltMap && (iMap = p->aAltMap[1+*piCol])>0 ){
003485 *pp = p->pAltCursor;
003486 *piCol = iMap - 1;
003487 return SQLITE_OK;
003488 }
003489 return sqlite3VdbeFinishMoveto(p);
003490 }
003491 if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){
003492 return handleMovedCursor(p);
003493 }
003494 return SQLITE_OK;
003495 }
003496
003497 /*
003498 ** The following functions:
003499 **
003500 ** sqlite3VdbeSerialType()
003501 ** sqlite3VdbeSerialTypeLen()
003502 ** sqlite3VdbeSerialLen()
003503 ** sqlite3VdbeSerialPut()
003504 ** sqlite3VdbeSerialGet()
003505 **
003506 ** encapsulate the code that serializes values for storage in SQLite
003507 ** data and index records. Each serialized value consists of a
003508 ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
003509 ** integer, stored as a varint.
003510 **
003511 ** In an SQLite index record, the serial type is stored directly before
003512 ** the blob of data that it corresponds to. In a table record, all serial
003513 ** types are stored at the start of the record, and the blobs of data at
003514 ** the end. Hence these functions allow the caller to handle the
003515 ** serial-type and data blob separately.
003516 **
003517 ** The following table describes the various storage classes for data:
003518 **
003519 ** serial type bytes of data type
003520 ** -------------- --------------- ---------------
003521 ** 0 0 NULL
003522 ** 1 1 signed integer
003523 ** 2 2 signed integer
003524 ** 3 3 signed integer
003525 ** 4 4 signed integer
003526 ** 5 6 signed integer
003527 ** 6 8 signed integer
003528 ** 7 8 IEEE float
003529 ** 8 0 Integer constant 0
003530 ** 9 0 Integer constant 1
003531 ** 10,11 reserved for expansion
003532 ** N>=12 and even (N-12)/2 BLOB
003533 ** N>=13 and odd (N-13)/2 text
003534 **
003535 ** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions
003536 ** of SQLite will not understand those serial types.
003537 */
003538
003539 #if 0 /* Inlined into the OP_MakeRecord opcode */
003540 /*
003541 ** Return the serial-type for the value stored in pMem.
003542 **
003543 ** This routine might convert a large MEM_IntReal value into MEM_Real.
003544 **
003545 ** 2019-07-11: The primary user of this subroutine was the OP_MakeRecord
003546 ** opcode in the byte-code engine. But by moving this routine in-line, we
003547 ** can omit some redundant tests and make that opcode a lot faster. So
003548 ** this routine is now only used by the STAT3 logic and STAT3 support has
003549 ** ended. The code is kept here for historical reference only.
003550 */
003551 u32 sqlite3VdbeSerialType(Mem *pMem, int file_format, u32 *pLen){
003552 int flags = pMem->flags;
003553 u32 n;
003554
003555 assert( pLen!=0 );
003556 if( flags&MEM_Null ){
003557 *pLen = 0;
003558 return 0;
003559 }
003560 if( flags&(MEM_Int|MEM_IntReal) ){
003561 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
003562 # define MAX_6BYTE ((((i64)0x00008000)<<32)-1)
003563 i64 i = pMem->u.i;
003564 u64 u;
003565 testcase( flags & MEM_Int );
003566 testcase( flags & MEM_IntReal );
003567 if( i<0 ){
003568 u = ~i;
003569 }else{
003570 u = i;
003571 }
003572 if( u<=127 ){
003573 if( (i&1)==i && file_format>=4 ){
003574 *pLen = 0;
003575 return 8+(u32)u;
003576 }else{
003577 *pLen = 1;
003578 return 1;
003579 }
003580 }
003581 if( u<=32767 ){ *pLen = 2; return 2; }
003582 if( u<=8388607 ){ *pLen = 3; return 3; }
003583 if( u<=2147483647 ){ *pLen = 4; return 4; }
003584 if( u<=MAX_6BYTE ){ *pLen = 6; return 5; }
003585 *pLen = 8;
003586 if( flags&MEM_IntReal ){
003587 /* If the value is IntReal and is going to take up 8 bytes to store
003588 ** as an integer, then we might as well make it an 8-byte floating
003589 ** point value */
003590 pMem->u.r = (double)pMem->u.i;
003591 pMem->flags &= ~MEM_IntReal;
003592 pMem->flags |= MEM_Real;
003593 return 7;
003594 }
003595 return 6;
003596 }
003597 if( flags&MEM_Real ){
003598 *pLen = 8;
003599 return 7;
003600 }
003601 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
003602 assert( pMem->n>=0 );
003603 n = (u32)pMem->n;
003604 if( flags & MEM_Zero ){
003605 n += pMem->u.nZero;
003606 }
003607 *pLen = n;
003608 return ((n*2) + 12 + ((flags&MEM_Str)!=0));
003609 }
003610 #endif /* inlined into OP_MakeRecord */
003611
003612 /*
003613 ** The sizes for serial types less than 128
003614 */
003615 static const u8 sqlite3SmallTypeSizes[] = {
003616 /* 0 1 2 3 4 5 6 7 8 9 */
003617 /* 0 */ 0, 1, 2, 3, 4, 6, 8, 8, 0, 0,
003618 /* 10 */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3,
003619 /* 20 */ 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
003620 /* 30 */ 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,
003621 /* 40 */ 14, 14, 15, 15, 16, 16, 17, 17, 18, 18,
003622 /* 50 */ 19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
003623 /* 60 */ 24, 24, 25, 25, 26, 26, 27, 27, 28, 28,
003624 /* 70 */ 29, 29, 30, 30, 31, 31, 32, 32, 33, 33,
003625 /* 80 */ 34, 34, 35, 35, 36, 36, 37, 37, 38, 38,
003626 /* 90 */ 39, 39, 40, 40, 41, 41, 42, 42, 43, 43,
003627 /* 100 */ 44, 44, 45, 45, 46, 46, 47, 47, 48, 48,
003628 /* 110 */ 49, 49, 50, 50, 51, 51, 52, 52, 53, 53,
003629 /* 120 */ 54, 54, 55, 55, 56, 56, 57, 57
003630 };
003631
003632 /*
003633 ** Return the length of the data corresponding to the supplied serial-type.
003634 */
003635 u32 sqlite3VdbeSerialTypeLen(u32 serial_type){
003636 if( serial_type>=128 ){
003637 return (serial_type-12)/2;
003638 }else{
003639 assert( serial_type<12
003640 || sqlite3SmallTypeSizes[serial_type]==(serial_type - 12)/2 );
003641 return sqlite3SmallTypeSizes[serial_type];
003642 }
003643 }
003644 u8 sqlite3VdbeOneByteSerialTypeLen(u8 serial_type){
003645 assert( serial_type<128 );
003646 return sqlite3SmallTypeSizes[serial_type];
003647 }
003648
003649 /*
003650 ** If we are on an architecture with mixed-endian floating
003651 ** points (ex: ARM7) then swap the lower 4 bytes with the
003652 ** upper 4 bytes. Return the result.
003653 **
003654 ** For most architectures, this is a no-op.
003655 **
003656 ** (later): It is reported to me that the mixed-endian problem
003657 ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
003658 ** that early versions of GCC stored the two words of a 64-bit
003659 ** float in the wrong order. And that error has been propagated
003660 ** ever since. The blame is not necessarily with GCC, though.
003661 ** GCC might have just copying the problem from a prior compiler.
003662 ** I am also told that newer versions of GCC that follow a different
003663 ** ABI get the byte order right.
003664 **
003665 ** Developers using SQLite on an ARM7 should compile and run their
003666 ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
003667 ** enabled, some asserts below will ensure that the byte order of
003668 ** floating point values is correct.
003669 **
003670 ** (2007-08-30) Frank van Vugt has studied this problem closely
003671 ** and has send his findings to the SQLite developers. Frank
003672 ** writes that some Linux kernels offer floating point hardware
003673 ** emulation that uses only 32-bit mantissas instead of a full
003674 ** 48-bits as required by the IEEE standard. (This is the
003675 ** CONFIG_FPE_FASTFPE option.) On such systems, floating point
003676 ** byte swapping becomes very complicated. To avoid problems,
003677 ** the necessary byte swapping is carried out using a 64-bit integer
003678 ** rather than a 64-bit float. Frank assures us that the code here
003679 ** works for him. We, the developers, have no way to independently
003680 ** verify this, but Frank seems to know what he is talking about
003681 ** so we trust him.
003682 */
003683 #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
003684 static u64 floatSwap(u64 in){
003685 union {
003686 u64 r;
003687 u32 i[2];
003688 } u;
003689 u32 t;
003690
003691 u.r = in;
003692 t = u.i[0];
003693 u.i[0] = u.i[1];
003694 u.i[1] = t;
003695 return u.r;
003696 }
003697 # define swapMixedEndianFloat(X) X = floatSwap(X)
003698 #else
003699 # define swapMixedEndianFloat(X)
003700 #endif
003701
003702 /*
003703 ** Write the serialized data blob for the value stored in pMem into
003704 ** buf. It is assumed that the caller has allocated sufficient space.
003705 ** Return the number of bytes written.
003706 **
003707 ** nBuf is the amount of space left in buf[]. The caller is responsible
003708 ** for allocating enough space to buf[] to hold the entire field, exclusive
003709 ** of the pMem->u.nZero bytes for a MEM_Zero value.
003710 **
003711 ** Return the number of bytes actually written into buf[]. The number
003712 ** of bytes in the zero-filled tail is included in the return value only
003713 ** if those bytes were zeroed in buf[].
003714 */
003715 u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){
003716 u32 len;
003717
003718 /* Integer and Real */
003719 if( serial_type<=7 && serial_type>0 ){
003720 u64 v;
003721 u32 i;
003722 if( serial_type==7 ){
003723 assert( sizeof(v)==sizeof(pMem->u.r) );
003724 memcpy(&v, &pMem->u.r, sizeof(v));
003725 swapMixedEndianFloat(v);
003726 }else{
003727 v = pMem->u.i;
003728 }
003729 len = i = sqlite3SmallTypeSizes[serial_type];
003730 assert( i>0 );
003731 do{
003732 buf[--i] = (u8)(v&0xFF);
003733 v >>= 8;
003734 }while( i );
003735 return len;
003736 }
003737
003738 /* String or blob */
003739 if( serial_type>=12 ){
003740 assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
003741 == (int)sqlite3VdbeSerialTypeLen(serial_type) );
003742 len = pMem->n;
003743 if( len>0 ) memcpy(buf, pMem->z, len);
003744 return len;
003745 }
003746
003747 /* NULL or constants 0 or 1 */
003748 return 0;
003749 }
003750
003751 /* Input "x" is a sequence of unsigned characters that represent a
003752 ** big-endian integer. Return the equivalent native integer
003753 */
003754 #define ONE_BYTE_INT(x) ((i8)(x)[0])
003755 #define TWO_BYTE_INT(x) (256*(i8)((x)[0])|(x)[1])
003756 #define THREE_BYTE_INT(x) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2])
003757 #define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
003758 #define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
003759
003760 /*
003761 ** Deserialize the data blob pointed to by buf as serial type serial_type
003762 ** and store the result in pMem. Return the number of bytes read.
003763 **
003764 ** This function is implemented as two separate routines for performance.
003765 ** The few cases that require local variables are broken out into a separate
003766 ** routine so that in most cases the overhead of moving the stack pointer
003767 ** is avoided.
003768 */
003769 static u32 serialGet(
003770 const unsigned char *buf, /* Buffer to deserialize from */
003771 u32 serial_type, /* Serial type to deserialize */
003772 Mem *pMem /* Memory cell to write value into */
003773 ){
003774 u64 x = FOUR_BYTE_UINT(buf);
003775 u32 y = FOUR_BYTE_UINT(buf+4);
003776 x = (x<<32) + y;
003777 if( serial_type==6 ){
003778 /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit
003779 ** twos-complement integer. */
003780 pMem->u.i = *(i64*)&x;
003781 pMem->flags = MEM_Int;
003782 testcase( pMem->u.i<0 );
003783 }else{
003784 /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit
003785 ** floating point number. */
003786 #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
003787 /* Verify that integers and floating point values use the same
003788 ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
003789 ** defined that 64-bit floating point values really are mixed
003790 ** endian.
003791 */
003792 static const u64 t1 = ((u64)0x3ff00000)<<32;
003793 static const double r1 = 1.0;
003794 u64 t2 = t1;
003795 swapMixedEndianFloat(t2);
003796 assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
003797 #endif
003798 assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
003799 swapMixedEndianFloat(x);
003800 memcpy(&pMem->u.r, &x, sizeof(x));
003801 pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real;
003802 }
003803 return 8;
003804 }
003805 u32 sqlite3VdbeSerialGet(
003806 const unsigned char *buf, /* Buffer to deserialize from */
003807 u32 serial_type, /* Serial type to deserialize */
003808 Mem *pMem /* Memory cell to write value into */
003809 ){
003810 switch( serial_type ){
003811 case 10: { /* Internal use only: NULL with virtual table
003812 ** UPDATE no-change flag set */
003813 pMem->flags = MEM_Null|MEM_Zero;
003814 pMem->n = 0;
003815 pMem->u.nZero = 0;
003816 break;
003817 }
003818 case 11: /* Reserved for future use */
003819 case 0: { /* Null */
003820 /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */
003821 pMem->flags = MEM_Null;
003822 break;
003823 }
003824 case 1: {
003825 /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement
003826 ** integer. */
003827 pMem->u.i = ONE_BYTE_INT(buf);
003828 pMem->flags = MEM_Int;
003829 testcase( pMem->u.i<0 );
003830 return 1;
003831 }
003832 case 2: { /* 2-byte signed integer */
003833 /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit
003834 ** twos-complement integer. */
003835 pMem->u.i = TWO_BYTE_INT(buf);
003836 pMem->flags = MEM_Int;
003837 testcase( pMem->u.i<0 );
003838 return 2;
003839 }
003840 case 3: { /* 3-byte signed integer */
003841 /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit
003842 ** twos-complement integer. */
003843 pMem->u.i = THREE_BYTE_INT(buf);
003844 pMem->flags = MEM_Int;
003845 testcase( pMem->u.i<0 );
003846 return 3;
003847 }
003848 case 4: { /* 4-byte signed integer */
003849 /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit
003850 ** twos-complement integer. */
003851 pMem->u.i = FOUR_BYTE_INT(buf);
003852 #ifdef __HP_cc
003853 /* Work around a sign-extension bug in the HP compiler for HP/UX */
003854 if( buf[0]&0x80 ) pMem->u.i |= 0xffffffff80000000LL;
003855 #endif
003856 pMem->flags = MEM_Int;
003857 testcase( pMem->u.i<0 );
003858 return 4;
003859 }
003860 case 5: { /* 6-byte signed integer */
003861 /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit
003862 ** twos-complement integer. */
003863 pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf);
003864 pMem->flags = MEM_Int;
003865 testcase( pMem->u.i<0 );
003866 return 6;
003867 }
003868 case 6: /* 8-byte signed integer */
003869 case 7: { /* IEEE floating point */
003870 /* These use local variables, so do them in a separate routine
003871 ** to avoid having to move the frame pointer in the common case */
003872 return serialGet(buf,serial_type,pMem);
003873 }
003874 case 8: /* Integer 0 */
003875 case 9: { /* Integer 1 */
003876 /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */
003877 /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */
003878 pMem->u.i = serial_type-8;
003879 pMem->flags = MEM_Int;
003880 return 0;
003881 }
003882 default: {
003883 /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in
003884 ** length.
003885 ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and
003886 ** (N-13)/2 bytes in length. */
003887 static const u16 aFlag[] = { MEM_Blob|MEM_Ephem, MEM_Str|MEM_Ephem };
003888 pMem->z = (char *)buf;
003889 pMem->n = (serial_type-12)/2;
003890 pMem->flags = aFlag[serial_type&1];
003891 return pMem->n;
003892 }
003893 }
003894 return 0;
003895 }
003896 /*
003897 ** This routine is used to allocate sufficient space for an UnpackedRecord
003898 ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
003899 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
003900 **
003901 ** The space is either allocated using sqlite3DbMallocRaw() or from within
003902 ** the unaligned buffer passed via the second and third arguments (presumably
003903 ** stack space). If the former, then *ppFree is set to a pointer that should
003904 ** be eventually freed by the caller using sqlite3DbFree(). Or, if the
003905 ** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL
003906 ** before returning.
003907 **
003908 ** If an OOM error occurs, NULL is returned.
003909 */
003910 UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(
003911 KeyInfo *pKeyInfo /* Description of the record */
003912 ){
003913 UnpackedRecord *p; /* Unpacked record to return */
003914 int nByte; /* Number of bytes required for *p */
003915 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
003916 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
003917 if( !p ) return 0;
003918 p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
003919 assert( pKeyInfo->aSortFlags!=0 );
003920 p->pKeyInfo = pKeyInfo;
003921 p->nField = pKeyInfo->nKeyField + 1;
003922 return p;
003923 }
003924
003925 /*
003926 ** Given the nKey-byte encoding of a record in pKey[], populate the
003927 ** UnpackedRecord structure indicated by the fourth argument with the
003928 ** contents of the decoded record.
003929 */
003930 void sqlite3VdbeRecordUnpack(
003931 KeyInfo *pKeyInfo, /* Information about the record format */
003932 int nKey, /* Size of the binary record */
003933 const void *pKey, /* The binary record */
003934 UnpackedRecord *p /* Populate this structure before returning. */
003935 ){
003936 const unsigned char *aKey = (const unsigned char *)pKey;
003937 u32 d;
003938 u32 idx; /* Offset in aKey[] to read from */
003939 u16 u; /* Unsigned loop counter */
003940 u32 szHdr;
003941 Mem *pMem = p->aMem;
003942
003943 p->default_rc = 0;
003944 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
003945 idx = getVarint32(aKey, szHdr);
003946 d = szHdr;
003947 u = 0;
003948 while( idx<szHdr && d<=(u32)nKey ){
003949 u32 serial_type;
003950
003951 idx += getVarint32(&aKey[idx], serial_type);
003952 pMem->enc = pKeyInfo->enc;
003953 pMem->db = pKeyInfo->db;
003954 /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
003955 pMem->szMalloc = 0;
003956 pMem->z = 0;
003957 d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem);
003958 pMem++;
003959 if( (++u)>=p->nField ) break;
003960 }
003961 if( d>(u32)nKey && u ){
003962 assert( CORRUPT_DB );
003963 /* In a corrupt record entry, the last pMem might have been set up using
003964 ** uninitialized memory. Overwrite its value with NULL, to prevent
003965 ** warnings from MSAN. */
003966 sqlite3VdbeMemSetNull(pMem-1);
003967 }
003968 assert( u<=pKeyInfo->nKeyField + 1 );
003969 p->nField = u;
003970 }
003971
003972 #ifdef SQLITE_DEBUG
003973 /*
003974 ** This function compares two index or table record keys in the same way
003975 ** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(),
003976 ** this function deserializes and compares values using the
003977 ** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
003978 ** in assert() statements to ensure that the optimized code in
003979 ** sqlite3VdbeRecordCompare() returns results with these two primitives.
003980 **
003981 ** Return true if the result of comparison is equivalent to desiredResult.
003982 ** Return false if there is a disagreement.
003983 */
003984 static int vdbeRecordCompareDebug(
003985 int nKey1, const void *pKey1, /* Left key */
003986 const UnpackedRecord *pPKey2, /* Right key */
003987 int desiredResult /* Correct answer */
003988 ){
003989 u32 d1; /* Offset into aKey[] of next data element */
003990 u32 idx1; /* Offset into aKey[] of next header element */
003991 u32 szHdr1; /* Number of bytes in header */
003992 int i = 0;
003993 int rc = 0;
003994 const unsigned char *aKey1 = (const unsigned char *)pKey1;
003995 KeyInfo *pKeyInfo;
003996 Mem mem1;
003997
003998 pKeyInfo = pPKey2->pKeyInfo;
003999 if( pKeyInfo->db==0 ) return 1;
004000 mem1.enc = pKeyInfo->enc;
004001 mem1.db = pKeyInfo->db;
004002 /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */
004003 VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */
004004
004005 /* Compilers may complain that mem1.u.i is potentially uninitialized.
004006 ** We could initialize it, as shown here, to silence those complaints.
004007 ** But in fact, mem1.u.i will never actually be used uninitialized, and doing
004008 ** the unnecessary initialization has a measurable negative performance
004009 ** impact, since this routine is a very high runner. And so, we choose
004010 ** to ignore the compiler warnings and leave this variable uninitialized.
004011 */
004012 /* mem1.u.i = 0; // not needed, here to silence compiler warning */
004013
004014 idx1 = getVarint32(aKey1, szHdr1);
004015 if( szHdr1>98307 ) return SQLITE_CORRUPT;
004016 d1 = szHdr1;
004017 assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB );
004018 assert( pKeyInfo->aSortFlags!=0 );
004019 assert( pKeyInfo->nKeyField>0 );
004020 assert( idx1<=szHdr1 || CORRUPT_DB );
004021 do{
004022 u32 serial_type1;
004023
004024 /* Read the serial types for the next element in each key. */
004025 idx1 += getVarint32( aKey1+idx1, serial_type1 );
004026
004027 /* Verify that there is enough key space remaining to avoid
004028 ** a buffer overread. The "d1+serial_type1+2" subexpression will
004029 ** always be greater than or equal to the amount of required key space.
004030 ** Use that approximation to avoid the more expensive call to
004031 ** sqlite3VdbeSerialTypeLen() in the common case.
004032 */
004033 if( d1+(u64)serial_type1+2>(u64)nKey1
004034 && d1+(u64)sqlite3VdbeSerialTypeLen(serial_type1)>(u64)nKey1
004035 ){
004036 break;
004037 }
004038
004039 /* Extract the values to be compared.
004040 */
004041 d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1);
004042
004043 /* Do the comparison
004044 */
004045 rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i],
004046 pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0);
004047 if( rc!=0 ){
004048 assert( mem1.szMalloc==0 ); /* See comment below */
004049 if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
004050 && ((mem1.flags & MEM_Null) || (pPKey2->aMem[i].flags & MEM_Null))
004051 ){
004052 rc = -rc;
004053 }
004054 if( pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC ){
004055 rc = -rc; /* Invert the result for DESC sort order. */
004056 }
004057 goto debugCompareEnd;
004058 }
004059 i++;
004060 }while( idx1<szHdr1 && i<pPKey2->nField );
004061
004062 /* No memory allocation is ever used on mem1. Prove this using
004063 ** the following assert(). If the assert() fails, it indicates a
004064 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).
004065 */
004066 assert( mem1.szMalloc==0 );
004067
004068 /* rc==0 here means that one of the keys ran out of fields and
004069 ** all the fields up to that point were equal. Return the default_rc
004070 ** value. */
004071 rc = pPKey2->default_rc;
004072
004073 debugCompareEnd:
004074 if( desiredResult==0 && rc==0 ) return 1;
004075 if( desiredResult<0 && rc<0 ) return 1;
004076 if( desiredResult>0 && rc>0 ) return 1;
004077 if( CORRUPT_DB ) return 1;
004078 if( pKeyInfo->db->mallocFailed ) return 1;
004079 return 0;
004080 }
004081 #endif
004082
004083 #ifdef SQLITE_DEBUG
004084 /*
004085 ** Count the number of fields (a.k.a. columns) in the record given by
004086 ** pKey,nKey. The verify that this count is less than or equal to the
004087 ** limit given by pKeyInfo->nAllField.
004088 **
004089 ** If this constraint is not satisfied, it means that the high-speed
004090 ** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will
004091 ** not work correctly. If this assert() ever fires, it probably means
004092 ** that the KeyInfo.nKeyField or KeyInfo.nAllField values were computed
004093 ** incorrectly.
004094 */
004095 static void vdbeAssertFieldCountWithinLimits(
004096 int nKey, const void *pKey, /* The record to verify */
004097 const KeyInfo *pKeyInfo /* Compare size with this KeyInfo */
004098 ){
004099 int nField = 0;
004100 u32 szHdr;
004101 u32 idx;
004102 u32 notUsed;
004103 const unsigned char *aKey = (const unsigned char*)pKey;
004104
004105 if( CORRUPT_DB ) return;
004106 idx = getVarint32(aKey, szHdr);
004107 assert( nKey>=0 );
004108 assert( szHdr<=(u32)nKey );
004109 while( idx<szHdr ){
004110 idx += getVarint32(aKey+idx, notUsed);
004111 nField++;
004112 }
004113 assert( nField <= pKeyInfo->nAllField );
004114 }
004115 #else
004116 # define vdbeAssertFieldCountWithinLimits(A,B,C)
004117 #endif
004118
004119 /*
004120 ** Both *pMem1 and *pMem2 contain string values. Compare the two values
004121 ** using the collation sequence pColl. As usual, return a negative , zero
004122 ** or positive value if *pMem1 is less than, equal to or greater than
004123 ** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);".
004124 */
004125 static int vdbeCompareMemString(
004126 const Mem *pMem1,
004127 const Mem *pMem2,
004128 const CollSeq *pColl,
004129 u8 *prcErr /* If an OOM occurs, set to SQLITE_NOMEM */
004130 ){
004131 if( pMem1->enc==pColl->enc ){
004132 /* The strings are already in the correct encoding. Call the
004133 ** comparison function directly */
004134 return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
004135 }else{
004136 int rc;
004137 const void *v1, *v2;
004138 Mem c1;
004139 Mem c2;
004140 sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null);
004141 sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null);
004142 sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
004143 sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
004144 v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
004145 v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
004146 if( (v1==0 || v2==0) ){
004147 if( prcErr ) *prcErr = SQLITE_NOMEM_BKPT;
004148 rc = 0;
004149 }else{
004150 rc = pColl->xCmp(pColl->pUser, c1.n, v1, c2.n, v2);
004151 }
004152 sqlite3VdbeMemRelease(&c1);
004153 sqlite3VdbeMemRelease(&c2);
004154 return rc;
004155 }
004156 }
004157
004158 /*
004159 ** The input pBlob is guaranteed to be a Blob that is not marked
004160 ** with MEM_Zero. Return true if it could be a zero-blob.
004161 */
004162 static int isAllZero(const char *z, int n){
004163 int i;
004164 for(i=0; i<n; i++){
004165 if( z[i] ) return 0;
004166 }
004167 return 1;
004168 }
004169
004170 /*
004171 ** Compare two blobs. Return negative, zero, or positive if the first
004172 ** is less than, equal to, or greater than the second, respectively.
004173 ** If one blob is a prefix of the other, then the shorter is the lessor.
004174 */
004175 SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){
004176 int c;
004177 int n1 = pB1->n;
004178 int n2 = pB2->n;
004179
004180 /* It is possible to have a Blob value that has some non-zero content
004181 ** followed by zero content. But that only comes up for Blobs formed
004182 ** by the OP_MakeRecord opcode, and such Blobs never get passed into
004183 ** sqlite3MemCompare(). */
004184 assert( (pB1->flags & MEM_Zero)==0 || n1==0 );
004185 assert( (pB2->flags & MEM_Zero)==0 || n2==0 );
004186
004187 if( (pB1->flags|pB2->flags) & MEM_Zero ){
004188 if( pB1->flags & pB2->flags & MEM_Zero ){
004189 return pB1->u.nZero - pB2->u.nZero;
004190 }else if( pB1->flags & MEM_Zero ){
004191 if( !isAllZero(pB2->z, pB2->n) ) return -1;
004192 return pB1->u.nZero - n2;
004193 }else{
004194 if( !isAllZero(pB1->z, pB1->n) ) return +1;
004195 return n1 - pB2->u.nZero;
004196 }
004197 }
004198 c = memcmp(pB1->z, pB2->z, n1>n2 ? n2 : n1);
004199 if( c ) return c;
004200 return n1 - n2;
004201 }
004202
004203 /*
004204 ** Do a comparison between a 64-bit signed integer and a 64-bit floating-point
004205 ** number. Return negative, zero, or positive if the first (i64) is less than,
004206 ** equal to, or greater than the second (double).
004207 */
004208 static int sqlite3IntFloatCompare(i64 i, double r){
004209 if( sizeof(LONGDOUBLE_TYPE)>8 ){
004210 LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i;
004211 if( x<r ) return -1;
004212 if( x>r ) return +1;
004213 return 0;
004214 }else{
004215 i64 y;
004216 double s;
004217 if( r<-9223372036854775808.0 ) return +1;
004218 if( r>=9223372036854775808.0 ) return -1;
004219 y = (i64)r;
004220 if( i<y ) return -1;
004221 if( i>y ) return +1;
004222 s = (double)i;
004223 if( s<r ) return -1;
004224 if( s>r ) return +1;
004225 return 0;
004226 }
004227 }
004228
004229 /*
004230 ** Compare the values contained by the two memory cells, returning
004231 ** negative, zero or positive if pMem1 is less than, equal to, or greater
004232 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
004233 ** and reals) sorted numerically, followed by text ordered by the collating
004234 ** sequence pColl and finally blob's ordered by memcmp().
004235 **
004236 ** Two NULL values are considered equal by this function.
004237 */
004238 int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
004239 int f1, f2;
004240 int combined_flags;
004241
004242 f1 = pMem1->flags;
004243 f2 = pMem2->flags;
004244 combined_flags = f1|f2;
004245 assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) );
004246
004247 /* If one value is NULL, it is less than the other. If both values
004248 ** are NULL, return 0.
004249 */
004250 if( combined_flags&MEM_Null ){
004251 return (f2&MEM_Null) - (f1&MEM_Null);
004252 }
004253
004254 /* At least one of the two values is a number
004255 */
004256 if( combined_flags&(MEM_Int|MEM_Real|MEM_IntReal) ){
004257 testcase( combined_flags & MEM_Int );
004258 testcase( combined_flags & MEM_Real );
004259 testcase( combined_flags & MEM_IntReal );
004260 if( (f1 & f2 & (MEM_Int|MEM_IntReal))!=0 ){
004261 testcase( f1 & f2 & MEM_Int );
004262 testcase( f1 & f2 & MEM_IntReal );
004263 if( pMem1->u.i < pMem2->u.i ) return -1;
004264 if( pMem1->u.i > pMem2->u.i ) return +1;
004265 return 0;
004266 }
004267 if( (f1 & f2 & MEM_Real)!=0 ){
004268 if( pMem1->u.r < pMem2->u.r ) return -1;
004269 if( pMem1->u.r > pMem2->u.r ) return +1;
004270 return 0;
004271 }
004272 if( (f1&(MEM_Int|MEM_IntReal))!=0 ){
004273 testcase( f1 & MEM_Int );
004274 testcase( f1 & MEM_IntReal );
004275 if( (f2&MEM_Real)!=0 ){
004276 return sqlite3IntFloatCompare(pMem1->u.i, pMem2->u.r);
004277 }else if( (f2&(MEM_Int|MEM_IntReal))!=0 ){
004278 if( pMem1->u.i < pMem2->u.i ) return -1;
004279 if( pMem1->u.i > pMem2->u.i ) return +1;
004280 return 0;
004281 }else{
004282 return -1;
004283 }
004284 }
004285 if( (f1&MEM_Real)!=0 ){
004286 if( (f2&(MEM_Int|MEM_IntReal))!=0 ){
004287 testcase( f2 & MEM_Int );
004288 testcase( f2 & MEM_IntReal );
004289 return -sqlite3IntFloatCompare(pMem2->u.i, pMem1->u.r);
004290 }else{
004291 return -1;
004292 }
004293 }
004294 return +1;
004295 }
004296
004297 /* If one value is a string and the other is a blob, the string is less.
004298 ** If both are strings, compare using the collating functions.
004299 */
004300 if( combined_flags&MEM_Str ){
004301 if( (f1 & MEM_Str)==0 ){
004302 return 1;
004303 }
004304 if( (f2 & MEM_Str)==0 ){
004305 return -1;
004306 }
004307
004308 assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed );
004309 assert( pMem1->enc==SQLITE_UTF8 ||
004310 pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
004311
004312 /* The collation sequence must be defined at this point, even if
004313 ** the user deletes the collation sequence after the vdbe program is
004314 ** compiled (this was not always the case).
004315 */
004316 assert( !pColl || pColl->xCmp );
004317
004318 if( pColl ){
004319 return vdbeCompareMemString(pMem1, pMem2, pColl, 0);
004320 }
004321 /* If a NULL pointer was passed as the collate function, fall through
004322 ** to the blob case and use memcmp(). */
004323 }
004324
004325 /* Both values must be blobs. Compare using memcmp(). */
004326 return sqlite3BlobCompare(pMem1, pMem2);
004327 }
004328
004329
004330 /*
004331 ** The first argument passed to this function is a serial-type that
004332 ** corresponds to an integer - all values between 1 and 9 inclusive
004333 ** except 7. The second points to a buffer containing an integer value
004334 ** serialized according to serial_type. This function deserializes
004335 ** and returns the value.
004336 */
004337 static i64 vdbeRecordDecodeInt(u32 serial_type, const u8 *aKey){
004338 u32 y;
004339 assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) );
004340 switch( serial_type ){
004341 case 0:
004342 case 1:
004343 testcase( aKey[0]&0x80 );
004344 return ONE_BYTE_INT(aKey);
004345 case 2:
004346 testcase( aKey[0]&0x80 );
004347 return TWO_BYTE_INT(aKey);
004348 case 3:
004349 testcase( aKey[0]&0x80 );
004350 return THREE_BYTE_INT(aKey);
004351 case 4: {
004352 testcase( aKey[0]&0x80 );
004353 y = FOUR_BYTE_UINT(aKey);
004354 return (i64)*(int*)&y;
004355 }
004356 case 5: {
004357 testcase( aKey[0]&0x80 );
004358 return FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey);
004359 }
004360 case 6: {
004361 u64 x = FOUR_BYTE_UINT(aKey);
004362 testcase( aKey[0]&0x80 );
004363 x = (x<<32) | FOUR_BYTE_UINT(aKey+4);
004364 return (i64)*(i64*)&x;
004365 }
004366 }
004367
004368 return (serial_type - 8);
004369 }
004370
004371 /*
004372 ** This function compares the two table rows or index records
004373 ** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero
004374 ** or positive integer if key1 is less than, equal to or
004375 ** greater than key2. The {nKey1, pKey1} key must be a blob
004376 ** created by the OP_MakeRecord opcode of the VDBE. The pPKey2
004377 ** key must be a parsed key such as obtained from
004378 ** sqlite3VdbeParseRecord.
004379 **
004380 ** If argument bSkip is non-zero, it is assumed that the caller has already
004381 ** determined that the first fields of the keys are equal.
004382 **
004383 ** Key1 and Key2 do not have to contain the same number of fields. If all
004384 ** fields that appear in both keys are equal, then pPKey2->default_rc is
004385 ** returned.
004386 **
004387 ** If database corruption is discovered, set pPKey2->errCode to
004388 ** SQLITE_CORRUPT and return 0. If an OOM error is encountered,
004389 ** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the
004390 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
004391 */
004392 int sqlite3VdbeRecordCompareWithSkip(
004393 int nKey1, const void *pKey1, /* Left key */
004394 UnpackedRecord *pPKey2, /* Right key */
004395 int bSkip /* If true, skip the first field */
004396 ){
004397 u32 d1; /* Offset into aKey[] of next data element */
004398 int i; /* Index of next field to compare */
004399 u32 szHdr1; /* Size of record header in bytes */
004400 u32 idx1; /* Offset of first type in header */
004401 int rc = 0; /* Return value */
004402 Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */
004403 KeyInfo *pKeyInfo;
004404 const unsigned char *aKey1 = (const unsigned char *)pKey1;
004405 Mem mem1;
004406
004407 /* If bSkip is true, then the caller has already determined that the first
004408 ** two elements in the keys are equal. Fix the various stack variables so
004409 ** that this routine begins comparing at the second field. */
004410 if( bSkip ){
004411 u32 s1;
004412 idx1 = 1 + getVarint32(&aKey1[1], s1);
004413 szHdr1 = aKey1[0];
004414 d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1);
004415 i = 1;
004416 pRhs++;
004417 }else{
004418 idx1 = getVarint32(aKey1, szHdr1);
004419 d1 = szHdr1;
004420 i = 0;
004421 }
004422 if( d1>(unsigned)nKey1 ){
004423 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
004424 return 0; /* Corruption */
004425 }
004426
004427 VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */
004428 assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
004429 || CORRUPT_DB );
004430 assert( pPKey2->pKeyInfo->aSortFlags!=0 );
004431 assert( pPKey2->pKeyInfo->nKeyField>0 );
004432 assert( idx1<=szHdr1 || CORRUPT_DB );
004433 do{
004434 u32 serial_type;
004435
004436 /* RHS is an integer */
004437 if( pRhs->flags & (MEM_Int|MEM_IntReal) ){
004438 testcase( pRhs->flags & MEM_Int );
004439 testcase( pRhs->flags & MEM_IntReal );
004440 serial_type = aKey1[idx1];
004441 testcase( serial_type==12 );
004442 if( serial_type>=10 ){
004443 rc = +1;
004444 }else if( serial_type==0 ){
004445 rc = -1;
004446 }else if( serial_type==7 ){
004447 sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
004448 rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r);
004449 }else{
004450 i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]);
004451 i64 rhs = pRhs->u.i;
004452 if( lhs<rhs ){
004453 rc = -1;
004454 }else if( lhs>rhs ){
004455 rc = +1;
004456 }
004457 }
004458 }
004459
004460 /* RHS is real */
004461 else if( pRhs->flags & MEM_Real ){
004462 serial_type = aKey1[idx1];
004463 if( serial_type>=10 ){
004464 /* Serial types 12 or greater are strings and blobs (greater than
004465 ** numbers). Types 10 and 11 are currently "reserved for future
004466 ** use", so it doesn't really matter what the results of comparing
004467 ** them to numberic values are. */
004468 rc = +1;
004469 }else if( serial_type==0 ){
004470 rc = -1;
004471 }else{
004472 sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
004473 if( serial_type==7 ){
004474 if( mem1.u.r<pRhs->u.r ){
004475 rc = -1;
004476 }else if( mem1.u.r>pRhs->u.r ){
004477 rc = +1;
004478 }
004479 }else{
004480 rc = sqlite3IntFloatCompare(mem1.u.i, pRhs->u.r);
004481 }
004482 }
004483 }
004484
004485 /* RHS is a string */
004486 else if( pRhs->flags & MEM_Str ){
004487 getVarint32(&aKey1[idx1], serial_type);
004488 testcase( serial_type==12 );
004489 if( serial_type<12 ){
004490 rc = -1;
004491 }else if( !(serial_type & 0x01) ){
004492 rc = +1;
004493 }else{
004494 mem1.n = (serial_type - 12) / 2;
004495 testcase( (d1+mem1.n)==(unsigned)nKey1 );
004496 testcase( (d1+mem1.n+1)==(unsigned)nKey1 );
004497 if( (d1+mem1.n) > (unsigned)nKey1
004498 || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i
004499 ){
004500 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
004501 return 0; /* Corruption */
004502 }else if( pKeyInfo->aColl[i] ){
004503 mem1.enc = pKeyInfo->enc;
004504 mem1.db = pKeyInfo->db;
004505 mem1.flags = MEM_Str;
004506 mem1.z = (char*)&aKey1[d1];
004507 rc = vdbeCompareMemString(
004508 &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode
004509 );
004510 }else{
004511 int nCmp = MIN(mem1.n, pRhs->n);
004512 rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
004513 if( rc==0 ) rc = mem1.n - pRhs->n;
004514 }
004515 }
004516 }
004517
004518 /* RHS is a blob */
004519 else if( pRhs->flags & MEM_Blob ){
004520 assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 );
004521 getVarint32(&aKey1[idx1], serial_type);
004522 testcase( serial_type==12 );
004523 if( serial_type<12 || (serial_type & 0x01) ){
004524 rc = -1;
004525 }else{
004526 int nStr = (serial_type - 12) / 2;
004527 testcase( (d1+nStr)==(unsigned)nKey1 );
004528 testcase( (d1+nStr+1)==(unsigned)nKey1 );
004529 if( (d1+nStr) > (unsigned)nKey1 ){
004530 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
004531 return 0; /* Corruption */
004532 }else if( pRhs->flags & MEM_Zero ){
004533 if( !isAllZero((const char*)&aKey1[d1],nStr) ){
004534 rc = 1;
004535 }else{
004536 rc = nStr - pRhs->u.nZero;
004537 }
004538 }else{
004539 int nCmp = MIN(nStr, pRhs->n);
004540 rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
004541 if( rc==0 ) rc = nStr - pRhs->n;
004542 }
004543 }
004544 }
004545
004546 /* RHS is null */
004547 else{
004548 serial_type = aKey1[idx1];
004549 rc = (serial_type!=0);
004550 }
004551
004552 if( rc!=0 ){
004553 int sortFlags = pPKey2->pKeyInfo->aSortFlags[i];
004554 if( sortFlags ){
004555 if( (sortFlags & KEYINFO_ORDER_BIGNULL)==0
004556 || ((sortFlags & KEYINFO_ORDER_DESC)
004557 !=(serial_type==0 || (pRhs->flags&MEM_Null)))
004558 ){
004559 rc = -rc;
004560 }
004561 }
004562 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) );
004563 assert( mem1.szMalloc==0 ); /* See comment below */
004564 return rc;
004565 }
004566
004567 i++;
004568 if( i==pPKey2->nField ) break;
004569 pRhs++;
004570 d1 += sqlite3VdbeSerialTypeLen(serial_type);
004571 idx1 += sqlite3VarintLen(serial_type);
004572 }while( idx1<(unsigned)szHdr1 && d1<=(unsigned)nKey1 );
004573
004574 /* No memory allocation is ever used on mem1. Prove this using
004575 ** the following assert(). If the assert() fails, it indicates a
004576 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */
004577 assert( mem1.szMalloc==0 );
004578
004579 /* rc==0 here means that one or both of the keys ran out of fields and
004580 ** all the fields up to that point were equal. Return the default_rc
004581 ** value. */
004582 assert( CORRUPT_DB
004583 || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, pPKey2->default_rc)
004584 || pPKey2->pKeyInfo->db->mallocFailed
004585 );
004586 pPKey2->eqSeen = 1;
004587 return pPKey2->default_rc;
004588 }
004589 int sqlite3VdbeRecordCompare(
004590 int nKey1, const void *pKey1, /* Left key */
004591 UnpackedRecord *pPKey2 /* Right key */
004592 ){
004593 return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 0);
004594 }
004595
004596
004597 /*
004598 ** This function is an optimized version of sqlite3VdbeRecordCompare()
004599 ** that (a) the first field of pPKey2 is an integer, and (b) the
004600 ** size-of-header varint at the start of (pKey1/nKey1) fits in a single
004601 ** byte (i.e. is less than 128).
004602 **
004603 ** To avoid concerns about buffer overreads, this routine is only used
004604 ** on schemas where the maximum valid header size is 63 bytes or less.
004605 */
004606 static int vdbeRecordCompareInt(
004607 int nKey1, const void *pKey1, /* Left key */
004608 UnpackedRecord *pPKey2 /* Right key */
004609 ){
004610 const u8 *aKey = &((const u8*)pKey1)[*(const u8*)pKey1 & 0x3F];
004611 int serial_type = ((const u8*)pKey1)[1];
004612 int res;
004613 u32 y;
004614 u64 x;
004615 i64 v;
004616 i64 lhs;
004617
004618 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
004619 assert( (*(u8*)pKey1)<=0x3F || CORRUPT_DB );
004620 switch( serial_type ){
004621 case 1: { /* 1-byte signed integer */
004622 lhs = ONE_BYTE_INT(aKey);
004623 testcase( lhs<0 );
004624 break;
004625 }
004626 case 2: { /* 2-byte signed integer */
004627 lhs = TWO_BYTE_INT(aKey);
004628 testcase( lhs<0 );
004629 break;
004630 }
004631 case 3: { /* 3-byte signed integer */
004632 lhs = THREE_BYTE_INT(aKey);
004633 testcase( lhs<0 );
004634 break;
004635 }
004636 case 4: { /* 4-byte signed integer */
004637 y = FOUR_BYTE_UINT(aKey);
004638 lhs = (i64)*(int*)&y;
004639 testcase( lhs<0 );
004640 break;
004641 }
004642 case 5: { /* 6-byte signed integer */
004643 lhs = FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey);
004644 testcase( lhs<0 );
004645 break;
004646 }
004647 case 6: { /* 8-byte signed integer */
004648 x = FOUR_BYTE_UINT(aKey);
004649 x = (x<<32) | FOUR_BYTE_UINT(aKey+4);
004650 lhs = *(i64*)&x;
004651 testcase( lhs<0 );
004652 break;
004653 }
004654 case 8:
004655 lhs = 0;
004656 break;
004657 case 9:
004658 lhs = 1;
004659 break;
004660
004661 /* This case could be removed without changing the results of running
004662 ** this code. Including it causes gcc to generate a faster switch
004663 ** statement (since the range of switch targets now starts at zero and
004664 ** is contiguous) but does not cause any duplicate code to be generated
004665 ** (as gcc is clever enough to combine the two like cases). Other
004666 ** compilers might be similar. */
004667 case 0: case 7:
004668 return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2);
004669
004670 default:
004671 return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2);
004672 }
004673
004674 v = pPKey2->aMem[0].u.i;
004675 if( v>lhs ){
004676 res = pPKey2->r1;
004677 }else if( v<lhs ){
004678 res = pPKey2->r2;
004679 }else if( pPKey2->nField>1 ){
004680 /* The first fields of the two keys are equal. Compare the trailing
004681 ** fields. */
004682 res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1);
004683 }else{
004684 /* The first fields of the two keys are equal and there are no trailing
004685 ** fields. Return pPKey2->default_rc in this case. */
004686 res = pPKey2->default_rc;
004687 pPKey2->eqSeen = 1;
004688 }
004689
004690 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) );
004691 return res;
004692 }
004693
004694 /*
004695 ** This function is an optimized version of sqlite3VdbeRecordCompare()
004696 ** that (a) the first field of pPKey2 is a string, that (b) the first field
004697 ** uses the collation sequence BINARY and (c) that the size-of-header varint
004698 ** at the start of (pKey1/nKey1) fits in a single byte.
004699 */
004700 static int vdbeRecordCompareString(
004701 int nKey1, const void *pKey1, /* Left key */
004702 UnpackedRecord *pPKey2 /* Right key */
004703 ){
004704 const u8 *aKey1 = (const u8*)pKey1;
004705 int serial_type;
004706 int res;
004707
004708 assert( pPKey2->aMem[0].flags & MEM_Str );
004709 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
004710 getVarint32(&aKey1[1], serial_type);
004711 if( serial_type<12 ){
004712 res = pPKey2->r1; /* (pKey1/nKey1) is a number or a null */
004713 }else if( !(serial_type & 0x01) ){
004714 res = pPKey2->r2; /* (pKey1/nKey1) is a blob */
004715 }else{
004716 int nCmp;
004717 int nStr;
004718 int szHdr = aKey1[0];
004719
004720 nStr = (serial_type-12) / 2;
004721 if( (szHdr + nStr) > nKey1 ){
004722 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
004723 return 0; /* Corruption */
004724 }
004725 nCmp = MIN( pPKey2->aMem[0].n, nStr );
004726 res = memcmp(&aKey1[szHdr], pPKey2->aMem[0].z, nCmp);
004727
004728 if( res>0 ){
004729 res = pPKey2->r2;
004730 }else if( res<0 ){
004731 res = pPKey2->r1;
004732 }else{
004733 res = nStr - pPKey2->aMem[0].n;
004734 if( res==0 ){
004735 if( pPKey2->nField>1 ){
004736 res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1);
004737 }else{
004738 res = pPKey2->default_rc;
004739 pPKey2->eqSeen = 1;
004740 }
004741 }else if( res>0 ){
004742 res = pPKey2->r2;
004743 }else{
004744 res = pPKey2->r1;
004745 }
004746 }
004747 }
004748
004749 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res)
004750 || CORRUPT_DB
004751 || pPKey2->pKeyInfo->db->mallocFailed
004752 );
004753 return res;
004754 }
004755
004756 /*
004757 ** Return a pointer to an sqlite3VdbeRecordCompare() compatible function
004758 ** suitable for comparing serialized records to the unpacked record passed
004759 ** as the only argument.
004760 */
004761 RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){
004762 /* varintRecordCompareInt() and varintRecordCompareString() both assume
004763 ** that the size-of-header varint that occurs at the start of each record
004764 ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt()
004765 ** also assumes that it is safe to overread a buffer by at least the
004766 ** maximum possible legal header size plus 8 bytes. Because there is
004767 ** guaranteed to be at least 74 (but not 136) bytes of padding following each
004768 ** buffer passed to varintRecordCompareInt() this makes it convenient to
004769 ** limit the size of the header to 64 bytes in cases where the first field
004770 ** is an integer.
004771 **
004772 ** The easiest way to enforce this limit is to consider only records with
004773 ** 13 fields or less. If the first field is an integer, the maximum legal
004774 ** header size is (12*5 + 1 + 1) bytes. */
004775 if( p->pKeyInfo->nAllField<=13 ){
004776 int flags = p->aMem[0].flags;
004777 if( p->pKeyInfo->aSortFlags[0] ){
004778 if( p->pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL ){
004779 return sqlite3VdbeRecordCompare;
004780 }
004781 p->r1 = 1;
004782 p->r2 = -1;
004783 }else{
004784 p->r1 = -1;
004785 p->r2 = 1;
004786 }
004787 if( (flags & MEM_Int) ){
004788 return vdbeRecordCompareInt;
004789 }
004790 testcase( flags & MEM_Real );
004791 testcase( flags & MEM_Null );
004792 testcase( flags & MEM_Blob );
004793 if( (flags & (MEM_Real|MEM_IntReal|MEM_Null|MEM_Blob))==0
004794 && p->pKeyInfo->aColl[0]==0
004795 ){
004796 assert( flags & MEM_Str );
004797 return vdbeRecordCompareString;
004798 }
004799 }
004800
004801 return sqlite3VdbeRecordCompare;
004802 }
004803
004804 /*
004805 ** pCur points at an index entry created using the OP_MakeRecord opcode.
004806 ** Read the rowid (the last field in the record) and store it in *rowid.
004807 ** Return SQLITE_OK if everything works, or an error code otherwise.
004808 **
004809 ** pCur might be pointing to text obtained from a corrupt database file.
004810 ** So the content cannot be trusted. Do appropriate checks on the content.
004811 */
004812 int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
004813 i64 nCellKey = 0;
004814 int rc;
004815 u32 szHdr; /* Size of the header */
004816 u32 typeRowid; /* Serial type of the rowid */
004817 u32 lenRowid; /* Size of the rowid */
004818 Mem m, v;
004819
004820 /* Get the size of the index entry. Only indices entries of less
004821 ** than 2GiB are support - anything large must be database corruption.
004822 ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so
004823 ** this code can safely assume that nCellKey is 32-bits
004824 */
004825 assert( sqlite3BtreeCursorIsValid(pCur) );
004826 nCellKey = sqlite3BtreePayloadSize(pCur);
004827 assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey );
004828
004829 /* Read in the complete content of the index entry */
004830 sqlite3VdbeMemInit(&m, db, 0);
004831 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
004832 if( rc ){
004833 return rc;
004834 }
004835
004836 /* The index entry must begin with a header size */
004837 (void)getVarint32((u8*)m.z, szHdr);
004838 testcase( szHdr==3 );
004839 testcase( szHdr==m.n );
004840 testcase( szHdr>0x7fffffff );
004841 assert( m.n>=0 );
004842 if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){
004843 goto idx_rowid_corruption;
004844 }
004845
004846 /* The last field of the index should be an integer - the ROWID.
004847 ** Verify that the last entry really is an integer. */
004848 (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid);
004849 testcase( typeRowid==1 );
004850 testcase( typeRowid==2 );
004851 testcase( typeRowid==3 );
004852 testcase( typeRowid==4 );
004853 testcase( typeRowid==5 );
004854 testcase( typeRowid==6 );
004855 testcase( typeRowid==8 );
004856 testcase( typeRowid==9 );
004857 if( unlikely(typeRowid<1 || typeRowid>9 || typeRowid==7) ){
004858 goto idx_rowid_corruption;
004859 }
004860 lenRowid = sqlite3SmallTypeSizes[typeRowid];
004861 testcase( (u32)m.n==szHdr+lenRowid );
004862 if( unlikely((u32)m.n<szHdr+lenRowid) ){
004863 goto idx_rowid_corruption;
004864 }
004865
004866 /* Fetch the integer off the end of the index record */
004867 sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
004868 *rowid = v.u.i;
004869 sqlite3VdbeMemRelease(&m);
004870 return SQLITE_OK;
004871
004872 /* Jump here if database corruption is detected after m has been
004873 ** allocated. Free the m object and return SQLITE_CORRUPT. */
004874 idx_rowid_corruption:
004875 testcase( m.szMalloc!=0 );
004876 sqlite3VdbeMemRelease(&m);
004877 return SQLITE_CORRUPT_BKPT;
004878 }
004879
004880 /*
004881 ** Compare the key of the index entry that cursor pC is pointing to against
004882 ** the key string in pUnpacked. Write into *pRes a number
004883 ** that is negative, zero, or positive if pC is less than, equal to,
004884 ** or greater than pUnpacked. Return SQLITE_OK on success.
004885 **
004886 ** pUnpacked is either created without a rowid or is truncated so that it
004887 ** omits the rowid at the end. The rowid at the end of the index entry
004888 ** is ignored as well. Hence, this routine only compares the prefixes
004889 ** of the keys prior to the final rowid, not the entire key.
004890 */
004891 int sqlite3VdbeIdxKeyCompare(
004892 sqlite3 *db, /* Database connection */
004893 VdbeCursor *pC, /* The cursor to compare against */
004894 UnpackedRecord *pUnpacked, /* Unpacked version of key */
004895 int *res /* Write the comparison result here */
004896 ){
004897 i64 nCellKey = 0;
004898 int rc;
004899 BtCursor *pCur;
004900 Mem m;
004901
004902 assert( pC->eCurType==CURTYPE_BTREE );
004903 pCur = pC->uc.pCursor;
004904 assert( sqlite3BtreeCursorIsValid(pCur) );
004905 nCellKey = sqlite3BtreePayloadSize(pCur);
004906 /* nCellKey will always be between 0 and 0xffffffff because of the way
004907 ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
004908 if( nCellKey<=0 || nCellKey>0x7fffffff ){
004909 *res = 0;
004910 return SQLITE_CORRUPT_BKPT;
004911 }
004912 sqlite3VdbeMemInit(&m, db, 0);
004913 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
004914 if( rc ){
004915 return rc;
004916 }
004917 *res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, pUnpacked, 0);
004918 sqlite3VdbeMemRelease(&m);
004919 return SQLITE_OK;
004920 }
004921
004922 /*
004923 ** This routine sets the value to be returned by subsequent calls to
004924 ** sqlite3_changes() on the database handle 'db'.
004925 */
004926 void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){
004927 assert( sqlite3_mutex_held(db->mutex) );
004928 db->nChange = nChange;
004929 db->nTotalChange += nChange;
004930 }
004931
004932 /*
004933 ** Set a flag in the vdbe to update the change counter when it is finalised
004934 ** or reset.
004935 */
004936 void sqlite3VdbeCountChanges(Vdbe *v){
004937 v->changeCntOn = 1;
004938 }
004939
004940 /*
004941 ** Mark every prepared statement associated with a database connection
004942 ** as expired.
004943 **
004944 ** An expired statement means that recompilation of the statement is
004945 ** recommend. Statements expire when things happen that make their
004946 ** programs obsolete. Removing user-defined functions or collating
004947 ** sequences, or changing an authorization function are the types of
004948 ** things that make prepared statements obsolete.
004949 **
004950 ** If iCode is 1, then expiration is advisory. The statement should
004951 ** be reprepared before being restarted, but if it is already running
004952 ** it is allowed to run to completion.
004953 **
004954 ** Internally, this function just sets the Vdbe.expired flag on all
004955 ** prepared statements. The flag is set to 1 for an immediate expiration
004956 ** and set to 2 for an advisory expiration.
004957 */
004958 void sqlite3ExpirePreparedStatements(sqlite3 *db, int iCode){
004959 Vdbe *p;
004960 for(p = db->pVdbe; p; p=p->pNext){
004961 p->expired = iCode+1;
004962 }
004963 }
004964
004965 /*
004966 ** Return the database associated with the Vdbe.
004967 */
004968 sqlite3 *sqlite3VdbeDb(Vdbe *v){
004969 return v->db;
004970 }
004971
004972 /*
004973 ** Return the SQLITE_PREPARE flags for a Vdbe.
004974 */
004975 u8 sqlite3VdbePrepareFlags(Vdbe *v){
004976 return v->prepFlags;
004977 }
004978
004979 /*
004980 ** Return a pointer to an sqlite3_value structure containing the value bound
004981 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
004982 ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_*
004983 ** constants) to the value before returning it.
004984 **
004985 ** The returned value must be freed by the caller using sqlite3ValueFree().
004986 */
004987 sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){
004988 assert( iVar>0 );
004989 if( v ){
004990 Mem *pMem = &v->aVar[iVar-1];
004991 assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
004992 if( 0==(pMem->flags & MEM_Null) ){
004993 sqlite3_value *pRet = sqlite3ValueNew(v->db);
004994 if( pRet ){
004995 sqlite3VdbeMemCopy((Mem *)pRet, pMem);
004996 sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8);
004997 }
004998 return pRet;
004999 }
005000 }
005001 return 0;
005002 }
005003
005004 /*
005005 ** Configure SQL variable iVar so that binding a new value to it signals
005006 ** to sqlite3_reoptimize() that re-preparing the statement may result
005007 ** in a better query plan.
005008 */
005009 void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
005010 assert( iVar>0 );
005011 assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
005012 if( iVar>=32 ){
005013 v->expmask |= 0x80000000;
005014 }else{
005015 v->expmask |= ((u32)1 << (iVar-1));
005016 }
005017 }
005018
005019 /*
005020 ** Cause a function to throw an error if it was call from OP_PureFunc
005021 ** rather than OP_Function.
005022 **
005023 ** OP_PureFunc means that the function must be deterministic, and should
005024 ** throw an error if it is given inputs that would make it non-deterministic.
005025 ** This routine is invoked by date/time functions that use non-deterministic
005026 ** features such as 'now'.
005027 */
005028 int sqlite3NotPureFunc(sqlite3_context *pCtx){
005029 const VdbeOp *pOp;
005030 #ifdef SQLITE_ENABLE_STAT4
005031 if( pCtx->pVdbe==0 ) return 1;
005032 #endif
005033 pOp = pCtx->pVdbe->aOp + pCtx->iOp;
005034 if( pOp->opcode==OP_PureFunc ){
005035 const char *zContext;
005036 char *zMsg;
005037 if( pOp->p5 & NC_IsCheck ){
005038 zContext = "a CHECK constraint";
005039 }else if( pOp->p5 & NC_GenCol ){
005040 zContext = "a generated column";
005041 }else{
005042 zContext = "an index";
005043 }
005044 zMsg = sqlite3_mprintf("non-deterministic use of %s() in %s",
005045 pCtx->pFunc->zName, zContext);
005046 sqlite3_result_error(pCtx, zMsg, -1);
005047 sqlite3_free(zMsg);
005048 return 0;
005049 }
005050 return 1;
005051 }
005052
005053 #ifndef SQLITE_OMIT_VIRTUALTABLE
005054 /*
005055 ** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored
005056 ** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored
005057 ** in memory obtained from sqlite3DbMalloc).
005058 */
005059 void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){
005060 if( pVtab->zErrMsg ){
005061 sqlite3 *db = p->db;
005062 sqlite3DbFree(db, p->zErrMsg);
005063 p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
005064 sqlite3_free(pVtab->zErrMsg);
005065 pVtab->zErrMsg = 0;
005066 }
005067 }
005068 #endif /* SQLITE_OMIT_VIRTUALTABLE */
005069
005070 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
005071
005072 /*
005073 ** If the second argument is not NULL, release any allocations associated
005074 ** with the memory cells in the p->aMem[] array. Also free the UnpackedRecord
005075 ** structure itself, using sqlite3DbFree().
005076 **
005077 ** This function is used to free UnpackedRecord structures allocated by
005078 ** the vdbeUnpackRecord() function found in vdbeapi.c.
005079 */
005080 static void vdbeFreeUnpacked(sqlite3 *db, int nField, UnpackedRecord *p){
005081 if( p ){
005082 int i;
005083 for(i=0; i<nField; i++){
005084 Mem *pMem = &p->aMem[i];
005085 if( pMem->zMalloc ) sqlite3VdbeMemRelease(pMem);
005086 }
005087 sqlite3DbFreeNN(db, p);
005088 }
005089 }
005090 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
005091
005092 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
005093 /*
005094 ** Invoke the pre-update hook. If this is an UPDATE or DELETE pre-update call,
005095 ** then cursor passed as the second argument should point to the row about
005096 ** to be update or deleted. If the application calls sqlite3_preupdate_old(),
005097 ** the required value will be read from the row the cursor points to.
005098 */
005099 void sqlite3VdbePreUpdateHook(
005100 Vdbe *v, /* Vdbe pre-update hook is invoked by */
005101 VdbeCursor *pCsr, /* Cursor to grab old.* values from */
005102 int op, /* SQLITE_INSERT, UPDATE or DELETE */
005103 const char *zDb, /* Database name */
005104 Table *pTab, /* Modified table */
005105 i64 iKey1, /* Initial key value */
005106 int iReg /* Register for new.* record */
005107 ){
005108 sqlite3 *db = v->db;
005109 i64 iKey2;
005110 PreUpdate preupdate;
005111 const char *zTbl = pTab->zName;
005112 static const u8 fakeSortOrder = 0;
005113
005114 assert( db->pPreUpdate==0 );
005115 memset(&preupdate, 0, sizeof(PreUpdate));
005116 if( HasRowid(pTab)==0 ){
005117 iKey1 = iKey2 = 0;
005118 preupdate.pPk = sqlite3PrimaryKeyIndex(pTab);
005119 }else{
005120 if( op==SQLITE_UPDATE ){
005121 iKey2 = v->aMem[iReg].u.i;
005122 }else{
005123 iKey2 = iKey1;
005124 }
005125 }
005126
005127 assert( pCsr->nField==pTab->nCol
005128 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
005129 );
005130
005131 preupdate.v = v;
005132 preupdate.pCsr = pCsr;
005133 preupdate.op = op;
005134 preupdate.iNewReg = iReg;
005135 preupdate.keyinfo.db = db;
005136 preupdate.keyinfo.enc = ENC(db);
005137 preupdate.keyinfo.nKeyField = pTab->nCol;
005138 preupdate.keyinfo.aSortFlags = (u8*)&fakeSortOrder;
005139 preupdate.iKey1 = iKey1;
005140 preupdate.iKey2 = iKey2;
005141 preupdate.pTab = pTab;
005142
005143 db->pPreUpdate = &preupdate;
005144 db->xPreUpdateCallback(db->pPreUpdateArg, db, op, zDb, zTbl, iKey1, iKey2);
005145 db->pPreUpdate = 0;
005146 sqlite3DbFree(db, preupdate.aRecord);
005147 vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pUnpacked);
005148 vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pNewUnpacked);
005149 if( preupdate.aNew ){
005150 int i;
005151 for(i=0; i<pCsr->nField; i++){
005152 sqlite3VdbeMemRelease(&preupdate.aNew[i]);
005153 }
005154 sqlite3DbFreeNN(db, preupdate.aNew);
005155 }
005156 }
005157 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */