1 /*
2 ** 2003 September 6
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** This file contains code used for creating, destroying, and populating
13 ** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.)
14 */
15 #include "sqliteInt.h"
16 #include "vdbeInt.h"
17
18 /* Forward references */
19 static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef);
20 static void vdbeFreeOpArray(sqlite3 *, Op *, int);
21
22 /*
23 ** Create a new virtual database engine.
24 */
sqlite3VdbeCreate(Parse * pParse)25 Vdbe *sqlite3VdbeCreate(Parse *pParse){
26 sqlite3 *db = pParse->db;
27 Vdbe *p;
28 p = sqlite3DbMallocRawNN(db, sizeof(Vdbe) );
29 if( p==0 ) return 0;
30 memset(&p->aOp, 0, sizeof(Vdbe)-offsetof(Vdbe,aOp));
31 p->db = db;
32 if( db->pVdbe ){
33 db->pVdbe->pPrev = p;
34 }
35 p->pNext = db->pVdbe;
36 p->pPrev = 0;
37 db->pVdbe = p;
38 p->magic = VDBE_MAGIC_INIT;
39 p->pParse = pParse;
40 pParse->pVdbe = p;
41 assert( pParse->aLabel==0 );
42 assert( pParse->nLabel==0 );
43 assert( p->nOpAlloc==0 );
44 assert( pParse->szOpAlloc==0 );
45 sqlite3VdbeAddOp2(p, OP_Init, 0, 1);
46 return p;
47 }
48
49 /*
50 ** Return the Parse object that owns a Vdbe object.
51 */
sqlite3VdbeParser(Vdbe * p)52 Parse *sqlite3VdbeParser(Vdbe *p){
53 return p->pParse;
54 }
55
56 /*
57 ** Change the error string stored in Vdbe.zErrMsg
58 */
sqlite3VdbeError(Vdbe * p,const char * zFormat,...)59 void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){
60 va_list ap;
61 sqlite3DbFree(p->db, p->zErrMsg);
62 va_start(ap, zFormat);
63 p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap);
64 va_end(ap);
65 }
66
67 /*
68 ** Remember the SQL string for a prepared statement.
69 */
sqlite3VdbeSetSql(Vdbe * p,const char * z,int n,u8 prepFlags)70 void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlags){
71 if( p==0 ) return;
72 p->prepFlags = prepFlags;
73 if( (prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
74 p->expmask = 0;
75 }
76 assert( p->zSql==0 );
77 p->zSql = sqlite3DbStrNDup(p->db, z, n);
78 }
79
80 #ifdef SQLITE_ENABLE_NORMALIZE
81 /*
82 ** Add a new element to the Vdbe->pDblStr list.
83 */
sqlite3VdbeAddDblquoteStr(sqlite3 * db,Vdbe * p,const char * z)84 void sqlite3VdbeAddDblquoteStr(sqlite3 *db, Vdbe *p, const char *z){
85 if( p ){
86 int n = sqlite3Strlen30(z);
87 DblquoteStr *pStr = sqlite3DbMallocRawNN(db,
88 sizeof(*pStr)+n+1-sizeof(pStr->z));
89 if( pStr ){
90 pStr->pNextStr = p->pDblStr;
91 p->pDblStr = pStr;
92 memcpy(pStr->z, z, n+1);
93 }
94 }
95 }
96 #endif
97
98 #ifdef SQLITE_ENABLE_NORMALIZE
99 /*
100 ** zId of length nId is a double-quoted identifier. Check to see if
101 ** that identifier is really used as a string literal.
102 */
sqlite3VdbeUsesDoubleQuotedString(Vdbe * pVdbe,const char * zId)103 int sqlite3VdbeUsesDoubleQuotedString(
104 Vdbe *pVdbe, /* The prepared statement */
105 const char *zId /* The double-quoted identifier, already dequoted */
106 ){
107 DblquoteStr *pStr;
108 assert( zId!=0 );
109 if( pVdbe->pDblStr==0 ) return 0;
110 for(pStr=pVdbe->pDblStr; pStr; pStr=pStr->pNextStr){
111 if( strcmp(zId, pStr->z)==0 ) return 1;
112 }
113 return 0;
114 }
115 #endif
116
117 /*
118 ** Swap all content between two VDBE structures.
119 */
sqlite3VdbeSwap(Vdbe * pA,Vdbe * pB)120 void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
121 Vdbe tmp, *pTmp;
122 char *zTmp;
123 assert( pA->db==pB->db );
124 tmp = *pA;
125 *pA = *pB;
126 *pB = tmp;
127 pTmp = pA->pNext;
128 pA->pNext = pB->pNext;
129 pB->pNext = pTmp;
130 pTmp = pA->pPrev;
131 pA->pPrev = pB->pPrev;
132 pB->pPrev = pTmp;
133 zTmp = pA->zSql;
134 pA->zSql = pB->zSql;
135 pB->zSql = zTmp;
136 #ifdef SQLITE_ENABLE_NORMALIZE
137 zTmp = pA->zNormSql;
138 pA->zNormSql = pB->zNormSql;
139 pB->zNormSql = zTmp;
140 #endif
141 pB->expmask = pA->expmask;
142 pB->prepFlags = pA->prepFlags;
143 memcpy(pB->aCounter, pA->aCounter, sizeof(pB->aCounter));
144 pB->aCounter[SQLITE_STMTSTATUS_REPREPARE]++;
145 }
146
147 /*
148 ** Resize the Vdbe.aOp array so that it is at least nOp elements larger
149 ** than its current size. nOp is guaranteed to be less than or equal
150 ** to 1024/sizeof(Op).
151 **
152 ** If an out-of-memory error occurs while resizing the array, return
153 ** SQLITE_NOMEM. In this case Vdbe.aOp and Vdbe.nOpAlloc remain
154 ** unchanged (this is so that any opcodes already allocated can be
155 ** correctly deallocated along with the rest of the Vdbe).
156 */
growOpArray(Vdbe * v,int nOp)157 static int growOpArray(Vdbe *v, int nOp){
158 VdbeOp *pNew;
159 Parse *p = v->pParse;
160
161 /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
162 ** more frequent reallocs and hence provide more opportunities for
163 ** simulated OOM faults. SQLITE_TEST_REALLOC_STRESS is generally used
164 ** during testing only. With SQLITE_TEST_REALLOC_STRESS grow the op array
165 ** by the minimum* amount required until the size reaches 512. Normal
166 ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
167 ** size of the op array or add 1KB of space, whichever is smaller. */
168 #ifdef SQLITE_TEST_REALLOC_STRESS
169 sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
170 : (sqlite3_int64)v->nOpAlloc+nOp);
171 #else
172 sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
173 : (sqlite3_int64)(1024/sizeof(Op)));
174 UNUSED_PARAMETER(nOp);
175 #endif
176
177 /* Ensure that the size of a VDBE does not grow too large */
178 if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
179 sqlite3OomFault(p->db);
180 return SQLITE_NOMEM;
181 }
182
183 assert( nOp<=(1024/sizeof(Op)) );
184 assert( nNew>=(v->nOpAlloc+nOp) );
185 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
186 if( pNew ){
187 p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew);
188 v->nOpAlloc = p->szOpAlloc/sizeof(Op);
189 v->aOp = pNew;
190 }
191 return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT);
192 }
193
194 #ifdef SQLITE_DEBUG
195 /* This routine is just a convenient place to set a breakpoint that will
196 ** fire after each opcode is inserted and displayed using
197 ** "PRAGMA vdbe_addoptrace=on". Parameters "pc" (program counter) and
198 ** pOp are available to make the breakpoint conditional.
199 **
200 ** Other useful labels for breakpoints include:
201 ** test_trace_breakpoint(pc,pOp)
202 ** sqlite3CorruptError(lineno)
203 ** sqlite3MisuseError(lineno)
204 ** sqlite3CantopenError(lineno)
205 */
test_addop_breakpoint(int pc,Op * pOp)206 static void test_addop_breakpoint(int pc, Op *pOp){
207 static int n = 0;
208 n++;
209 }
210 #endif
211
212 /*
213 ** Add a new instruction to the list of instructions current in the
214 ** VDBE. Return the address of the new instruction.
215 **
216 ** Parameters:
217 **
218 ** p Pointer to the VDBE
219 **
220 ** op The opcode for this instruction
221 **
222 ** p1, p2, p3 Operands
223 **
224 ** Use the sqlite3VdbeResolveLabel() function to fix an address and
225 ** the sqlite3VdbeChangeP4() function to change the value of the P4
226 ** operand.
227 */
growOp3(Vdbe * p,int op,int p1,int p2,int p3)228 static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){
229 assert( p->nOpAlloc<=p->nOp );
230 if( growOpArray(p, 1) ) return 1;
231 assert( p->nOpAlloc>p->nOp );
232 return sqlite3VdbeAddOp3(p, op, p1, p2, p3);
233 }
sqlite3VdbeAddOp3(Vdbe * p,int op,int p1,int p2,int p3)234 int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
235 int i;
236 VdbeOp *pOp;
237
238 i = p->nOp;
239 assert( p->magic==VDBE_MAGIC_INIT );
240 assert( op>=0 && op<0xff );
241 if( p->nOpAlloc<=i ){
242 return growOp3(p, op, p1, p2, p3);
243 }
244 p->nOp++;
245 pOp = &p->aOp[i];
246 pOp->opcode = (u8)op;
247 pOp->p5 = 0;
248 pOp->p1 = p1;
249 pOp->p2 = p2;
250 pOp->p3 = p3;
251 pOp->p4.p = 0;
252 pOp->p4type = P4_NOTUSED;
253 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
254 pOp->zComment = 0;
255 #endif
256 #ifdef SQLITE_DEBUG
257 if( p->db->flags & SQLITE_VdbeAddopTrace ){
258 sqlite3VdbePrintOp(0, i, &p->aOp[i]);
259 test_addop_breakpoint(i, &p->aOp[i]);
260 }
261 #endif
262 #ifdef VDBE_PROFILE
263 pOp->cycles = 0;
264 pOp->cnt = 0;
265 #endif
266 #ifdef SQLITE_VDBE_COVERAGE
267 pOp->iSrcLine = 0;
268 #endif
269 return i;
270 }
sqlite3VdbeAddOp0(Vdbe * p,int op)271 int sqlite3VdbeAddOp0(Vdbe *p, int op){
272 return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
273 }
sqlite3VdbeAddOp1(Vdbe * p,int op,int p1)274 int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
275 return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
276 }
sqlite3VdbeAddOp2(Vdbe * p,int op,int p1,int p2)277 int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
278 return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
279 }
280
281 /* Generate code for an unconditional jump to instruction iDest
282 */
sqlite3VdbeGoto(Vdbe * p,int iDest)283 int sqlite3VdbeGoto(Vdbe *p, int iDest){
284 return sqlite3VdbeAddOp3(p, OP_Goto, 0, iDest, 0);
285 }
286
287 /* Generate code to cause the string zStr to be loaded into
288 ** register iDest
289 */
sqlite3VdbeLoadString(Vdbe * p,int iDest,const char * zStr)290 int sqlite3VdbeLoadString(Vdbe *p, int iDest, const char *zStr){
291 return sqlite3VdbeAddOp4(p, OP_String8, 0, iDest, 0, zStr, 0);
292 }
293
294 /*
295 ** Generate code that initializes multiple registers to string or integer
296 ** constants. The registers begin with iDest and increase consecutively.
297 ** One register is initialized for each characgter in zTypes[]. For each
298 ** "s" character in zTypes[], the register is a string if the argument is
299 ** not NULL, or OP_Null if the value is a null pointer. For each "i" character
300 ** in zTypes[], the register is initialized to an integer.
301 **
302 ** If the input string does not end with "X" then an OP_ResultRow instruction
303 ** is generated for the values inserted.
304 */
sqlite3VdbeMultiLoad(Vdbe * p,int iDest,const char * zTypes,...)305 void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes, ...){
306 va_list ap;
307 int i;
308 char c;
309 va_start(ap, zTypes);
310 for(i=0; (c = zTypes[i])!=0; i++){
311 if( c=='s' ){
312 const char *z = va_arg(ap, const char*);
313 sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest+i, 0, z, 0);
314 }else if( c=='i' ){
315 sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest+i);
316 }else{
317 goto skip_op_resultrow;
318 }
319 }
320 sqlite3VdbeAddOp2(p, OP_ResultRow, iDest, i);
321 skip_op_resultrow:
322 va_end(ap);
323 }
324
325 /*
326 ** Add an opcode that includes the p4 value as a pointer.
327 */
sqlite3VdbeAddOp4(Vdbe * p,int op,int p1,int p2,int p3,const char * zP4,int p4type)328 int sqlite3VdbeAddOp4(
329 Vdbe *p, /* Add the opcode to this VM */
330 int op, /* The new opcode */
331 int p1, /* The P1 operand */
332 int p2, /* The P2 operand */
333 int p3, /* The P3 operand */
334 const char *zP4, /* The P4 operand */
335 int p4type /* P4 operand type */
336 ){
337 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
338 sqlite3VdbeChangeP4(p, addr, zP4, p4type);
339 return addr;
340 }
341
342 /*
343 ** Add an OP_Function or OP_PureFunc opcode.
344 **
345 ** The eCallCtx argument is information (typically taken from Expr.op2)
346 ** that describes the calling context of the function. 0 means a general
347 ** function call. NC_IsCheck means called by a check constraint,
348 ** NC_IdxExpr means called as part of an index expression. NC_PartIdx
349 ** means in the WHERE clause of a partial index. NC_GenCol means called
350 ** while computing a generated column value. 0 is the usual case.
351 */
sqlite3VdbeAddFunctionCall(Parse * pParse,int p1,int p2,int p3,int nArg,const FuncDef * pFunc,int eCallCtx)352 int sqlite3VdbeAddFunctionCall(
353 Parse *pParse, /* Parsing context */
354 int p1, /* Constant argument mask */
355 int p2, /* First argument register */
356 int p3, /* Register into which results are written */
357 int nArg, /* Number of argument */
358 const FuncDef *pFunc, /* The function to be invoked */
359 int eCallCtx /* Calling context */
360 ){
361 Vdbe *v = pParse->pVdbe;
362 int nByte;
363 int addr;
364 sqlite3_context *pCtx;
365 assert( v );
366 nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*);
367 pCtx = sqlite3DbMallocRawNN(pParse->db, nByte);
368 if( pCtx==0 ){
369 assert( pParse->db->mallocFailed );
370 freeEphemeralFunction(pParse->db, (FuncDef*)pFunc);
371 return 0;
372 }
373 pCtx->pOut = 0;
374 pCtx->pFunc = (FuncDef*)pFunc;
375 pCtx->pVdbe = 0;
376 pCtx->isError = 0;
377 pCtx->argc = nArg;
378 pCtx->iOp = sqlite3VdbeCurrentAddr(v);
379 addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function,
380 p1, p2, p3, (char*)pCtx, P4_FUNCCTX);
381 sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef);
382 return addr;
383 }
384
385 /*
386 ** Add an opcode that includes the p4 value with a P4_INT64 or
387 ** P4_REAL type.
388 */
sqlite3VdbeAddOp4Dup8(Vdbe * p,int op,int p1,int p2,int p3,const u8 * zP4,int p4type)389 int sqlite3VdbeAddOp4Dup8(
390 Vdbe *p, /* Add the opcode to this VM */
391 int op, /* The new opcode */
392 int p1, /* The P1 operand */
393 int p2, /* The P2 operand */
394 int p3, /* The P3 operand */
395 const u8 *zP4, /* The P4 operand */
396 int p4type /* P4 operand type */
397 ){
398 char *p4copy = sqlite3DbMallocRawNN(sqlite3VdbeDb(p), 8);
399 if( p4copy ) memcpy(p4copy, zP4, 8);
400 return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type);
401 }
402
403 #ifndef SQLITE_OMIT_EXPLAIN
404 /*
405 ** Return the address of the current EXPLAIN QUERY PLAN baseline.
406 ** 0 means "none".
407 */
sqlite3VdbeExplainParent(Parse * pParse)408 int sqlite3VdbeExplainParent(Parse *pParse){
409 VdbeOp *pOp;
410 if( pParse->addrExplain==0 ) return 0;
411 pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain);
412 return pOp->p2;
413 }
414
415 /*
416 ** Set a debugger breakpoint on the following routine in order to
417 ** monitor the EXPLAIN QUERY PLAN code generation.
418 */
419 #if defined(SQLITE_DEBUG)
sqlite3ExplainBreakpoint(const char * z1,const char * z2)420 void sqlite3ExplainBreakpoint(const char *z1, const char *z2){
421 (void)z1;
422 (void)z2;
423 }
424 #endif
425
426 /*
427 ** Add a new OP_ opcode.
428 **
429 ** If the bPush flag is true, then make this opcode the parent for
430 ** subsequent Explains until sqlite3VdbeExplainPop() is called.
431 */
sqlite3VdbeExplain(Parse * pParse,u8 bPush,const char * zFmt,...)432 void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){
433 #ifndef SQLITE_DEBUG
434 /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined.
435 ** But omit them (for performance) during production builds */
436 if( pParse->explain==2 )
437 #endif
438 {
439 char *zMsg;
440 Vdbe *v;
441 va_list ap;
442 int iThis;
443 va_start(ap, zFmt);
444 zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap);
445 va_end(ap);
446 v = pParse->pVdbe;
447 iThis = v->nOp;
448 sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
449 zMsg, P4_DYNAMIC);
450 sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetOp(v,-1)->p4.z);
451 if( bPush){
452 pParse->addrExplain = iThis;
453 }
454 }
455 }
456
457 /*
458 ** Pop the EXPLAIN QUERY PLAN stack one level.
459 */
sqlite3VdbeExplainPop(Parse * pParse)460 void sqlite3VdbeExplainPop(Parse *pParse){
461 sqlite3ExplainBreakpoint("POP", 0);
462 pParse->addrExplain = sqlite3VdbeExplainParent(pParse);
463 }
464 #endif /* SQLITE_OMIT_EXPLAIN */
465
466 /*
467 ** Add an OP_ParseSchema opcode. This routine is broken out from
468 ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
469 ** as having been used.
470 **
471 ** The zWhere string must have been obtained from sqlite3_malloc().
472 ** This routine will take ownership of the allocated memory.
473 */
sqlite3VdbeAddParseSchemaOp(Vdbe * p,int iDb,char * zWhere)474 void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
475 int j;
476 sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
477 for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
478 }
479
480 /*
481 ** Add an opcode that includes the p4 value as an integer.
482 */
sqlite3VdbeAddOp4Int(Vdbe * p,int op,int p1,int p2,int p3,int p4)483 int sqlite3VdbeAddOp4Int(
484 Vdbe *p, /* Add the opcode to this VM */
485 int op, /* The new opcode */
486 int p1, /* The P1 operand */
487 int p2, /* The P2 operand */
488 int p3, /* The P3 operand */
489 int p4 /* The P4 operand as an integer */
490 ){
491 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
492 if( p->db->mallocFailed==0 ){
493 VdbeOp *pOp = &p->aOp[addr];
494 pOp->p4type = P4_INT32;
495 pOp->p4.i = p4;
496 }
497 return addr;
498 }
499
500 /* Insert the end of a co-routine
501 */
sqlite3VdbeEndCoroutine(Vdbe * v,int regYield)502 void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
503 sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
504
505 /* Clear the temporary register cache, thereby ensuring that each
506 ** co-routine has its own independent set of registers, because co-routines
507 ** might expect their registers to be preserved across an OP_Yield, and
508 ** that could cause problems if two or more co-routines are using the same
509 ** temporary register.
510 */
511 v->pParse->nTempReg = 0;
512 v->pParse->nRangeReg = 0;
513 }
514
515 /*
516 ** Create a new symbolic label for an instruction that has yet to be
517 ** coded. The symbolic label is really just a negative number. The
518 ** label can be used as the P2 value of an operation. Later, when
519 ** the label is resolved to a specific address, the VDBE will scan
520 ** through its operation list and change all values of P2 which match
521 ** the label into the resolved address.
522 **
523 ** The VDBE knows that a P2 value is a label because labels are
524 ** always negative and P2 values are suppose to be non-negative.
525 ** Hence, a negative P2 value is a label that has yet to be resolved.
526 ** (Later:) This is only true for opcodes that have the OPFLG_JUMP
527 ** property.
528 **
529 ** Variable usage notes:
530 **
531 ** Parse.aLabel[x] Stores the address that the x-th label resolves
532 ** into. For testing (SQLITE_DEBUG), unresolved
533 ** labels stores -1, but that is not required.
534 ** Parse.nLabelAlloc Number of slots allocated to Parse.aLabel[]
535 ** Parse.nLabel The *negative* of the number of labels that have
536 ** been issued. The negative is stored because
537 ** that gives a performance improvement over storing
538 ** the equivalent positive value.
539 */
sqlite3VdbeMakeLabel(Parse * pParse)540 int sqlite3VdbeMakeLabel(Parse *pParse){
541 return --pParse->nLabel;
542 }
543
544 /*
545 ** Resolve label "x" to be the address of the next instruction to
546 ** be inserted. The parameter "x" must have been obtained from
547 ** a prior call to sqlite3VdbeMakeLabel().
548 */
resizeResolveLabel(Parse * p,Vdbe * v,int j)549 static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){
550 int nNewSize = 10 - p->nLabel;
551 p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
552 nNewSize*sizeof(p->aLabel[0]));
553 if( p->aLabel==0 ){
554 p->nLabelAlloc = 0;
555 }else{
556 #ifdef SQLITE_DEBUG
557 int i;
558 for(i=p->nLabelAlloc; i<nNewSize; i++) p->aLabel[i] = -1;
559 #endif
560 p->nLabelAlloc = nNewSize;
561 p->aLabel[j] = v->nOp;
562 }
563 }
sqlite3VdbeResolveLabel(Vdbe * v,int x)564 void sqlite3VdbeResolveLabel(Vdbe *v, int x){
565 Parse *p = v->pParse;
566 int j = ADDR(x);
567 assert( v->magic==VDBE_MAGIC_INIT );
568 assert( j<-p->nLabel );
569 assert( j>=0 );
570 #ifdef SQLITE_DEBUG
571 if( p->db->flags & SQLITE_VdbeAddopTrace ){
572 printf("RESOLVE LABEL %d to %d\n", x, v->nOp);
573 }
574 #endif
575 if( p->nLabelAlloc + p->nLabel < 0 ){
576 resizeResolveLabel(p,v,j);
577 }else{
578 assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */
579 p->aLabel[j] = v->nOp;
580 }
581 }
582
583 /*
584 ** Mark the VDBE as one that can only be run one time.
585 */
sqlite3VdbeRunOnlyOnce(Vdbe * p)586 void sqlite3VdbeRunOnlyOnce(Vdbe *p){
587 p->runOnlyOnce = 1;
588 }
589
590 /*
591 ** Mark the VDBE as one that can only be run multiple times.
592 */
sqlite3VdbeReusable(Vdbe * p)593 void sqlite3VdbeReusable(Vdbe *p){
594 p->runOnlyOnce = 0;
595 }
596
597 #ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */
598
599 /*
600 ** The following type and function are used to iterate through all opcodes
601 ** in a Vdbe main program and each of the sub-programs (triggers) it may
602 ** invoke directly or indirectly. It should be used as follows:
603 **
604 ** Op *pOp;
605 ** VdbeOpIter sIter;
606 **
607 ** memset(&sIter, 0, sizeof(sIter));
608 ** sIter.v = v; // v is of type Vdbe*
609 ** while( (pOp = opIterNext(&sIter)) ){
610 ** // Do something with pOp
611 ** }
612 ** sqlite3DbFree(v->db, sIter.apSub);
613 **
614 */
615 typedef struct VdbeOpIter VdbeOpIter;
616 struct VdbeOpIter {
617 Vdbe *v; /* Vdbe to iterate through the opcodes of */
618 SubProgram **apSub; /* Array of subprograms */
619 int nSub; /* Number of entries in apSub */
620 int iAddr; /* Address of next instruction to return */
621 int iSub; /* 0 = main program, 1 = first sub-program etc. */
622 };
opIterNext(VdbeOpIter * p)623 static Op *opIterNext(VdbeOpIter *p){
624 Vdbe *v = p->v;
625 Op *pRet = 0;
626 Op *aOp;
627 int nOp;
628
629 if( p->iSub<=p->nSub ){
630
631 if( p->iSub==0 ){
632 aOp = v->aOp;
633 nOp = v->nOp;
634 }else{
635 aOp = p->apSub[p->iSub-1]->aOp;
636 nOp = p->apSub[p->iSub-1]->nOp;
637 }
638 assert( p->iAddr<nOp );
639
640 pRet = &aOp[p->iAddr];
641 p->iAddr++;
642 if( p->iAddr==nOp ){
643 p->iSub++;
644 p->iAddr = 0;
645 }
646
647 if( pRet->p4type==P4_SUBPROGRAM ){
648 int nByte = (p->nSub+1)*sizeof(SubProgram*);
649 int j;
650 for(j=0; j<p->nSub; j++){
651 if( p->apSub[j]==pRet->p4.pProgram ) break;
652 }
653 if( j==p->nSub ){
654 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
655 if( !p->apSub ){
656 pRet = 0;
657 }else{
658 p->apSub[p->nSub++] = pRet->p4.pProgram;
659 }
660 }
661 }
662 }
663
664 return pRet;
665 }
666
667 /*
668 ** Check if the program stored in the VM associated with pParse may
669 ** throw an ABORT exception (causing the statement, but not entire transaction
670 ** to be rolled back). This condition is true if the main program or any
671 ** sub-programs contains any of the following:
672 **
673 ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
674 ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
675 ** * OP_Destroy
676 ** * OP_VUpdate
677 ** * OP_VCreate
678 ** * OP_VRename
679 ** * OP_FkCounter with P2==0 (immediate foreign key constraint)
680 ** * OP_CreateBtree/BTREE_INTKEY and OP_InitCoroutine
681 ** (for CREATE TABLE AS SELECT ...)
682 **
683 ** Then check that the value of Parse.mayAbort is true if an
684 ** ABORT may be thrown, or false otherwise. Return true if it does
685 ** match, or false otherwise. This function is intended to be used as
686 ** part of an assert statement in the compiler. Similar to:
687 **
688 ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
689 */
sqlite3VdbeAssertMayAbort(Vdbe * v,int mayAbort)690 int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
691 int hasAbort = 0;
692 int hasFkCounter = 0;
693 int hasCreateTable = 0;
694 int hasCreateIndex = 0;
695 int hasInitCoroutine = 0;
696 Op *pOp;
697 VdbeOpIter sIter;
698 memset(&sIter, 0, sizeof(sIter));
699 sIter.v = v;
700
701 while( (pOp = opIterNext(&sIter))!=0 ){
702 int opcode = pOp->opcode;
703 if( opcode==OP_Destroy || opcode==OP_VUpdate || opcode==OP_VRename
704 || opcode==OP_VDestroy
705 || opcode==OP_VCreate
706 || (opcode==OP_ParseSchema && pOp->p4.z==0)
707 || ((opcode==OP_Halt || opcode==OP_HaltIfNull)
708 && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort))
709 ){
710 hasAbort = 1;
711 break;
712 }
713 if( opcode==OP_CreateBtree && pOp->p3==BTREE_INTKEY ) hasCreateTable = 1;
714 if( mayAbort ){
715 /* hasCreateIndex may also be set for some DELETE statements that use
716 ** OP_Clear. So this routine may end up returning true in the case
717 ** where a "DELETE FROM tbl" has a statement-journal but does not
718 ** require one. This is not so bad - it is an inefficiency, not a bug. */
719 if( opcode==OP_CreateBtree && pOp->p3==BTREE_BLOBKEY ) hasCreateIndex = 1;
720 if( opcode==OP_Clear ) hasCreateIndex = 1;
721 }
722 if( opcode==OP_InitCoroutine ) hasInitCoroutine = 1;
723 #ifndef SQLITE_OMIT_FOREIGN_KEY
724 if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){
725 hasFkCounter = 1;
726 }
727 #endif
728 }
729 sqlite3DbFree(v->db, sIter.apSub);
730
731 /* Return true if hasAbort==mayAbort. Or if a malloc failure occurred.
732 ** If malloc failed, then the while() loop above may not have iterated
733 ** through all opcodes and hasAbort may be set incorrectly. Return
734 ** true for this case to prevent the assert() in the callers frame
735 ** from failing. */
736 return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter
737 || (hasCreateTable && hasInitCoroutine) || hasCreateIndex
738 );
739 }
740 #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */
741
742 #ifdef SQLITE_DEBUG
743 /*
744 ** Increment the nWrite counter in the VDBE if the cursor is not an
745 ** ephemeral cursor, or if the cursor argument is NULL.
746 */
sqlite3VdbeIncrWriteCounter(Vdbe * p,VdbeCursor * pC)747 void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){
748 if( pC==0
749 || (pC->eCurType!=CURTYPE_SORTER
750 && pC->eCurType!=CURTYPE_PSEUDO
751 && !pC->isEphemeral)
752 ){
753 p->nWrite++;
754 }
755 }
756 #endif
757
758 #ifdef SQLITE_DEBUG
759 /*
760 ** Assert if an Abort at this point in time might result in a corrupt
761 ** database.
762 */
sqlite3VdbeAssertAbortable(Vdbe * p)763 void sqlite3VdbeAssertAbortable(Vdbe *p){
764 assert( p->nWrite==0 || p->usesStmtJournal );
765 }
766 #endif
767
768 /*
769 ** This routine is called after all opcodes have been inserted. It loops
770 ** through all the opcodes and fixes up some details.
771 **
772 ** (1) For each jump instruction with a negative P2 value (a label)
773 ** resolve the P2 value to an actual address.
774 **
775 ** (2) Compute the maximum number of arguments used by any SQL function
776 ** and store that value in *pMaxFuncArgs.
777 **
778 ** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately
779 ** indicate what the prepared statement actually does.
780 **
781 ** (4) Initialize the p4.xAdvance pointer on opcodes that use it.
782 **
783 ** (5) Reclaim the memory allocated for storing labels.
784 **
785 ** This routine will only function correctly if the mkopcodeh.tcl generator
786 ** script numbers the opcodes correctly. Changes to this routine must be
787 ** coordinated with changes to mkopcodeh.tcl.
788 */
resolveP2Values(Vdbe * p,int * pMaxFuncArgs)789 static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
790 int nMaxArgs = *pMaxFuncArgs;
791 Op *pOp;
792 Parse *pParse = p->pParse;
793 int *aLabel = pParse->aLabel;
794 p->readOnly = 1;
795 p->bIsReader = 0;
796 pOp = &p->aOp[p->nOp-1];
797 while(1){
798
799 /* Only JUMP opcodes and the short list of special opcodes in the switch
800 ** below need to be considered. The mkopcodeh.tcl generator script groups
801 ** all these opcodes together near the front of the opcode list. Skip
802 ** any opcode that does not need processing by virtual of the fact that
803 ** it is larger than SQLITE_MX_JUMP_OPCODE, as a performance optimization.
804 */
805 if( pOp->opcode<=SQLITE_MX_JUMP_OPCODE ){
806 /* NOTE: Be sure to update mkopcodeh.tcl when adding or removing
807 ** cases from this switch! */
808 switch( pOp->opcode ){
809 case OP_Transaction: {
810 if( pOp->p2!=0 ) p->readOnly = 0;
811 /* fall thru */
812 }
813 case OP_AutoCommit:
814 case OP_Savepoint: {
815 p->bIsReader = 1;
816 break;
817 }
818 #ifndef SQLITE_OMIT_WAL
819 case OP_Checkpoint:
820 #endif
821 case OP_Vacuum:
822 case OP_JournalMode: {
823 p->readOnly = 0;
824 p->bIsReader = 1;
825 break;
826 }
827 case OP_Next:
828 case OP_SorterNext: {
829 pOp->p4.xAdvance = sqlite3BtreeNext;
830 pOp->p4type = P4_ADVANCE;
831 /* The code generator never codes any of these opcodes as a jump
832 ** to a label. They are always coded as a jump backwards to a
833 ** known address */
834 assert( pOp->p2>=0 );
835 break;
836 }
837 case OP_Prev: {
838 pOp->p4.xAdvance = sqlite3BtreePrevious;
839 pOp->p4type = P4_ADVANCE;
840 /* The code generator never codes any of these opcodes as a jump
841 ** to a label. They are always coded as a jump backwards to a
842 ** known address */
843 assert( pOp->p2>=0 );
844 break;
845 }
846 #ifndef SQLITE_OMIT_VIRTUALTABLE
847 case OP_VUpdate: {
848 if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
849 break;
850 }
851 case OP_VFilter: {
852 int n;
853 assert( (pOp - p->aOp) >= 3 );
854 assert( pOp[-1].opcode==OP_Integer );
855 n = pOp[-1].p1;
856 if( n>nMaxArgs ) nMaxArgs = n;
857 /* Fall through into the default case */
858 }
859 #endif
860 default: {
861 if( pOp->p2<0 ){
862 /* The mkopcodeh.tcl script has so arranged things that the only
863 ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
864 ** have non-negative values for P2. */
865 assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 );
866 assert( ADDR(pOp->p2)<-pParse->nLabel );
867 pOp->p2 = aLabel[ADDR(pOp->p2)];
868 }
869 break;
870 }
871 }
872 /* The mkopcodeh.tcl script has so arranged things that the only
873 ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
874 ** have non-negative values for P2. */
875 assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0);
876 }
877 if( pOp==p->aOp ) break;
878 pOp--;
879 }
880 sqlite3DbFree(p->db, pParse->aLabel);
881 pParse->aLabel = 0;
882 pParse->nLabel = 0;
883 *pMaxFuncArgs = nMaxArgs;
884 assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) );
885 }
886
887 /*
888 ** Return the address of the next instruction to be inserted.
889 */
sqlite3VdbeCurrentAddr(Vdbe * p)890 int sqlite3VdbeCurrentAddr(Vdbe *p){
891 assert( p->magic==VDBE_MAGIC_INIT );
892 return p->nOp;
893 }
894
895 /*
896 ** Verify that at least N opcode slots are available in p without
897 ** having to malloc for more space (except when compiled using
898 ** SQLITE_TEST_REALLOC_STRESS). This interface is used during testing
899 ** to verify that certain calls to sqlite3VdbeAddOpList() can never
900 ** fail due to a OOM fault and hence that the return value from
901 ** sqlite3VdbeAddOpList() will always be non-NULL.
902 */
903 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
sqlite3VdbeVerifyNoMallocRequired(Vdbe * p,int N)904 void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N){
905 assert( p->nOp + N <= p->nOpAlloc );
906 }
907 #endif
908
909 /*
910 ** Verify that the VM passed as the only argument does not contain
911 ** an OP_ResultRow opcode. Fail an assert() if it does. This is used
912 ** by code in pragma.c to ensure that the implementation of certain
913 ** pragmas comports with the flags specified in the mkpragmatab.tcl
914 ** script.
915 */
916 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
sqlite3VdbeVerifyNoResultRow(Vdbe * p)917 void sqlite3VdbeVerifyNoResultRow(Vdbe *p){
918 int i;
919 for(i=0; i<p->nOp; i++){
920 assert( p->aOp[i].opcode!=OP_ResultRow );
921 }
922 }
923 #endif
924
925 /*
926 ** Generate code (a single OP_Abortable opcode) that will
927 ** verify that the VDBE program can safely call Abort in the current
928 ** context.
929 */
930 #if defined(SQLITE_DEBUG)
sqlite3VdbeVerifyAbortable(Vdbe * p,int onError)931 void sqlite3VdbeVerifyAbortable(Vdbe *p, int onError){
932 if( onError==OE_Abort ) sqlite3VdbeAddOp0(p, OP_Abortable);
933 }
934 #endif
935
936 /*
937 ** This function returns a pointer to the array of opcodes associated with
938 ** the Vdbe passed as the first argument. It is the callers responsibility
939 ** to arrange for the returned array to be eventually freed using the
940 ** vdbeFreeOpArray() function.
941 **
942 ** Before returning, *pnOp is set to the number of entries in the returned
943 ** array. Also, *pnMaxArg is set to the larger of its current value and
944 ** the number of entries in the Vdbe.apArg[] array required to execute the
945 ** returned program.
946 */
sqlite3VdbeTakeOpArray(Vdbe * p,int * pnOp,int * pnMaxArg)947 VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){
948 VdbeOp *aOp = p->aOp;
949 assert( aOp && !p->db->mallocFailed );
950
951 /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
952 assert( DbMaskAllZero(p->btreeMask) );
953
954 resolveP2Values(p, pnMaxArg);
955 *pnOp = p->nOp;
956 p->aOp = 0;
957 return aOp;
958 }
959
960 /*
961 ** Add a whole list of operations to the operation stack. Return a
962 ** pointer to the first operation inserted.
963 **
964 ** Non-zero P2 arguments to jump instructions are automatically adjusted
965 ** so that the jump target is relative to the first operation inserted.
966 */
sqlite3VdbeAddOpList(Vdbe * p,int nOp,VdbeOpList const * aOp,int iLineno)967 VdbeOp *sqlite3VdbeAddOpList(
968 Vdbe *p, /* Add opcodes to the prepared statement */
969 int nOp, /* Number of opcodes to add */
970 VdbeOpList const *aOp, /* The opcodes to be added */
971 int iLineno /* Source-file line number of first opcode */
972 ){
973 int i;
974 VdbeOp *pOut, *pFirst;
975 assert( nOp>0 );
976 assert( p->magic==VDBE_MAGIC_INIT );
977 if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){
978 return 0;
979 }
980 pFirst = pOut = &p->aOp[p->nOp];
981 for(i=0; i<nOp; i++, aOp++, pOut++){
982 pOut->opcode = aOp->opcode;
983 pOut->p1 = aOp->p1;
984 pOut->p2 = aOp->p2;
985 assert( aOp->p2>=0 );
986 if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){
987 pOut->p2 += p->nOp;
988 }
989 pOut->p3 = aOp->p3;
990 pOut->p4type = P4_NOTUSED;
991 pOut->p4.p = 0;
992 pOut->p5 = 0;
993 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
994 pOut->zComment = 0;
995 #endif
996 #ifdef SQLITE_VDBE_COVERAGE
997 pOut->iSrcLine = iLineno+i;
998 #else
999 (void)iLineno;
1000 #endif
1001 #ifdef SQLITE_DEBUG
1002 if( p->db->flags & SQLITE_VdbeAddopTrace ){
1003 sqlite3VdbePrintOp(0, i+p->nOp, &p->aOp[i+p->nOp]);
1004 }
1005 #endif
1006 }
1007 p->nOp += nOp;
1008 return pFirst;
1009 }
1010
1011 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS)
1012 /*
1013 ** Add an entry to the array of counters managed by sqlite3_stmt_scanstatus().
1014 */
sqlite3VdbeScanStatus(Vdbe * p,int addrExplain,int addrLoop,int addrVisit,LogEst nEst,const char * zName)1015 void sqlite3VdbeScanStatus(
1016 Vdbe *p, /* VM to add scanstatus() to */
1017 int addrExplain, /* Address of OP_Explain (or 0) */
1018 int addrLoop, /* Address of loop counter */
1019 int addrVisit, /* Address of rows visited counter */
1020 LogEst nEst, /* Estimated number of output rows */
1021 const char *zName /* Name of table or index being scanned */
1022 ){
1023 sqlite3_int64 nByte = (p->nScan+1) * sizeof(ScanStatus);
1024 ScanStatus *aNew;
1025 aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte);
1026 if( aNew ){
1027 ScanStatus *pNew = &aNew[p->nScan++];
1028 pNew->addrExplain = addrExplain;
1029 pNew->addrLoop = addrLoop;
1030 pNew->addrVisit = addrVisit;
1031 pNew->nEst = nEst;
1032 pNew->zName = sqlite3DbStrDup(p->db, zName);
1033 p->aScan = aNew;
1034 }
1035 }
1036 #endif
1037
1038
1039 /*
1040 ** Change the value of the opcode, or P1, P2, P3, or P5 operands
1041 ** for a specific instruction.
1042 */
sqlite3VdbeChangeOpcode(Vdbe * p,int addr,u8 iNewOpcode)1043 void sqlite3VdbeChangeOpcode(Vdbe *p, int addr, u8 iNewOpcode){
1044 sqlite3VdbeGetOp(p,addr)->opcode = iNewOpcode;
1045 }
sqlite3VdbeChangeP1(Vdbe * p,int addr,int val)1046 void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){
1047 sqlite3VdbeGetOp(p,addr)->p1 = val;
1048 }
sqlite3VdbeChangeP2(Vdbe * p,int addr,int val)1049 void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){
1050 sqlite3VdbeGetOp(p,addr)->p2 = val;
1051 }
sqlite3VdbeChangeP3(Vdbe * p,int addr,int val)1052 void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){
1053 sqlite3VdbeGetOp(p,addr)->p3 = val;
1054 }
sqlite3VdbeChangeP5(Vdbe * p,u16 p5)1055 void sqlite3VdbeChangeP5(Vdbe *p, u16 p5){
1056 assert( p->nOp>0 || p->db->mallocFailed );
1057 if( p->nOp>0 ) p->aOp[p->nOp-1].p5 = p5;
1058 }
1059
1060 /*
1061 ** Change the P2 operand of instruction addr so that it points to
1062 ** the address of the next instruction to be coded.
1063 */
sqlite3VdbeJumpHere(Vdbe * p,int addr)1064 void sqlite3VdbeJumpHere(Vdbe *p, int addr){
1065 sqlite3VdbeChangeP2(p, addr, p->nOp);
1066 }
1067
1068
1069 /*
1070 ** If the input FuncDef structure is ephemeral, then free it. If
1071 ** the FuncDef is not ephermal, then do nothing.
1072 */
freeEphemeralFunction(sqlite3 * db,FuncDef * pDef)1073 static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){
1074 if( (pDef->funcFlags & SQLITE_FUNC_EPHEM)!=0 ){
1075 sqlite3DbFreeNN(db, pDef);
1076 }
1077 }
1078
1079 /*
1080 ** Delete a P4 value if necessary.
1081 */
freeP4Mem(sqlite3 * db,Mem * p)1082 static SQLITE_NOINLINE void freeP4Mem(sqlite3 *db, Mem *p){
1083 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
1084 sqlite3DbFreeNN(db, p);
1085 }
freeP4FuncCtx(sqlite3 * db,sqlite3_context * p)1086 static SQLITE_NOINLINE void freeP4FuncCtx(sqlite3 *db, sqlite3_context *p){
1087 freeEphemeralFunction(db, p->pFunc);
1088 sqlite3DbFreeNN(db, p);
1089 }
freeP4(sqlite3 * db,int p4type,void * p4)1090 static void freeP4(sqlite3 *db, int p4type, void *p4){
1091 assert( db );
1092 switch( p4type ){
1093 case P4_FUNCCTX: {
1094 freeP4FuncCtx(db, (sqlite3_context*)p4);
1095 break;
1096 }
1097 case P4_REAL:
1098 case P4_INT64:
1099 case P4_DYNAMIC:
1100 case P4_DYNBLOB:
1101 case P4_INTARRAY: {
1102 sqlite3DbFree(db, p4);
1103 break;
1104 }
1105 case P4_KEYINFO: {
1106 if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4);
1107 break;
1108 }
1109 #ifdef SQLITE_ENABLE_CURSOR_HINTS
1110 case P4_EXPR: {
1111 sqlite3ExprDelete(db, (Expr*)p4);
1112 break;
1113 }
1114 #endif
1115 case P4_FUNCDEF: {
1116 freeEphemeralFunction(db, (FuncDef*)p4);
1117 break;
1118 }
1119 case P4_MEM: {
1120 if( db->pnBytesFreed==0 ){
1121 sqlite3ValueFree((sqlite3_value*)p4);
1122 }else{
1123 freeP4Mem(db, (Mem*)p4);
1124 }
1125 break;
1126 }
1127 case P4_VTAB : {
1128 if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4);
1129 break;
1130 }
1131 }
1132 }
1133
1134 /*
1135 ** Free the space allocated for aOp and any p4 values allocated for the
1136 ** opcodes contained within. If aOp is not NULL it is assumed to contain
1137 ** nOp entries.
1138 */
vdbeFreeOpArray(sqlite3 * db,Op * aOp,int nOp)1139 static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
1140 if( aOp ){
1141 Op *pOp;
1142 for(pOp=&aOp[nOp-1]; pOp>=aOp; pOp--){
1143 if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p);
1144 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1145 sqlite3DbFree(db, pOp->zComment);
1146 #endif
1147 }
1148 sqlite3DbFreeNN(db, aOp);
1149 }
1150 }
1151
1152 /*
1153 ** Link the SubProgram object passed as the second argument into the linked
1154 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
1155 ** objects when the VM is no longer required.
1156 */
sqlite3VdbeLinkSubProgram(Vdbe * pVdbe,SubProgram * p)1157 void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){
1158 p->pNext = pVdbe->pProgram;
1159 pVdbe->pProgram = p;
1160 }
1161
1162 /*
1163 ** Return true if the given Vdbe has any SubPrograms.
1164 */
sqlite3VdbeHasSubProgram(Vdbe * pVdbe)1165 int sqlite3VdbeHasSubProgram(Vdbe *pVdbe){
1166 return pVdbe->pProgram!=0;
1167 }
1168
1169 /*
1170 ** Change the opcode at addr into OP_Noop
1171 */
sqlite3VdbeChangeToNoop(Vdbe * p,int addr)1172 int sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
1173 VdbeOp *pOp;
1174 if( p->db->mallocFailed ) return 0;
1175 assert( addr>=0 && addr<p->nOp );
1176 pOp = &p->aOp[addr];
1177 freeP4(p->db, pOp->p4type, pOp->p4.p);
1178 pOp->p4type = P4_NOTUSED;
1179 pOp->p4.z = 0;
1180 pOp->opcode = OP_Noop;
1181 return 1;
1182 }
1183
1184 /*
1185 ** If the last opcode is "op" and it is not a jump destination,
1186 ** then remove it. Return true if and only if an opcode was removed.
1187 */
sqlite3VdbeDeletePriorOpcode(Vdbe * p,u8 op)1188 int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){
1189 if( p->nOp>0 && p->aOp[p->nOp-1].opcode==op ){
1190 return sqlite3VdbeChangeToNoop(p, p->nOp-1);
1191 }else{
1192 return 0;
1193 }
1194 }
1195
1196 #ifdef SQLITE_DEBUG
1197 /*
1198 ** Generate an OP_ReleaseReg opcode to indicate that a range of
1199 ** registers, except any identified by mask, are no longer in use.
1200 */
sqlite3VdbeReleaseRegisters(Parse * pParse,int iFirst,int N,u32 mask,int bUndefine)1201 void sqlite3VdbeReleaseRegisters(
1202 Parse *pParse, /* Parsing context */
1203 int iFirst, /* Index of first register to be released */
1204 int N, /* Number of registers to release */
1205 u32 mask, /* Mask of registers to NOT release */
1206 int bUndefine /* If true, mark registers as undefined */
1207 ){
1208 if( N==0 ) return;
1209 assert( pParse->pVdbe );
1210 assert( iFirst>=1 );
1211 assert( iFirst+N-1<=pParse->nMem );
1212 if( N<=31 && mask!=0 ){
1213 while( N>0 && (mask&1)!=0 ){
1214 mask >>= 1;
1215 iFirst++;
1216 N--;
1217 }
1218 while( N>0 && N<=32 && (mask & MASKBIT32(N-1))!=0 ){
1219 mask &= ~MASKBIT32(N-1);
1220 N--;
1221 }
1222 }
1223 if( N>0 ){
1224 sqlite3VdbeAddOp3(pParse->pVdbe, OP_ReleaseReg, iFirst, N, *(int*)&mask);
1225 if( bUndefine ) sqlite3VdbeChangeP5(pParse->pVdbe, 1);
1226 }
1227 }
1228 #endif /* SQLITE_DEBUG */
1229
1230
1231 /*
1232 ** Change the value of the P4 operand for a specific instruction.
1233 ** This routine is useful when a large program is loaded from a
1234 ** static array using sqlite3VdbeAddOpList but we want to make a
1235 ** few minor changes to the program.
1236 **
1237 ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
1238 ** the string is made into memory obtained from sqlite3_malloc().
1239 ** A value of n==0 means copy bytes of zP4 up to and including the
1240 ** first null byte. If n>0 then copy n+1 bytes of zP4.
1241 **
1242 ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
1243 ** to a string or structure that is guaranteed to exist for the lifetime of
1244 ** the Vdbe. In these cases we can just copy the pointer.
1245 **
1246 ** If addr<0 then change P4 on the most recently inserted instruction.
1247 */
vdbeChangeP4Full(Vdbe * p,Op * pOp,const char * zP4,int n)1248 static void SQLITE_NOINLINE vdbeChangeP4Full(
1249 Vdbe *p,
1250 Op *pOp,
1251 const char *zP4,
1252 int n
1253 ){
1254 if( pOp->p4type ){
1255 freeP4(p->db, pOp->p4type, pOp->p4.p);
1256 pOp->p4type = 0;
1257 pOp->p4.p = 0;
1258 }
1259 if( n<0 ){
1260 sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n);
1261 }else{
1262 if( n==0 ) n = sqlite3Strlen30(zP4);
1263 pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
1264 pOp->p4type = P4_DYNAMIC;
1265 }
1266 }
sqlite3VdbeChangeP4(Vdbe * p,int addr,const char * zP4,int n)1267 void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
1268 Op *pOp;
1269 sqlite3 *db;
1270 assert( p!=0 );
1271 db = p->db;
1272 assert( p->magic==VDBE_MAGIC_INIT );
1273 assert( p->aOp!=0 || db->mallocFailed );
1274 if( db->mallocFailed ){
1275 if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4);
1276 return;
1277 }
1278 assert( p->nOp>0 );
1279 assert( addr<p->nOp );
1280 if( addr<0 ){
1281 addr = p->nOp - 1;
1282 }
1283 pOp = &p->aOp[addr];
1284 if( n>=0 || pOp->p4type ){
1285 vdbeChangeP4Full(p, pOp, zP4, n);
1286 return;
1287 }
1288 if( n==P4_INT32 ){
1289 /* Note: this cast is safe, because the origin data point was an int
1290 ** that was cast to a (const char *). */
1291 pOp->p4.i = SQLITE_PTR_TO_INT(zP4);
1292 pOp->p4type = P4_INT32;
1293 }else if( zP4!=0 ){
1294 assert( n<0 );
1295 pOp->p4.p = (void*)zP4;
1296 pOp->p4type = (signed char)n;
1297 if( n==P4_VTAB ) sqlite3VtabLock((VTable*)zP4);
1298 }
1299 }
1300
1301 /*
1302 ** Change the P4 operand of the most recently coded instruction
1303 ** to the value defined by the arguments. This is a high-speed
1304 ** version of sqlite3VdbeChangeP4().
1305 **
1306 ** The P4 operand must not have been previously defined. And the new
1307 ** P4 must not be P4_INT32. Use sqlite3VdbeChangeP4() in either of
1308 ** those cases.
1309 */
sqlite3VdbeAppendP4(Vdbe * p,void * pP4,int n)1310 void sqlite3VdbeAppendP4(Vdbe *p, void *pP4, int n){
1311 VdbeOp *pOp;
1312 assert( n!=P4_INT32 && n!=P4_VTAB );
1313 assert( n<=0 );
1314 if( p->db->mallocFailed ){
1315 freeP4(p->db, n, pP4);
1316 }else{
1317 assert( pP4!=0 );
1318 assert( p->nOp>0 );
1319 pOp = &p->aOp[p->nOp-1];
1320 assert( pOp->p4type==P4_NOTUSED );
1321 pOp->p4type = n;
1322 pOp->p4.p = pP4;
1323 }
1324 }
1325
1326 /*
1327 ** Set the P4 on the most recently added opcode to the KeyInfo for the
1328 ** index given.
1329 */
sqlite3VdbeSetP4KeyInfo(Parse * pParse,Index * pIdx)1330 void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){
1331 Vdbe *v = pParse->pVdbe;
1332 KeyInfo *pKeyInfo;
1333 assert( v!=0 );
1334 assert( pIdx!=0 );
1335 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx);
1336 if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
1337 }
1338
1339 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1340 /*
1341 ** Change the comment on the most recently coded instruction. Or
1342 ** insert a No-op and add the comment to that new instruction. This
1343 ** makes the code easier to read during debugging. None of this happens
1344 ** in a production build.
1345 */
vdbeVComment(Vdbe * p,const char * zFormat,va_list ap)1346 static void vdbeVComment(Vdbe *p, const char *zFormat, va_list ap){
1347 assert( p->nOp>0 || p->aOp==0 );
1348 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed
1349 || p->pParse->nErr>0 );
1350 if( p->nOp ){
1351 assert( p->aOp );
1352 sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment);
1353 p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap);
1354 }
1355 }
sqlite3VdbeComment(Vdbe * p,const char * zFormat,...)1356 void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
1357 va_list ap;
1358 if( p ){
1359 va_start(ap, zFormat);
1360 vdbeVComment(p, zFormat, ap);
1361 va_end(ap);
1362 }
1363 }
sqlite3VdbeNoopComment(Vdbe * p,const char * zFormat,...)1364 void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){
1365 va_list ap;
1366 if( p ){
1367 sqlite3VdbeAddOp0(p, OP_Noop);
1368 va_start(ap, zFormat);
1369 vdbeVComment(p, zFormat, ap);
1370 va_end(ap);
1371 }
1372 }
1373 #endif /* NDEBUG */
1374
1375 #ifdef SQLITE_VDBE_COVERAGE
1376 /*
1377 ** Set the value if the iSrcLine field for the previously coded instruction.
1378 */
sqlite3VdbeSetLineNumber(Vdbe * v,int iLine)1379 void sqlite3VdbeSetLineNumber(Vdbe *v, int iLine){
1380 sqlite3VdbeGetOp(v,-1)->iSrcLine = iLine;
1381 }
1382 #endif /* SQLITE_VDBE_COVERAGE */
1383
1384 /*
1385 ** Return the opcode for a given address. If the address is -1, then
1386 ** return the most recently inserted opcode.
1387 **
1388 ** If a memory allocation error has occurred prior to the calling of this
1389 ** routine, then a pointer to a dummy VdbeOp will be returned. That opcode
1390 ** is readable but not writable, though it is cast to a writable value.
1391 ** The return of a dummy opcode allows the call to continue functioning
1392 ** after an OOM fault without having to check to see if the return from
1393 ** this routine is a valid pointer. But because the dummy.opcode is 0,
1394 ** dummy will never be written to. This is verified by code inspection and
1395 ** by running with Valgrind.
1396 */
sqlite3VdbeGetOp(Vdbe * p,int addr)1397 VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
1398 /* C89 specifies that the constant "dummy" will be initialized to all
1399 ** zeros, which is correct. MSVC generates a warning, nevertheless. */
1400 static VdbeOp dummy; /* Ignore the MSVC warning about no initializer */
1401 assert( p->magic==VDBE_MAGIC_INIT );
1402 if( addr<0 ){
1403 addr = p->nOp - 1;
1404 }
1405 assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
1406 if( p->db->mallocFailed ){
1407 return (VdbeOp*)&dummy;
1408 }else{
1409 return &p->aOp[addr];
1410 }
1411 }
1412
1413 #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS)
1414 /*
1415 ** Return an integer value for one of the parameters to the opcode pOp
1416 ** determined by character c.
1417 */
translateP(char c,const Op * pOp)1418 static int translateP(char c, const Op *pOp){
1419 if( c=='1' ) return pOp->p1;
1420 if( c=='2' ) return pOp->p2;
1421 if( c=='3' ) return pOp->p3;
1422 if( c=='4' ) return pOp->p4.i;
1423 return pOp->p5;
1424 }
1425
1426 /*
1427 ** Compute a string for the "comment" field of a VDBE opcode listing.
1428 **
1429 ** The Synopsis: field in comments in the vdbe.c source file gets converted
1430 ** to an extra string that is appended to the sqlite3OpcodeName(). In the
1431 ** absence of other comments, this synopsis becomes the comment on the opcode.
1432 ** Some translation occurs:
1433 **
1434 ** "PX" -> "r[X]"
1435 ** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1
1436 ** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0
1437 ** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x
1438 */
displayComment(const Op * pOp,const char * zP4,char * zTemp,int nTemp)1439 static int displayComment(
1440 const Op *pOp, /* The opcode to be commented */
1441 const char *zP4, /* Previously obtained value for P4 */
1442 char *zTemp, /* Write result here */
1443 int nTemp /* Space available in zTemp[] */
1444 ){
1445 const char *zOpName;
1446 const char *zSynopsis;
1447 int nOpName;
1448 int ii, jj;
1449 char zAlt[50];
1450 zOpName = sqlite3OpcodeName(pOp->opcode);
1451 nOpName = sqlite3Strlen30(zOpName);
1452 if( zOpName[nOpName+1] ){
1453 int seenCom = 0;
1454 char c;
1455 zSynopsis = zOpName += nOpName + 1;
1456 if( strncmp(zSynopsis,"IF ",3)==0 ){
1457 if( pOp->p5 & SQLITE_STOREP2 ){
1458 sqlite3_snprintf(sizeof(zAlt), zAlt, "r[P2] = (%s)", zSynopsis+3);
1459 }else{
1460 sqlite3_snprintf(sizeof(zAlt), zAlt, "if %s goto P2", zSynopsis+3);
1461 }
1462 zSynopsis = zAlt;
1463 }
1464 for(ii=jj=0; jj<nTemp-1 && (c = zSynopsis[ii])!=0; ii++){
1465 if( c=='P' ){
1466 c = zSynopsis[++ii];
1467 if( c=='4' ){
1468 sqlite3_snprintf(nTemp-jj, zTemp+jj, "%s", zP4);
1469 }else if( c=='X' ){
1470 sqlite3_snprintf(nTemp-jj, zTemp+jj, "%s", pOp->zComment);
1471 seenCom = 1;
1472 }else{
1473 int v1 = translateP(c, pOp);
1474 int v2;
1475 sqlite3_snprintf(nTemp-jj, zTemp+jj, "%d", v1);
1476 if( strncmp(zSynopsis+ii+1, "@P", 2)==0 ){
1477 ii += 3;
1478 jj += sqlite3Strlen30(zTemp+jj);
1479 v2 = translateP(zSynopsis[ii], pOp);
1480 if( strncmp(zSynopsis+ii+1,"+1",2)==0 ){
1481 ii += 2;
1482 v2++;
1483 }
1484 if( v2>1 ){
1485 sqlite3_snprintf(nTemp-jj, zTemp+jj, "..%d", v1+v2-1);
1486 }
1487 }else if( strncmp(zSynopsis+ii+1, "..P3", 4)==0 && pOp->p3==0 ){
1488 ii += 4;
1489 }
1490 }
1491 jj += sqlite3Strlen30(zTemp+jj);
1492 }else{
1493 zTemp[jj++] = c;
1494 }
1495 }
1496 if( !seenCom && jj<nTemp-5 && pOp->zComment ){
1497 sqlite3_snprintf(nTemp-jj, zTemp+jj, "; %s", pOp->zComment);
1498 jj += sqlite3Strlen30(zTemp+jj);
1499 }
1500 if( jj<nTemp ) zTemp[jj] = 0;
1501 }else if( pOp->zComment ){
1502 sqlite3_snprintf(nTemp, zTemp, "%s", pOp->zComment);
1503 jj = sqlite3Strlen30(zTemp);
1504 }else{
1505 zTemp[0] = 0;
1506 jj = 0;
1507 }
1508 return jj;
1509 }
1510 #endif /* SQLITE_DEBUG */
1511
1512 #if VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS)
1513 /*
1514 ** Translate the P4.pExpr value for an OP_CursorHint opcode into text
1515 ** that can be displayed in the P4 column of EXPLAIN output.
1516 */
displayP4Expr(StrAccum * p,Expr * pExpr)1517 static void displayP4Expr(StrAccum *p, Expr *pExpr){
1518 const char *zOp = 0;
1519 switch( pExpr->op ){
1520 case TK_STRING:
1521 sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
1522 break;
1523 case TK_INTEGER:
1524 sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
1525 break;
1526 case TK_NULL:
1527 sqlite3_str_appendf(p, "NULL");
1528 break;
1529 case TK_REGISTER: {
1530 sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
1531 break;
1532 }
1533 case TK_COLUMN: {
1534 if( pExpr->iColumn<0 ){
1535 sqlite3_str_appendf(p, "rowid");
1536 }else{
1537 sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
1538 }
1539 break;
1540 }
1541 case TK_LT: zOp = "LT"; break;
1542 case TK_LE: zOp = "LE"; break;
1543 case TK_GT: zOp = "GT"; break;
1544 case TK_GE: zOp = "GE"; break;
1545 case TK_NE: zOp = "NE"; break;
1546 case TK_EQ: zOp = "EQ"; break;
1547 case TK_IS: zOp = "IS"; break;
1548 case TK_ISNOT: zOp = "ISNOT"; break;
1549 case TK_AND: zOp = "AND"; break;
1550 case TK_OR: zOp = "OR"; break;
1551 case TK_PLUS: zOp = "ADD"; break;
1552 case TK_STAR: zOp = "MUL"; break;
1553 case TK_MINUS: zOp = "SUB"; break;
1554 case TK_REM: zOp = "REM"; break;
1555 case TK_BITAND: zOp = "BITAND"; break;
1556 case TK_BITOR: zOp = "BITOR"; break;
1557 case TK_SLASH: zOp = "DIV"; break;
1558 case TK_LSHIFT: zOp = "LSHIFT"; break;
1559 case TK_RSHIFT: zOp = "RSHIFT"; break;
1560 case TK_CONCAT: zOp = "CONCAT"; break;
1561 case TK_UMINUS: zOp = "MINUS"; break;
1562 case TK_UPLUS: zOp = "PLUS"; break;
1563 case TK_BITNOT: zOp = "BITNOT"; break;
1564 case TK_NOT: zOp = "NOT"; break;
1565 case TK_ISNULL: zOp = "ISNULL"; break;
1566 case TK_NOTNULL: zOp = "NOTNULL"; break;
1567
1568 default:
1569 sqlite3_str_appendf(p, "%s", "expr");
1570 break;
1571 }
1572
1573 if( zOp ){
1574 sqlite3_str_appendf(p, "%s(", zOp);
1575 displayP4Expr(p, pExpr->pLeft);
1576 if( pExpr->pRight ){
1577 sqlite3_str_append(p, ",", 1);
1578 displayP4Expr(p, pExpr->pRight);
1579 }
1580 sqlite3_str_append(p, ")", 1);
1581 }
1582 }
1583 #endif /* VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) */
1584
1585
1586 #if VDBE_DISPLAY_P4
1587 /*
1588 ** Compute a string that describes the P4 parameter for an opcode.
1589 ** Use zTemp for any required temporary buffer space.
1590 */
displayP4(Op * pOp,char * zTemp,int nTemp)1591 static char *displayP4(Op *pOp, char *zTemp, int nTemp){
1592 char *zP4 = zTemp;
1593 StrAccum x;
1594 assert( nTemp>=20 );
1595 sqlite3StrAccumInit(&x, 0, zTemp, nTemp, 0);
1596 switch( pOp->p4type ){
1597 case P4_KEYINFO: {
1598 int j;
1599 KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
1600 assert( pKeyInfo->aSortFlags!=0 );
1601 sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField);
1602 for(j=0; j<pKeyInfo->nKeyField; j++){
1603 CollSeq *pColl = pKeyInfo->aColl[j];
1604 const char *zColl = pColl ? pColl->zName : "";
1605 if( strcmp(zColl, "BINARY")==0 ) zColl = "B";
1606 sqlite3_str_appendf(&x, ",%s%s%s",
1607 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_DESC) ? "-" : "",
1608 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "",
1609 zColl);
1610 }
1611 sqlite3_str_append(&x, ")", 1);
1612 break;
1613 }
1614 #ifdef SQLITE_ENABLE_CURSOR_HINTS
1615 case P4_EXPR: {
1616 displayP4Expr(&x, pOp->p4.pExpr);
1617 break;
1618 }
1619 #endif
1620 case P4_COLLSEQ: {
1621 CollSeq *pColl = pOp->p4.pColl;
1622 sqlite3_str_appendf(&x, "(%.20s)", pColl->zName);
1623 break;
1624 }
1625 case P4_FUNCDEF: {
1626 FuncDef *pDef = pOp->p4.pFunc;
1627 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
1628 break;
1629 }
1630 case P4_FUNCCTX: {
1631 FuncDef *pDef = pOp->p4.pCtx->pFunc;
1632 sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
1633 break;
1634 }
1635 case P4_INT64: {
1636 sqlite3_str_appendf(&x, "%lld", *pOp->p4.pI64);
1637 break;
1638 }
1639 case P4_INT32: {
1640 sqlite3_str_appendf(&x, "%d", pOp->p4.i);
1641 break;
1642 }
1643 case P4_REAL: {
1644 sqlite3_str_appendf(&x, "%.16g", *pOp->p4.pReal);
1645 break;
1646 }
1647 case P4_MEM: {
1648 Mem *pMem = pOp->p4.pMem;
1649 if( pMem->flags & MEM_Str ){
1650 zP4 = pMem->z;
1651 }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
1652 sqlite3_str_appendf(&x, "%lld", pMem->u.i);
1653 }else if( pMem->flags & MEM_Real ){
1654 sqlite3_str_appendf(&x, "%.16g", pMem->u.r);
1655 }else if( pMem->flags & MEM_Null ){
1656 zP4 = "NULL";
1657 }else{
1658 assert( pMem->flags & MEM_Blob );
1659 zP4 = "(blob)";
1660 }
1661 break;
1662 }
1663 #ifndef SQLITE_OMIT_VIRTUALTABLE
1664 case P4_VTAB: {
1665 sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab;
1666 sqlite3_str_appendf(&x, "vtab:%p", pVtab);
1667 break;
1668 }
1669 #endif
1670 case P4_INTARRAY: {
1671 int i;
1672 int *ai = pOp->p4.ai;
1673 int n = ai[0]; /* The first element of an INTARRAY is always the
1674 ** count of the number of elements to follow */
1675 for(i=1; i<=n; i++){
1676 sqlite3_str_appendf(&x, ",%d", ai[i]);
1677 }
1678 zTemp[0] = '[';
1679 sqlite3_str_append(&x, "]", 1);
1680 break;
1681 }
1682 case P4_SUBPROGRAM: {
1683 sqlite3_str_appendf(&x, "program");
1684 break;
1685 }
1686 case P4_DYNBLOB:
1687 case P4_ADVANCE: {
1688 zTemp[0] = 0;
1689 break;
1690 }
1691 case P4_TABLE: {
1692 sqlite3_str_appendf(&x, "%s", pOp->p4.pTab->zName);
1693 break;
1694 }
1695 default: {
1696 zP4 = pOp->p4.z;
1697 if( zP4==0 ){
1698 zP4 = zTemp;
1699 zTemp[0] = 0;
1700 }
1701 }
1702 }
1703 sqlite3StrAccumFinish(&x);
1704 assert( zP4!=0 );
1705 return zP4;
1706 }
1707 #endif /* VDBE_DISPLAY_P4 */
1708
1709 /*
1710 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
1711 **
1712 ** The prepared statements need to know in advance the complete set of
1713 ** attached databases that will be use. A mask of these databases
1714 ** is maintained in p->btreeMask. The p->lockMask value is the subset of
1715 ** p->btreeMask of databases that will require a lock.
1716 */
sqlite3VdbeUsesBtree(Vdbe * p,int i)1717 void sqlite3VdbeUsesBtree(Vdbe *p, int i){
1718 assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
1719 assert( i<(int)sizeof(p->btreeMask)*8 );
1720 DbMaskSet(p->btreeMask, i);
1721 if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
1722 DbMaskSet(p->lockMask, i);
1723 }
1724 }
1725
1726 #if !defined(SQLITE_OMIT_SHARED_CACHE)
1727 /*
1728 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
1729 ** this routine obtains the mutex associated with each BtShared structure
1730 ** that may be accessed by the VM passed as an argument. In doing so it also
1731 ** sets the BtShared.db member of each of the BtShared structures, ensuring
1732 ** that the correct busy-handler callback is invoked if required.
1733 **
1734 ** If SQLite is not threadsafe but does support shared-cache mode, then
1735 ** sqlite3BtreeEnter() is invoked to set the BtShared.db variables
1736 ** of all of BtShared structures accessible via the database handle
1737 ** associated with the VM.
1738 **
1739 ** If SQLite is not threadsafe and does not support shared-cache mode, this
1740 ** function is a no-op.
1741 **
1742 ** The p->btreeMask field is a bitmask of all btrees that the prepared
1743 ** statement p will ever use. Let N be the number of bits in p->btreeMask
1744 ** corresponding to btrees that use shared cache. Then the runtime of
1745 ** this routine is N*N. But as N is rarely more than 1, this should not
1746 ** be a problem.
1747 */
sqlite3VdbeEnter(Vdbe * p)1748 void sqlite3VdbeEnter(Vdbe *p){
1749 int i;
1750 sqlite3 *db;
1751 Db *aDb;
1752 int nDb;
1753 if( DbMaskAllZero(p->lockMask) ) return; /* The common case */
1754 db = p->db;
1755 aDb = db->aDb;
1756 nDb = db->nDb;
1757 for(i=0; i<nDb; i++){
1758 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
1759 sqlite3BtreeEnter(aDb[i].pBt);
1760 }
1761 }
1762 }
1763 #endif
1764
1765 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
1766 /*
1767 ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter().
1768 */
vdbeLeave(Vdbe * p)1769 static SQLITE_NOINLINE void vdbeLeave(Vdbe *p){
1770 int i;
1771 sqlite3 *db;
1772 Db *aDb;
1773 int nDb;
1774 db = p->db;
1775 aDb = db->aDb;
1776 nDb = db->nDb;
1777 for(i=0; i<nDb; i++){
1778 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
1779 sqlite3BtreeLeave(aDb[i].pBt);
1780 }
1781 }
1782 }
sqlite3VdbeLeave(Vdbe * p)1783 void sqlite3VdbeLeave(Vdbe *p){
1784 if( DbMaskAllZero(p->lockMask) ) return; /* The common case */
1785 vdbeLeave(p);
1786 }
1787 #endif
1788
1789 #if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
1790 /*
1791 ** Print a single opcode. This routine is used for debugging only.
1792 */
sqlite3VdbePrintOp(FILE * pOut,int pc,VdbeOp * pOp)1793 void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){
1794 char *zP4;
1795 char zPtr[50];
1796 char zCom[100];
1797 static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-13s %.2X %s\n";
1798 if( pOut==0 ) pOut = stdout;
1799 zP4 = displayP4(pOp, zPtr, sizeof(zPtr));
1800 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1801 displayComment(pOp, zP4, zCom, sizeof(zCom));
1802 #else
1803 zCom[0] = 0;
1804 #endif
1805 /* NB: The sqlite3OpcodeName() function is implemented by code created
1806 ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the
1807 ** information from the vdbe.c source text */
1808 fprintf(pOut, zFormat1, pc,
1809 sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5,
1810 zCom
1811 );
1812 fflush(pOut);
1813 }
1814 #endif
1815
1816 /*
1817 ** Initialize an array of N Mem element.
1818 */
initMemArray(Mem * p,int N,sqlite3 * db,u16 flags)1819 static void initMemArray(Mem *p, int N, sqlite3 *db, u16 flags){
1820 while( (N--)>0 ){
1821 p->db = db;
1822 p->flags = flags;
1823 p->szMalloc = 0;
1824 #ifdef SQLITE_DEBUG
1825 p->pScopyFrom = 0;
1826 #endif
1827 p++;
1828 }
1829 }
1830
1831 /*
1832 ** Release an array of N Mem elements
1833 */
releaseMemArray(Mem * p,int N)1834 static void releaseMemArray(Mem *p, int N){
1835 if( p && N ){
1836 Mem *pEnd = &p[N];
1837 sqlite3 *db = p->db;
1838 if( db->pnBytesFreed ){
1839 do{
1840 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
1841 }while( (++p)<pEnd );
1842 return;
1843 }
1844 do{
1845 assert( (&p[1])==pEnd || p[0].db==p[1].db );
1846 assert( sqlite3VdbeCheckMemInvariants(p) );
1847
1848 /* This block is really an inlined version of sqlite3VdbeMemRelease()
1849 ** that takes advantage of the fact that the memory cell value is
1850 ** being set to NULL after releasing any dynamic resources.
1851 **
1852 ** The justification for duplicating code is that according to
1853 ** callgrind, this causes a certain test case to hit the CPU 4.7
1854 ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
1855 ** sqlite3MemRelease() were called from here. With -O2, this jumps
1856 ** to 6.6 percent. The test case is inserting 1000 rows into a table
1857 ** with no indexes using a single prepared INSERT statement, bind()
1858 ** and reset(). Inserts are grouped into a transaction.
1859 */
1860 testcase( p->flags & MEM_Agg );
1861 testcase( p->flags & MEM_Dyn );
1862 testcase( p->xDel==sqlite3VdbeFrameMemDel );
1863 if( p->flags&(MEM_Agg|MEM_Dyn) ){
1864 sqlite3VdbeMemRelease(p);
1865 }else if( p->szMalloc ){
1866 sqlite3DbFreeNN(db, p->zMalloc);
1867 p->szMalloc = 0;
1868 }
1869
1870 p->flags = MEM_Undefined;
1871 }while( (++p)<pEnd );
1872 }
1873 }
1874
1875 #ifdef SQLITE_DEBUG
1876 /*
1877 ** Verify that pFrame is a valid VdbeFrame pointer. Return true if it is
1878 ** and false if something is wrong.
1879 **
1880 ** This routine is intended for use inside of assert() statements only.
1881 */
sqlite3VdbeFrameIsValid(VdbeFrame * pFrame)1882 int sqlite3VdbeFrameIsValid(VdbeFrame *pFrame){
1883 if( pFrame->iFrameMagic!=SQLITE_FRAME_MAGIC ) return 0;
1884 return 1;
1885 }
1886 #endif
1887
1888
1889 /*
1890 ** This is a destructor on a Mem object (which is really an sqlite3_value)
1891 ** that deletes the Frame object that is attached to it as a blob.
1892 **
1893 ** This routine does not delete the Frame right away. It merely adds the
1894 ** frame to a list of frames to be deleted when the Vdbe halts.
1895 */
sqlite3VdbeFrameMemDel(void * pArg)1896 void sqlite3VdbeFrameMemDel(void *pArg){
1897 VdbeFrame *pFrame = (VdbeFrame*)pArg;
1898 assert( sqlite3VdbeFrameIsValid(pFrame) );
1899 pFrame->pParent = pFrame->v->pDelFrame;
1900 pFrame->v->pDelFrame = pFrame;
1901 }
1902
1903
1904 /*
1905 ** Delete a VdbeFrame object and its contents. VdbeFrame objects are
1906 ** allocated by the OP_Program opcode in sqlite3VdbeExec().
1907 */
sqlite3VdbeFrameDelete(VdbeFrame * p)1908 void sqlite3VdbeFrameDelete(VdbeFrame *p){
1909 int i;
1910 Mem *aMem = VdbeFrameMem(p);
1911 VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem];
1912 assert( sqlite3VdbeFrameIsValid(p) );
1913 for(i=0; i<p->nChildCsr; i++){
1914 sqlite3VdbeFreeCursor(p->v, apCsr[i]);
1915 }
1916 releaseMemArray(aMem, p->nChildMem);
1917 sqlite3VdbeDeleteAuxData(p->v->db, &p->pAuxData, -1, 0);
1918 sqlite3DbFree(p->v->db, p);
1919 }
1920
1921 #ifndef SQLITE_OMIT_EXPLAIN
1922 /*
1923 ** Give a listing of the program in the virtual machine.
1924 **
1925 ** The interface is the same as sqlite3VdbeExec(). But instead of
1926 ** running the code, it invokes the callback once for each instruction.
1927 ** This feature is used to implement "EXPLAIN".
1928 **
1929 ** When p->explain==1, each instruction is listed. When
1930 ** p->explain==2, only OP_Explain instructions are listed and these
1931 ** are shown in a different format. p->explain==2 is used to implement
1932 ** EXPLAIN QUERY PLAN.
1933 ** 2018-04-24: In p->explain==2 mode, the OP_Init opcodes of triggers
1934 ** are also shown, so that the boundaries between the main program and
1935 ** each trigger are clear.
1936 **
1937 ** When p->explain==1, first the main program is listed, then each of
1938 ** the trigger subprograms are listed one by one.
1939 */
sqlite3VdbeList(Vdbe * p)1940 int sqlite3VdbeList(
1941 Vdbe *p /* The VDBE */
1942 ){
1943 int nRow; /* Stop when row count reaches this */
1944 int nSub = 0; /* Number of sub-vdbes seen so far */
1945 SubProgram **apSub = 0; /* Array of sub-vdbes */
1946 Mem *pSub = 0; /* Memory cell hold array of subprogs */
1947 sqlite3 *db = p->db; /* The database connection */
1948 int i; /* Loop counter */
1949 int rc = SQLITE_OK; /* Return code */
1950 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
1951 int bListSubprogs = (p->explain==1 || (db->flags & SQLITE_TriggerEQP)!=0);
1952 Op *pOp = 0;
1953
1954 assert( p->explain );
1955 assert( p->magic==VDBE_MAGIC_RUN );
1956 assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
1957
1958 /* Even though this opcode does not use dynamic strings for
1959 ** the result, result columns may become dynamic if the user calls
1960 ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
1961 */
1962 releaseMemArray(pMem, 8);
1963 p->pResultSet = 0;
1964
1965 if( p->rc==SQLITE_NOMEM ){
1966 /* This happens if a malloc() inside a call to sqlite3_column_text() or
1967 ** sqlite3_column_text16() failed. */
1968 sqlite3OomFault(db);
1969 return SQLITE_ERROR;
1970 }
1971
1972 /* When the number of output rows reaches nRow, that means the
1973 ** listing has finished and sqlite3_step() should return SQLITE_DONE.
1974 ** nRow is the sum of the number of rows in the main program, plus
1975 ** the sum of the number of rows in all trigger subprograms encountered
1976 ** so far. The nRow value will increase as new trigger subprograms are
1977 ** encountered, but p->pc will eventually catch up to nRow.
1978 */
1979 nRow = p->nOp;
1980 if( bListSubprogs ){
1981 /* The first 8 memory cells are used for the result set. So we will
1982 ** commandeer the 9th cell to use as storage for an array of pointers
1983 ** to trigger subprograms. The VDBE is guaranteed to have at least 9
1984 ** cells. */
1985 assert( p->nMem>9 );
1986 pSub = &p->aMem[9];
1987 if( pSub->flags&MEM_Blob ){
1988 /* On the first call to sqlite3_step(), pSub will hold a NULL. It is
1989 ** initialized to a BLOB by the P4_SUBPROGRAM processing logic below */
1990 nSub = pSub->n/sizeof(Vdbe*);
1991 apSub = (SubProgram **)pSub->z;
1992 }
1993 for(i=0; i<nSub; i++){
1994 nRow += apSub[i]->nOp;
1995 }
1996 }
1997
1998 while(1){ /* Loop exits via break */
1999 i = p->pc++;
2000 if( i>=nRow ){
2001 p->rc = SQLITE_OK;
2002 rc = SQLITE_DONE;
2003 break;
2004 }
2005 if( i<p->nOp ){
2006 /* The output line number is small enough that we are still in the
2007 ** main program. */
2008 pOp = &p->aOp[i];
2009 }else{
2010 /* We are currently listing subprograms. Figure out which one and
2011 ** pick up the appropriate opcode. */
2012 int j;
2013 i -= p->nOp;
2014 assert( apSub!=0 );
2015 assert( nSub>0 );
2016 for(j=0; i>=apSub[j]->nOp; j++){
2017 i -= apSub[j]->nOp;
2018 assert( i<apSub[j]->nOp || j+1<nSub );
2019 }
2020 pOp = &apSub[j]->aOp[i];
2021 }
2022
2023 /* When an OP_Program opcode is encounter (the only opcode that has
2024 ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms
2025 ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
2026 ** has not already been seen.
2027 */
2028 if( bListSubprogs && pOp->p4type==P4_SUBPROGRAM ){
2029 int nByte = (nSub+1)*sizeof(SubProgram*);
2030 int j;
2031 for(j=0; j<nSub; j++){
2032 if( apSub[j]==pOp->p4.pProgram ) break;
2033 }
2034 if( j==nSub ){
2035 p->rc = sqlite3VdbeMemGrow(pSub, nByte, nSub!=0);
2036 if( p->rc!=SQLITE_OK ){
2037 rc = SQLITE_ERROR;
2038 break;
2039 }
2040 apSub = (SubProgram **)pSub->z;
2041 apSub[nSub++] = pOp->p4.pProgram;
2042 pSub->flags |= MEM_Blob;
2043 pSub->n = nSub*sizeof(SubProgram*);
2044 nRow += pOp->p4.pProgram->nOp;
2045 }
2046 }
2047 if( p->explain<2 ) break;
2048 if( pOp->opcode==OP_Explain ) break;
2049 if( pOp->opcode==OP_Init && p->pc>1 ) break;
2050 }
2051
2052 if( rc==SQLITE_OK ){
2053 if( db->u1.isInterrupted ){
2054 p->rc = SQLITE_INTERRUPT;
2055 rc = SQLITE_ERROR;
2056 sqlite3VdbeError(p, sqlite3ErrStr(p->rc));
2057 }else{
2058 char *zP4;
2059 if( p->explain==1 ){
2060 pMem->flags = MEM_Int;
2061 pMem->u.i = i; /* Program counter */
2062 pMem++;
2063
2064 pMem->flags = MEM_Static|MEM_Str|MEM_Term;
2065 pMem->z = (char*)sqlite3OpcodeName(pOp->opcode); /* Opcode */
2066 assert( pMem->z!=0 );
2067 pMem->n = sqlite3Strlen30(pMem->z);
2068 pMem->enc = SQLITE_UTF8;
2069 pMem++;
2070 }
2071
2072 pMem->flags = MEM_Int;
2073 pMem->u.i = pOp->p1; /* P1 */
2074 pMem++;
2075
2076 pMem->flags = MEM_Int;
2077 pMem->u.i = pOp->p2; /* P2 */
2078 pMem++;
2079
2080 pMem->flags = MEM_Int;
2081 pMem->u.i = pOp->p3; /* P3 */
2082 pMem++;
2083
2084 if( sqlite3VdbeMemClearAndResize(pMem, 100) ){ /* P4 */
2085 assert( p->db->mallocFailed );
2086 return SQLITE_ERROR;
2087 }
2088 pMem->flags = MEM_Str|MEM_Term;
2089 zP4 = displayP4(pOp, pMem->z, pMem->szMalloc);
2090 if( zP4!=pMem->z ){
2091 pMem->n = 0;
2092 sqlite3VdbeMemSetStr(pMem, zP4, -1, SQLITE_UTF8, 0);
2093 }else{
2094 assert( pMem->z!=0 );
2095 pMem->n = sqlite3Strlen30(pMem->z);
2096 pMem->enc = SQLITE_UTF8;
2097 }
2098 pMem++;
2099
2100 if( p->explain==1 ){
2101 if( sqlite3VdbeMemClearAndResize(pMem, 4) ){
2102 assert( p->db->mallocFailed );
2103 return SQLITE_ERROR;
2104 }
2105 pMem->flags = MEM_Str|MEM_Term;
2106 pMem->n = 2;
2107 sqlite3_snprintf(3, pMem->z, "%.2x", pOp->p5); /* P5 */
2108 pMem->enc = SQLITE_UTF8;
2109 pMem++;
2110
2111 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
2112 if( sqlite3VdbeMemClearAndResize(pMem, 500) ){
2113 assert( p->db->mallocFailed );
2114 return SQLITE_ERROR;
2115 }
2116 pMem->flags = MEM_Str|MEM_Term;
2117 pMem->n = displayComment(pOp, zP4, pMem->z, 500);
2118 pMem->enc = SQLITE_UTF8;
2119 #else
2120 pMem->flags = MEM_Null; /* Comment */
2121 #endif
2122 }
2123
2124 p->nResColumn = 8 - 4*(p->explain-1);
2125 p->pResultSet = &p->aMem[1];
2126 p->rc = SQLITE_OK;
2127 rc = SQLITE_ROW;
2128 }
2129 }
2130 return rc;
2131 }
2132 #endif /* SQLITE_OMIT_EXPLAIN */
2133
2134 #ifdef SQLITE_DEBUG
2135 /*
2136 ** Print the SQL that was used to generate a VDBE program.
2137 */
sqlite3VdbePrintSql(Vdbe * p)2138 void sqlite3VdbePrintSql(Vdbe *p){
2139 const char *z = 0;
2140 if( p->zSql ){
2141 z = p->zSql;
2142 }else if( p->nOp>=1 ){
2143 const VdbeOp *pOp = &p->aOp[0];
2144 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
2145 z = pOp->p4.z;
2146 while( sqlite3Isspace(*z) ) z++;
2147 }
2148 }
2149 if( z ) printf("SQL: [%s]\n", z);
2150 }
2151 #endif
2152
2153 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
2154 /*
2155 ** Print an IOTRACE message showing SQL content.
2156 */
sqlite3VdbeIOTraceSql(Vdbe * p)2157 void sqlite3VdbeIOTraceSql(Vdbe *p){
2158 int nOp = p->nOp;
2159 VdbeOp *pOp;
2160 if( sqlite3IoTrace==0 ) return;
2161 if( nOp<1 ) return;
2162 pOp = &p->aOp[0];
2163 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
2164 int i, j;
2165 char z[1000];
2166 sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
2167 for(i=0; sqlite3Isspace(z[i]); i++){}
2168 for(j=0; z[i]; i++){
2169 if( sqlite3Isspace(z[i]) ){
2170 if( z[i-1]!=' ' ){
2171 z[j++] = ' ';
2172 }
2173 }else{
2174 z[j++] = z[i];
2175 }
2176 }
2177 z[j] = 0;
2178 sqlite3IoTrace("SQL %s\n", z);
2179 }
2180 }
2181 #endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */
2182
2183 /* An instance of this object describes bulk memory available for use
2184 ** by subcomponents of a prepared statement. Space is allocated out
2185 ** of a ReusableSpace object by the allocSpace() routine below.
2186 */
2187 struct ReusableSpace {
2188 u8 *pSpace; /* Available memory */
2189 sqlite3_int64 nFree; /* Bytes of available memory */
2190 sqlite3_int64 nNeeded; /* Total bytes that could not be allocated */
2191 };
2192
2193 /* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf
2194 ** from the ReusableSpace object. Return a pointer to the allocated
2195 ** memory on success. If insufficient memory is available in the
2196 ** ReusableSpace object, increase the ReusableSpace.nNeeded
2197 ** value by the amount needed and return NULL.
2198 **
2199 ** If pBuf is not initially NULL, that means that the memory has already
2200 ** been allocated by a prior call to this routine, so just return a copy
2201 ** of pBuf and leave ReusableSpace unchanged.
2202 **
2203 ** This allocator is employed to repurpose unused slots at the end of the
2204 ** opcode array of prepared state for other memory needs of the prepared
2205 ** statement.
2206 */
allocSpace(struct ReusableSpace * p,void * pBuf,sqlite3_int64 nByte)2207 static void *allocSpace(
2208 struct ReusableSpace *p, /* Bulk memory available for allocation */
2209 void *pBuf, /* Pointer to a prior allocation */
2210 sqlite3_int64 nByte /* Bytes of memory needed */
2211 ){
2212 assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) );
2213 if( pBuf==0 ){
2214 nByte = ROUND8(nByte);
2215 if( nByte <= p->nFree ){
2216 p->nFree -= nByte;
2217 pBuf = &p->pSpace[p->nFree];
2218 }else{
2219 p->nNeeded += nByte;
2220 }
2221 }
2222 assert( EIGHT_BYTE_ALIGNMENT(pBuf) );
2223 return pBuf;
2224 }
2225
2226 /*
2227 ** Rewind the VDBE back to the beginning in preparation for
2228 ** running it.
2229 */
sqlite3VdbeRewind(Vdbe * p)2230 void sqlite3VdbeRewind(Vdbe *p){
2231 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
2232 int i;
2233 #endif
2234 assert( p!=0 );
2235 assert( p->magic==VDBE_MAGIC_INIT || p->magic==VDBE_MAGIC_RESET );
2236
2237 /* There should be at least one opcode.
2238 */
2239 assert( p->nOp>0 );
2240
2241 /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */
2242 p->magic = VDBE_MAGIC_RUN;
2243
2244 #ifdef SQLITE_DEBUG
2245 for(i=0; i<p->nMem; i++){
2246 assert( p->aMem[i].db==p->db );
2247 }
2248 #endif
2249 p->pc = -1;
2250 p->rc = SQLITE_OK;
2251 p->errorAction = OE_Abort;
2252 p->nChange = 0;
2253 p->cacheCtr = 1;
2254 p->minWriteFileFormat = 255;
2255 p->iStatement = 0;
2256 p->nFkConstraint = 0;
2257 #ifdef VDBE_PROFILE
2258 for(i=0; i<p->nOp; i++){
2259 p->aOp[i].cnt = 0;
2260 p->aOp[i].cycles = 0;
2261 }
2262 #endif
2263 }
2264
2265 /*
2266 ** Prepare a virtual machine for execution for the first time after
2267 ** creating the virtual machine. This involves things such
2268 ** as allocating registers and initializing the program counter.
2269 ** After the VDBE has be prepped, it can be executed by one or more
2270 ** calls to sqlite3VdbeExec().
2271 **
2272 ** This function may be called exactly once on each virtual machine.
2273 ** After this routine is called the VM has been "packaged" and is ready
2274 ** to run. After this routine is called, further calls to
2275 ** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects
2276 ** the Vdbe from the Parse object that helped generate it so that the
2277 ** the Vdbe becomes an independent entity and the Parse object can be
2278 ** destroyed.
2279 **
2280 ** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back
2281 ** to its initial state after it has been run.
2282 */
sqlite3VdbeMakeReady(Vdbe * p,Parse * pParse)2283 void sqlite3VdbeMakeReady(
2284 Vdbe *p, /* The VDBE */
2285 Parse *pParse /* Parsing context */
2286 ){
2287 sqlite3 *db; /* The database connection */
2288 int nVar; /* Number of parameters */
2289 int nMem; /* Number of VM memory registers */
2290 int nCursor; /* Number of cursors required */
2291 int nArg; /* Number of arguments in subprograms */
2292 int n; /* Loop counter */
2293 struct ReusableSpace x; /* Reusable bulk memory */
2294
2295 assert( p!=0 );
2296 assert( p->nOp>0 );
2297 assert( pParse!=0 );
2298 assert( p->magic==VDBE_MAGIC_INIT );
2299 assert( pParse==p->pParse );
2300 db = p->db;
2301 assert( db->mallocFailed==0 );
2302 nVar = pParse->nVar;
2303 nMem = pParse->nMem;
2304 nCursor = pParse->nTab;
2305 nArg = pParse->nMaxArg;
2306
2307 /* Each cursor uses a memory cell. The first cursor (cursor 0) can
2308 ** use aMem[0] which is not otherwise used by the VDBE program. Allocate
2309 ** space at the end of aMem[] for cursors 1 and greater.
2310 ** See also: allocateCursor().
2311 */
2312 nMem += nCursor;
2313 if( nCursor==0 && nMem>0 ) nMem++; /* Space for aMem[0] even if not used */
2314
2315 /* Figure out how much reusable memory is available at the end of the
2316 ** opcode array. This extra memory will be reallocated for other elements
2317 ** of the prepared statement.
2318 */
2319 n = ROUND8(sizeof(Op)*p->nOp); /* Bytes of opcode memory used */
2320 x.pSpace = &((u8*)p->aOp)[n]; /* Unused opcode memory */
2321 assert( EIGHT_BYTE_ALIGNMENT(x.pSpace) );
2322 x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n); /* Bytes of unused memory */
2323 assert( x.nFree>=0 );
2324 assert( EIGHT_BYTE_ALIGNMENT(&x.pSpace[x.nFree]) );
2325
2326 resolveP2Values(p, &nArg);
2327 p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
2328 if( pParse->explain ){
2329 static const char * const azColName[] = {
2330 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
2331 "id", "parent", "notused", "detail"
2332 };
2333 int iFirst, mx, i;
2334 if( nMem<10 ) nMem = 10;
2335 if( pParse->explain==2 ){
2336 sqlite3VdbeSetNumCols(p, 4);
2337 iFirst = 8;
2338 mx = 12;
2339 }else{
2340 sqlite3VdbeSetNumCols(p, 8);
2341 iFirst = 0;
2342 mx = 8;
2343 }
2344 for(i=iFirst; i<mx; i++){
2345 sqlite3VdbeSetColName(p, i-iFirst, COLNAME_NAME,
2346 azColName[i], SQLITE_STATIC);
2347 }
2348 }
2349 p->expired = 0;
2350
2351 /* Memory for registers, parameters, cursor, etc, is allocated in one or two
2352 ** passes. On the first pass, we try to reuse unused memory at the
2353 ** end of the opcode array. If we are unable to satisfy all memory
2354 ** requirements by reusing the opcode array tail, then the second
2355 ** pass will fill in the remainder using a fresh memory allocation.
2356 **
2357 ** This two-pass approach that reuses as much memory as possible from
2358 ** the leftover memory at the end of the opcode array. This can significantly
2359 ** reduce the amount of memory held by a prepared statement.
2360 */
2361 x.nNeeded = 0;
2362 p->aMem = allocSpace(&x, 0, nMem*sizeof(Mem));
2363 p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem));
2364 p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*));
2365 p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*));
2366 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
2367 p->anExec = allocSpace(&x, 0, p->nOp*sizeof(i64));
2368 #endif
2369 if( x.nNeeded ){
2370 x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded);
2371 x.nFree = x.nNeeded;
2372 if( !db->mallocFailed ){
2373 p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem));
2374 p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem));
2375 p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*));
2376 p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*));
2377 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
2378 p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64));
2379 #endif
2380 }
2381 }
2382
2383 p->pVList = pParse->pVList;
2384 pParse->pVList = 0;
2385 p->explain = pParse->explain;
2386 if( db->mallocFailed ){
2387 p->nVar = 0;
2388 p->nCursor = 0;
2389 p->nMem = 0;
2390 }else{
2391 p->nCursor = nCursor;
2392 p->nVar = (ynVar)nVar;
2393 initMemArray(p->aVar, nVar, db, MEM_Null);
2394 p->nMem = nMem;
2395 initMemArray(p->aMem, nMem, db, MEM_Undefined);
2396 memset(p->apCsr, 0, nCursor*sizeof(VdbeCursor*));
2397 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
2398 memset(p->anExec, 0, p->nOp*sizeof(i64));
2399 #endif
2400 }
2401 sqlite3VdbeRewind(p);
2402 }
2403
2404 /*
2405 ** Close a VDBE cursor and release all the resources that cursor
2406 ** happens to hold.
2407 */
sqlite3VdbeFreeCursor(Vdbe * p,VdbeCursor * pCx)2408 void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
2409 if( pCx==0 ){
2410 return;
2411 }
2412 assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE );
2413 switch( pCx->eCurType ){
2414 case CURTYPE_SORTER: {
2415 sqlite3VdbeSorterClose(p->db, pCx);
2416 break;
2417 }
2418 case CURTYPE_BTREE: {
2419 if( pCx->isEphemeral ){
2420 if( pCx->pBtx ) sqlite3BtreeClose(pCx->pBtx);
2421 /* The pCx->pCursor will be close automatically, if it exists, by
2422 ** the call above. */
2423 }else{
2424 assert( pCx->uc.pCursor!=0 );
2425 sqlite3BtreeCloseCursor(pCx->uc.pCursor);
2426 }
2427 break;
2428 }
2429 #ifndef SQLITE_OMIT_VIRTUALTABLE
2430 case CURTYPE_VTAB: {
2431 sqlite3_vtab_cursor *pVCur = pCx->uc.pVCur;
2432 const sqlite3_module *pModule = pVCur->pVtab->pModule;
2433 assert( pVCur->pVtab->nRef>0 );
2434 pVCur->pVtab->nRef--;
2435 pModule->xClose(pVCur);
2436 break;
2437 }
2438 #endif
2439 }
2440 }
2441
2442 /*
2443 ** Close all cursors in the current frame.
2444 */
closeCursorsInFrame(Vdbe * p)2445 static void closeCursorsInFrame(Vdbe *p){
2446 if( p->apCsr ){
2447 int i;
2448 for(i=0; i<p->nCursor; i++){
2449 VdbeCursor *pC = p->apCsr[i];
2450 if( pC ){
2451 sqlite3VdbeFreeCursor(p, pC);
2452 p->apCsr[i] = 0;
2453 }
2454 }
2455 }
2456 }
2457
2458 /*
2459 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
2460 ** is used, for example, when a trigger sub-program is halted to restore
2461 ** control to the main program.
2462 */
sqlite3VdbeFrameRestore(VdbeFrame * pFrame)2463 int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){
2464 Vdbe *v = pFrame->v;
2465 closeCursorsInFrame(v);
2466 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
2467 v->anExec = pFrame->anExec;
2468 #endif
2469 v->aOp = pFrame->aOp;
2470 v->nOp = pFrame->nOp;
2471 v->aMem = pFrame->aMem;
2472 v->nMem = pFrame->nMem;
2473 v->apCsr = pFrame->apCsr;
2474 v->nCursor = pFrame->nCursor;
2475 v->db->lastRowid = pFrame->lastRowid;
2476 v->nChange = pFrame->nChange;
2477 v->db->nChange = pFrame->nDbChange;
2478 sqlite3VdbeDeleteAuxData(v->db, &v->pAuxData, -1, 0);
2479 v->pAuxData = pFrame->pAuxData;
2480 pFrame->pAuxData = 0;
2481 return pFrame->pc;
2482 }
2483
2484 /*
2485 ** Close all cursors.
2486 **
2487 ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory
2488 ** cell array. This is necessary as the memory cell array may contain
2489 ** pointers to VdbeFrame objects, which may in turn contain pointers to
2490 ** open cursors.
2491 */
closeAllCursors(Vdbe * p)2492 static void closeAllCursors(Vdbe *p){
2493 if( p->pFrame ){
2494 VdbeFrame *pFrame;
2495 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
2496 sqlite3VdbeFrameRestore(pFrame);
2497 p->pFrame = 0;
2498 p->nFrame = 0;
2499 }
2500 assert( p->nFrame==0 );
2501 closeCursorsInFrame(p);
2502 if( p->aMem ){
2503 releaseMemArray(p->aMem, p->nMem);
2504 }
2505 while( p->pDelFrame ){
2506 VdbeFrame *pDel = p->pDelFrame;
2507 p->pDelFrame = pDel->pParent;
2508 sqlite3VdbeFrameDelete(pDel);
2509 }
2510
2511 /* Delete any auxdata allocations made by the VM */
2512 if( p->pAuxData ) sqlite3VdbeDeleteAuxData(p->db, &p->pAuxData, -1, 0);
2513 assert( p->pAuxData==0 );
2514 }
2515
2516 /*
2517 ** Set the number of result columns that will be returned by this SQL
2518 ** statement. This is now set at compile time, rather than during
2519 ** execution of the vdbe program so that sqlite3_column_count() can
2520 ** be called on an SQL statement before sqlite3_step().
2521 */
sqlite3VdbeSetNumCols(Vdbe * p,int nResColumn)2522 void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
2523 int n;
2524 sqlite3 *db = p->db;
2525
2526 if( p->nResColumn ){
2527 releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
2528 sqlite3DbFree(db, p->aColName);
2529 }
2530 n = nResColumn*COLNAME_N;
2531 p->nResColumn = (u16)nResColumn;
2532 p->aColName = (Mem*)sqlite3DbMallocRawNN(db, sizeof(Mem)*n );
2533 if( p->aColName==0 ) return;
2534 initMemArray(p->aColName, n, db, MEM_Null);
2535 }
2536
2537 /*
2538 ** Set the name of the idx'th column to be returned by the SQL statement.
2539 ** zName must be a pointer to a nul terminated string.
2540 **
2541 ** This call must be made after a call to sqlite3VdbeSetNumCols().
2542 **
2543 ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
2544 ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
2545 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
2546 */
sqlite3VdbeSetColName(Vdbe * p,int idx,int var,const char * zName,void (* xDel)(void *))2547 int sqlite3VdbeSetColName(
2548 Vdbe *p, /* Vdbe being configured */
2549 int idx, /* Index of column zName applies to */
2550 int var, /* One of the COLNAME_* constants */
2551 const char *zName, /* Pointer to buffer containing name */
2552 void (*xDel)(void*) /* Memory management strategy for zName */
2553 ){
2554 int rc;
2555 Mem *pColName;
2556 assert( idx<p->nResColumn );
2557 assert( var<COLNAME_N );
2558 if( p->db->mallocFailed ){
2559 assert( !zName || xDel!=SQLITE_DYNAMIC );
2560 return SQLITE_NOMEM_BKPT;
2561 }
2562 assert( p->aColName!=0 );
2563 pColName = &(p->aColName[idx+var*p->nResColumn]);
2564 rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
2565 assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
2566 return rc;
2567 }
2568
2569 /*
2570 ** A read or write transaction may or may not be active on database handle
2571 ** db. If a transaction is active, commit it. If there is a
2572 ** write-transaction spanning more than one database file, this routine
2573 ** takes care of the master journal trickery.
2574 */
vdbeCommit(sqlite3 * db,Vdbe * p)2575 static int vdbeCommit(sqlite3 *db, Vdbe *p){
2576 int i;
2577 int nTrans = 0; /* Number of databases with an active write-transaction
2578 ** that are candidates for a two-phase commit using a
2579 ** master-journal */
2580 int rc = SQLITE_OK;
2581 int needXcommit = 0;
2582
2583 #ifdef SQLITE_OMIT_VIRTUALTABLE
2584 /* With this option, sqlite3VtabSync() is defined to be simply
2585 ** SQLITE_OK so p is not used.
2586 */
2587 UNUSED_PARAMETER(p);
2588 #endif
2589
2590 /* Before doing anything else, call the xSync() callback for any
2591 ** virtual module tables written in this transaction. This has to
2592 ** be done before determining whether a master journal file is
2593 ** required, as an xSync() callback may add an attached database
2594 ** to the transaction.
2595 */
2596 rc = sqlite3VtabSync(db, p);
2597
2598 /* This loop determines (a) if the commit hook should be invoked and
2599 ** (b) how many database files have open write transactions, not
2600 ** including the temp database. (b) is important because if more than
2601 ** one database file has an open write transaction, a master journal
2602 ** file is required for an atomic commit.
2603 */
2604 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
2605 Btree *pBt = db->aDb[i].pBt;
2606 if( sqlite3BtreeIsInTrans(pBt) ){
2607 /* Whether or not a database might need a master journal depends upon
2608 ** its journal mode (among other things). This matrix determines which
2609 ** journal modes use a master journal and which do not */
2610 static const u8 aMJNeeded[] = {
2611 /* DELETE */ 1,
2612 /* PERSIST */ 1,
2613 /* OFF */ 0,
2614 /* TRUNCATE */ 1,
2615 /* MEMORY */ 0,
2616 /* WAL */ 0
2617 };
2618 Pager *pPager; /* Pager associated with pBt */
2619 needXcommit = 1;
2620 sqlite3BtreeEnter(pBt);
2621 pPager = sqlite3BtreePager(pBt);
2622 if( db->aDb[i].safety_level!=PAGER_SYNCHRONOUS_OFF
2623 && aMJNeeded[sqlite3PagerGetJournalMode(pPager)]
2624 && sqlite3PagerIsMemdb(pPager)==0
2625 ){
2626 assert( i!=1 );
2627 nTrans++;
2628 }
2629 rc = sqlite3PagerExclusiveLock(pPager);
2630 sqlite3BtreeLeave(pBt);
2631 }
2632 }
2633 if( rc!=SQLITE_OK ){
2634 return rc;
2635 }
2636
2637 /* If there are any write-transactions at all, invoke the commit hook */
2638 if( needXcommit && db->xCommitCallback ){
2639 rc = db->xCommitCallback(db->pCommitArg);
2640 if( rc ){
2641 return SQLITE_CONSTRAINT_COMMITHOOK;
2642 }
2643 }
2644
2645 /* The simple case - no more than one database file (not counting the
2646 ** TEMP database) has a transaction active. There is no need for the
2647 ** master-journal.
2648 **
2649 ** If the return value of sqlite3BtreeGetFilename() is a zero length
2650 ** string, it means the main database is :memory: or a temp file. In
2651 ** that case we do not support atomic multi-file commits, so use the
2652 ** simple case then too.
2653 */
2654 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
2655 || nTrans<=1
2656 ){
2657 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
2658 Btree *pBt = db->aDb[i].pBt;
2659 if( pBt ){
2660 rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
2661 }
2662 }
2663
2664 /* Do the commit only if all databases successfully complete phase 1.
2665 ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
2666 ** IO error while deleting or truncating a journal file. It is unlikely,
2667 ** but could happen. In this case abandon processing and return the error.
2668 */
2669 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
2670 Btree *pBt = db->aDb[i].pBt;
2671 if( pBt ){
2672 rc = sqlite3BtreeCommitPhaseTwo(pBt, 0);
2673 }
2674 }
2675 if( rc==SQLITE_OK ){
2676 sqlite3VtabCommit(db);
2677 }
2678 }
2679
2680 /* The complex case - There is a multi-file write-transaction active.
2681 ** This requires a master journal file to ensure the transaction is
2682 ** committed atomically.
2683 */
2684 #ifndef SQLITE_OMIT_DISKIO
2685 else{
2686 sqlite3_vfs *pVfs = db->pVfs;
2687 char *zMaster = 0; /* File-name for the master journal */
2688 char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
2689 sqlite3_file *pMaster = 0;
2690 i64 offset = 0;
2691 int res;
2692 int retryCount = 0;
2693 int nMainFile;
2694
2695 /* Select a master journal file name */
2696 nMainFile = sqlite3Strlen30(zMainFile);
2697 zMaster = sqlite3MPrintf(db, "%s-mjXXXXXX9XXz%c%c", zMainFile, 0, 0);
2698 if( zMaster==0 ) return SQLITE_NOMEM_BKPT;
2699 do {
2700 u32 iRandom;
2701 if( retryCount ){
2702 if( retryCount>100 ){
2703 sqlite3_log(SQLITE_FULL, "MJ delete: %s", zMaster);
2704 sqlite3OsDelete(pVfs, zMaster, 0);
2705 break;
2706 }else if( retryCount==1 ){
2707 sqlite3_log(SQLITE_FULL, "MJ collide: %s", zMaster);
2708 }
2709 }
2710 retryCount++;
2711 sqlite3_randomness(sizeof(iRandom), &iRandom);
2712 sqlite3_snprintf(13, &zMaster[nMainFile], "-mj%06X9%02X",
2713 (iRandom>>8)&0xffffff, iRandom&0xff);
2714 /* The antipenultimate character of the master journal name must
2715 ** be "9" to avoid name collisions when using 8+3 filenames. */
2716 assert( zMaster[sqlite3Strlen30(zMaster)-3]=='9' );
2717 sqlite3FileSuffix3(zMainFile, zMaster);
2718 rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res);
2719 }while( rc==SQLITE_OK && res );
2720 if( rc==SQLITE_OK ){
2721 /* Open the master journal. */
2722 rc = sqlite3OsOpenMalloc(pVfs, zMaster, &pMaster,
2723 SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
2724 SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_MASTER_JOURNAL, 0
2725 );
2726 }
2727 if( rc!=SQLITE_OK ){
2728 sqlite3DbFree(db, zMaster);
2729 return rc;
2730 }
2731
2732 /* Write the name of each database file in the transaction into the new
2733 ** master journal file. If an error occurs at this point close
2734 ** and delete the master journal file. All the individual journal files
2735 ** still have 'null' as the master journal pointer, so they will roll
2736 ** back independently if a failure occurs.
2737 */
2738 for(i=0; i<db->nDb; i++){
2739 Btree *pBt = db->aDb[i].pBt;
2740 if( sqlite3BtreeIsInTrans(pBt) ){
2741 char const *zFile = sqlite3BtreeGetJournalname(pBt);
2742 if( zFile==0 ){
2743 continue; /* Ignore TEMP and :memory: databases */
2744 }
2745 assert( zFile[0]!=0 );
2746 rc = sqlite3OsWrite(pMaster, zFile, sqlite3Strlen30(zFile)+1, offset);
2747 offset += sqlite3Strlen30(zFile)+1;
2748 if( rc!=SQLITE_OK ){
2749 sqlite3OsCloseFree(pMaster);
2750 sqlite3OsDelete(pVfs, zMaster, 0);
2751 sqlite3DbFree(db, zMaster);
2752 return rc;
2753 }
2754 }
2755 }
2756
2757 /* Sync the master journal file. If the IOCAP_SEQUENTIAL device
2758 ** flag is set this is not required.
2759 */
2760 if( 0==(sqlite3OsDeviceCharacteristics(pMaster)&SQLITE_IOCAP_SEQUENTIAL)
2761 && SQLITE_OK!=(rc = sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL))
2762 ){
2763 sqlite3OsCloseFree(pMaster);
2764 sqlite3OsDelete(pVfs, zMaster, 0);
2765 sqlite3DbFree(db, zMaster);
2766 return rc;
2767 }
2768
2769 /* Sync all the db files involved in the transaction. The same call
2770 ** sets the master journal pointer in each individual journal. If
2771 ** an error occurs here, do not delete the master journal file.
2772 **
2773 ** If the error occurs during the first call to
2774 ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
2775 ** master journal file will be orphaned. But we cannot delete it,
2776 ** in case the master journal file name was written into the journal
2777 ** file before the failure occurred.
2778 */
2779 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
2780 Btree *pBt = db->aDb[i].pBt;
2781 if( pBt ){
2782 rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster);
2783 }
2784 }
2785 sqlite3OsCloseFree(pMaster);
2786 assert( rc!=SQLITE_BUSY );
2787 if( rc!=SQLITE_OK ){
2788 sqlite3DbFree(db, zMaster);
2789 return rc;
2790 }
2791
2792 /* Delete the master journal file. This commits the transaction. After
2793 ** doing this the directory is synced again before any individual
2794 ** transaction files are deleted.
2795 */
2796 rc = sqlite3OsDelete(pVfs, zMaster, 1);
2797 sqlite3DbFree(db, zMaster);
2798 zMaster = 0;
2799 if( rc ){
2800 return rc;
2801 }
2802
2803 /* All files and directories have already been synced, so the following
2804 ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
2805 ** deleting or truncating journals. If something goes wrong while
2806 ** this is happening we don't really care. The integrity of the
2807 ** transaction is already guaranteed, but some stray 'cold' journals
2808 ** may be lying around. Returning an error code won't help matters.
2809 */
2810 disable_simulated_io_errors();
2811 sqlite3BeginBenignMalloc();
2812 for(i=0; i<db->nDb; i++){
2813 Btree *pBt = db->aDb[i].pBt;
2814 if( pBt ){
2815 sqlite3BtreeCommitPhaseTwo(pBt, 1);
2816 }
2817 }
2818 sqlite3EndBenignMalloc();
2819 enable_simulated_io_errors();
2820
2821 sqlite3VtabCommit(db);
2822 }
2823 #endif
2824
2825 return rc;
2826 }
2827
2828 /*
2829 ** This routine checks that the sqlite3.nVdbeActive count variable
2830 ** matches the number of vdbe's in the list sqlite3.pVdbe that are
2831 ** currently active. An assertion fails if the two counts do not match.
2832 ** This is an internal self-check only - it is not an essential processing
2833 ** step.
2834 **
2835 ** This is a no-op if NDEBUG is defined.
2836 */
2837 #ifndef NDEBUG
checkActiveVdbeCnt(sqlite3 * db)2838 static void checkActiveVdbeCnt(sqlite3 *db){
2839 Vdbe *p;
2840 int cnt = 0;
2841 int nWrite = 0;
2842 int nRead = 0;
2843 p = db->pVdbe;
2844 while( p ){
2845 if( sqlite3_stmt_busy((sqlite3_stmt*)p) ){
2846 cnt++;
2847 if( p->readOnly==0 ) nWrite++;
2848 if( p->bIsReader ) nRead++;
2849 }
2850 p = p->pNext;
2851 }
2852 assert( cnt==db->nVdbeActive );
2853 assert( nWrite==db->nVdbeWrite );
2854 assert( nRead==db->nVdbeRead );
2855 }
2856 #else
2857 #define checkActiveVdbeCnt(x)
2858 #endif
2859
2860 /*
2861 ** If the Vdbe passed as the first argument opened a statement-transaction,
2862 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
2863 ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
2864 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
2865 ** statement transaction is committed.
2866 **
2867 ** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned.
2868 ** Otherwise SQLITE_OK.
2869 */
vdbeCloseStatement(Vdbe * p,int eOp)2870 static SQLITE_NOINLINE int vdbeCloseStatement(Vdbe *p, int eOp){
2871 sqlite3 *const db = p->db;
2872 int rc = SQLITE_OK;
2873 int i;
2874 const int iSavepoint = p->iStatement-1;
2875
2876 assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
2877 assert( db->nStatement>0 );
2878 assert( p->iStatement==(db->nStatement+db->nSavepoint) );
2879
2880 for(i=0; i<db->nDb; i++){
2881 int rc2 = SQLITE_OK;
2882 Btree *pBt = db->aDb[i].pBt;
2883 if( pBt ){
2884 if( eOp==SAVEPOINT_ROLLBACK ){
2885 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
2886 }
2887 if( rc2==SQLITE_OK ){
2888 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
2889 }
2890 if( rc==SQLITE_OK ){
2891 rc = rc2;
2892 }
2893 }
2894 }
2895 db->nStatement--;
2896 p->iStatement = 0;
2897
2898 if( rc==SQLITE_OK ){
2899 if( eOp==SAVEPOINT_ROLLBACK ){
2900 rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint);
2901 }
2902 if( rc==SQLITE_OK ){
2903 rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint);
2904 }
2905 }
2906
2907 /* If the statement transaction is being rolled back, also restore the
2908 ** database handles deferred constraint counter to the value it had when
2909 ** the statement transaction was opened. */
2910 if( eOp==SAVEPOINT_ROLLBACK ){
2911 db->nDeferredCons = p->nStmtDefCons;
2912 db->nDeferredImmCons = p->nStmtDefImmCons;
2913 }
2914 return rc;
2915 }
sqlite3VdbeCloseStatement(Vdbe * p,int eOp)2916 int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){
2917 if( p->db->nStatement && p->iStatement ){
2918 return vdbeCloseStatement(p, eOp);
2919 }
2920 return SQLITE_OK;
2921 }
2922
2923
2924 /*
2925 ** This function is called when a transaction opened by the database
2926 ** handle associated with the VM passed as an argument is about to be
2927 ** committed. If there are outstanding deferred foreign key constraint
2928 ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
2929 **
2930 ** If there are outstanding FK violations and this function returns
2931 ** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY
2932 ** and write an error message to it. Then return SQLITE_ERROR.
2933 */
2934 #ifndef SQLITE_OMIT_FOREIGN_KEY
sqlite3VdbeCheckFk(Vdbe * p,int deferred)2935 int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
2936 sqlite3 *db = p->db;
2937 if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0)
2938 || (!deferred && p->nFkConstraint>0)
2939 ){
2940 p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;
2941 p->errorAction = OE_Abort;
2942 sqlite3VdbeError(p, "FOREIGN KEY constraint failed");
2943 return SQLITE_ERROR;
2944 }
2945 return SQLITE_OK;
2946 }
2947 #endif
2948
2949 /*
2950 ** This routine is called the when a VDBE tries to halt. If the VDBE
2951 ** has made changes and is in autocommit mode, then commit those
2952 ** changes. If a rollback is needed, then do the rollback.
2953 **
2954 ** This routine is the only way to move the state of a VM from
2955 ** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to
2956 ** call this on a VM that is in the SQLITE_MAGIC_HALT state.
2957 **
2958 ** Return an error code. If the commit could not complete because of
2959 ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it
2960 ** means the close did not happen and needs to be repeated.
2961 */
sqlite3VdbeHalt(Vdbe * p)2962 int sqlite3VdbeHalt(Vdbe *p){
2963 int rc; /* Used to store transient return codes */
2964 sqlite3 *db = p->db;
2965
2966 /* This function contains the logic that determines if a statement or
2967 ** transaction will be committed or rolled back as a result of the
2968 ** execution of this virtual machine.
2969 **
2970 ** If any of the following errors occur:
2971 **
2972 ** SQLITE_NOMEM
2973 ** SQLITE_IOERR
2974 ** SQLITE_FULL
2975 ** SQLITE_INTERRUPT
2976 **
2977 ** Then the internal cache might have been left in an inconsistent
2978 ** state. We need to rollback the statement transaction, if there is
2979 ** one, or the complete transaction if there is no statement transaction.
2980 */
2981
2982 if( p->magic!=VDBE_MAGIC_RUN ){
2983 return SQLITE_OK;
2984 }
2985 if( db->mallocFailed ){
2986 p->rc = SQLITE_NOMEM_BKPT;
2987 }
2988 closeAllCursors(p);
2989 checkActiveVdbeCnt(db);
2990
2991 /* No commit or rollback needed if the program never started or if the
2992 ** SQL statement does not read or write a database file. */
2993 if( p->pc>=0 && p->bIsReader ){
2994 int mrc; /* Primary error code from p->rc */
2995 int eStatementOp = 0;
2996 int isSpecialError; /* Set to true if a 'special' error */
2997
2998 /* Lock all btrees used by the statement */
2999 sqlite3VdbeEnter(p);
3000
3001 /* Check for one of the special errors */
3002 mrc = p->rc & 0xff;
3003 isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR
3004 || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL;
3005 if( isSpecialError ){
3006 /* If the query was read-only and the error code is SQLITE_INTERRUPT,
3007 ** no rollback is necessary. Otherwise, at least a savepoint
3008 ** transaction must be rolled back to restore the database to a
3009 ** consistent state.
3010 **
3011 ** Even if the statement is read-only, it is important to perform
3012 ** a statement or transaction rollback operation. If the error
3013 ** occurred while writing to the journal, sub-journal or database
3014 ** file as part of an effort to free up cache space (see function
3015 ** pagerStress() in pager.c), the rollback is required to restore
3016 ** the pager to a consistent state.
3017 */
3018 if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){
3019 if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){
3020 eStatementOp = SAVEPOINT_ROLLBACK;
3021 }else{
3022 /* We are forced to roll back the active transaction. Before doing
3023 ** so, abort any other statements this handle currently has active.
3024 */
3025 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
3026 sqlite3CloseSavepoints(db);
3027 db->autoCommit = 1;
3028 p->nChange = 0;
3029 }
3030 }
3031 }
3032
3033 /* Check for immediate foreign key violations. */
3034 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
3035 sqlite3VdbeCheckFk(p, 0);
3036 }
3037
3038 /* If the auto-commit flag is set and this is the only active writer
3039 ** VM, then we do either a commit or rollback of the current transaction.
3040 **
3041 ** Note: This block also runs if one of the special errors handled
3042 ** above has occurred.
3043 */
3044 if( !sqlite3VtabInSync(db)
3045 && db->autoCommit
3046 && db->nVdbeWrite==(p->readOnly==0)
3047 ){
3048 if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
3049 rc = sqlite3VdbeCheckFk(p, 1);
3050 if( rc!=SQLITE_OK ){
3051 if( NEVER(p->readOnly) ){
3052 sqlite3VdbeLeave(p);
3053 return SQLITE_ERROR;
3054 }
3055 rc = SQLITE_CONSTRAINT_FOREIGNKEY;
3056 }else{
3057 /* The auto-commit flag is true, the vdbe program was successful
3058 ** or hit an 'OR FAIL' constraint and there are no deferred foreign
3059 ** key constraints to hold up the transaction. This means a commit
3060 ** is required. */
3061 rc = vdbeCommit(db, p);
3062 }
3063 if( rc==SQLITE_BUSY && p->readOnly ){
3064 sqlite3VdbeLeave(p);
3065 return SQLITE_BUSY;
3066 }else if( rc!=SQLITE_OK ){
3067 p->rc = rc;
3068 sqlite3RollbackAll(db, SQLITE_OK);
3069 p->nChange = 0;
3070 }else{
3071 db->nDeferredCons = 0;
3072 db->nDeferredImmCons = 0;
3073 db->flags &= ~(u64)SQLITE_DeferFKs;
3074 sqlite3CommitInternalChanges(db);
3075 }
3076 }else{
3077 sqlite3RollbackAll(db, SQLITE_OK);
3078 p->nChange = 0;
3079 }
3080 db->nStatement = 0;
3081 }else if( eStatementOp==0 ){
3082 if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
3083 eStatementOp = SAVEPOINT_RELEASE;
3084 }else if( p->errorAction==OE_Abort ){
3085 eStatementOp = SAVEPOINT_ROLLBACK;
3086 }else{
3087 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
3088 sqlite3CloseSavepoints(db);
3089 db->autoCommit = 1;
3090 p->nChange = 0;
3091 }
3092 }
3093
3094 /* If eStatementOp is non-zero, then a statement transaction needs to
3095 ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to
3096 ** do so. If this operation returns an error, and the current statement
3097 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
3098 ** current statement error code.
3099 */
3100 if( eStatementOp ){
3101 rc = sqlite3VdbeCloseStatement(p, eStatementOp);
3102 if( rc ){
3103 if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){
3104 p->rc = rc;
3105 sqlite3DbFree(db, p->zErrMsg);
3106 p->zErrMsg = 0;
3107 }
3108 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
3109 sqlite3CloseSavepoints(db);
3110 db->autoCommit = 1;
3111 p->nChange = 0;
3112 }
3113 }
3114
3115 /* If this was an INSERT, UPDATE or DELETE and no statement transaction
3116 ** has been rolled back, update the database connection change-counter.
3117 */
3118 if( p->changeCntOn ){
3119 if( eStatementOp!=SAVEPOINT_ROLLBACK ){
3120 sqlite3VdbeSetChanges(db, p->nChange);
3121 }else{
3122 sqlite3VdbeSetChanges(db, 0);
3123 }
3124 p->nChange = 0;
3125 }
3126
3127 /* Release the locks */
3128 sqlite3VdbeLeave(p);
3129 }
3130
3131 /* We have successfully halted and closed the VM. Record this fact. */
3132 if( p->pc>=0 ){
3133 db->nVdbeActive--;
3134 if( !p->readOnly ) db->nVdbeWrite--;
3135 if( p->bIsReader ) db->nVdbeRead--;
3136 assert( db->nVdbeActive>=db->nVdbeRead );
3137 assert( db->nVdbeRead>=db->nVdbeWrite );
3138 assert( db->nVdbeWrite>=0 );
3139 }
3140 p->magic = VDBE_MAGIC_HALT;
3141 checkActiveVdbeCnt(db);
3142 if( db->mallocFailed ){
3143 p->rc = SQLITE_NOMEM_BKPT;
3144 }
3145
3146 /* If the auto-commit flag is set to true, then any locks that were held
3147 ** by connection db have now been released. Call sqlite3ConnectionUnlocked()
3148 ** to invoke any required unlock-notify callbacks.
3149 */
3150 if( db->autoCommit ){
3151 sqlite3ConnectionUnlocked(db);
3152 }
3153
3154 assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 );
3155 return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
3156 }
3157
3158
3159 /*
3160 ** Each VDBE holds the result of the most recent sqlite3_step() call
3161 ** in p->rc. This routine sets that result back to SQLITE_OK.
3162 */
sqlite3VdbeResetStepResult(Vdbe * p)3163 void sqlite3VdbeResetStepResult(Vdbe *p){
3164 p->rc = SQLITE_OK;
3165 }
3166
3167 /*
3168 ** Copy the error code and error message belonging to the VDBE passed
3169 ** as the first argument to its database handle (so that they will be
3170 ** returned by calls to sqlite3_errcode() and sqlite3_errmsg()).
3171 **
3172 ** This function does not clear the VDBE error code or message, just
3173 ** copies them to the database handle.
3174 */
sqlite3VdbeTransferError(Vdbe * p)3175 int sqlite3VdbeTransferError(Vdbe *p){
3176 sqlite3 *db = p->db;
3177 int rc = p->rc;
3178 if( p->zErrMsg ){
3179 db->bBenignMalloc++;
3180 sqlite3BeginBenignMalloc();
3181 if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
3182 sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
3183 sqlite3EndBenignMalloc();
3184 db->bBenignMalloc--;
3185 }else if( db->pErr ){
3186 sqlite3ValueSetNull(db->pErr);
3187 }
3188 db->errCode = rc;
3189 return rc;
3190 }
3191
3192 #ifdef SQLITE_ENABLE_SQLLOG
3193 /*
3194 ** If an SQLITE_CONFIG_SQLLOG hook is registered and the VM has been run,
3195 ** invoke it.
3196 */
vdbeInvokeSqllog(Vdbe * v)3197 static void vdbeInvokeSqllog(Vdbe *v){
3198 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
3199 char *zExpanded = sqlite3VdbeExpandSql(v, v->zSql);
3200 assert( v->db->init.busy==0 );
3201 if( zExpanded ){
3202 sqlite3GlobalConfig.xSqllog(
3203 sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1
3204 );
3205 sqlite3DbFree(v->db, zExpanded);
3206 }
3207 }
3208 }
3209 #else
3210 # define vdbeInvokeSqllog(x)
3211 #endif
3212
3213 /*
3214 ** Clean up a VDBE after execution but do not delete the VDBE just yet.
3215 ** Write any error messages into *pzErrMsg. Return the result code.
3216 **
3217 ** After this routine is run, the VDBE should be ready to be executed
3218 ** again.
3219 **
3220 ** To look at it another way, this routine resets the state of the
3221 ** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to
3222 ** VDBE_MAGIC_INIT.
3223 */
sqlite3VdbeReset(Vdbe * p)3224 int sqlite3VdbeReset(Vdbe *p){
3225 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
3226 int i;
3227 #endif
3228
3229 sqlite3 *db;
3230 db = p->db;
3231
3232 /* If the VM did not run to completion or if it encountered an
3233 ** error, then it might not have been halted properly. So halt
3234 ** it now.
3235 */
3236 sqlite3VdbeHalt(p);
3237
3238 /* If the VDBE has been run even partially, then transfer the error code
3239 ** and error message from the VDBE into the main database structure. But
3240 ** if the VDBE has just been set to run but has not actually executed any
3241 ** instructions yet, leave the main database error information unchanged.
3242 */
3243 if( p->pc>=0 ){
3244 vdbeInvokeSqllog(p);
3245 sqlite3VdbeTransferError(p);
3246 if( p->runOnlyOnce ) p->expired = 1;
3247 }else if( p->rc && p->expired ){
3248 /* The expired flag was set on the VDBE before the first call
3249 ** to sqlite3_step(). For consistency (since sqlite3_step() was
3250 ** called), set the database error in this case as well.
3251 */
3252 sqlite3ErrorWithMsg(db, p->rc, p->zErrMsg ? "%s" : 0, p->zErrMsg);
3253 }
3254
3255 /* Reset register contents and reclaim error message memory.
3256 */
3257 #ifdef SQLITE_DEBUG
3258 /* Execute assert() statements to ensure that the Vdbe.apCsr[] and
3259 ** Vdbe.aMem[] arrays have already been cleaned up. */
3260 if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
3261 if( p->aMem ){
3262 for(i=0; i<p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
3263 }
3264 #endif
3265 sqlite3DbFree(db, p->zErrMsg);
3266 p->zErrMsg = 0;
3267 p->pResultSet = 0;
3268 #ifdef SQLITE_DEBUG
3269 p->nWrite = 0;
3270 #endif
3271
3272 /* Save profiling information from this VDBE run.
3273 */
3274 #ifdef VDBE_PROFILE
3275 {
3276 FILE *out = fopen("vdbe_profile.out", "a");
3277 if( out ){
3278 fprintf(out, "---- ");
3279 for(i=0; i<p->nOp; i++){
3280 fprintf(out, "%02x", p->aOp[i].opcode);
3281 }
3282 fprintf(out, "\n");
3283 if( p->zSql ){
3284 char c, pc = 0;
3285 fprintf(out, "-- ");
3286 for(i=0; (c = p->zSql[i])!=0; i++){
3287 if( pc=='\n' ) fprintf(out, "-- ");
3288 putc(c, out);
3289 pc = c;
3290 }
3291 if( pc!='\n' ) fprintf(out, "\n");
3292 }
3293 for(i=0; i<p->nOp; i++){
3294 char zHdr[100];
3295 sqlite3_snprintf(sizeof(zHdr), zHdr, "%6u %12llu %8llu ",
3296 p->aOp[i].cnt,
3297 p->aOp[i].cycles,
3298 p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
3299 );
3300 fprintf(out, "%s", zHdr);
3301 sqlite3VdbePrintOp(out, i, &p->aOp[i]);
3302 }
3303 fclose(out);
3304 }
3305 }
3306 #endif
3307 p->magic = VDBE_MAGIC_RESET;
3308 return p->rc & db->errMask;
3309 }
3310
3311 /*
3312 ** Clean up and delete a VDBE after execution. Return an integer which is
3313 ** the result code. Write any error message text into *pzErrMsg.
3314 */
sqlite3VdbeFinalize(Vdbe * p)3315 int sqlite3VdbeFinalize(Vdbe *p){
3316 int rc = SQLITE_OK;
3317 if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){
3318 rc = sqlite3VdbeReset(p);
3319 assert( (rc & p->db->errMask)==rc );
3320 }
3321 sqlite3VdbeDelete(p);
3322 return rc;
3323 }
3324
3325 /*
3326 ** If parameter iOp is less than zero, then invoke the destructor for
3327 ** all auxiliary data pointers currently cached by the VM passed as
3328 ** the first argument.
3329 **
3330 ** Or, if iOp is greater than or equal to zero, then the destructor is
3331 ** only invoked for those auxiliary data pointers created by the user
3332 ** function invoked by the OP_Function opcode at instruction iOp of
3333 ** VM pVdbe, and only then if:
3334 **
3335 ** * the associated function parameter is the 32nd or later (counting
3336 ** from left to right), or
3337 **
3338 ** * the corresponding bit in argument mask is clear (where the first
3339 ** function parameter corresponds to bit 0 etc.).
3340 */
sqlite3VdbeDeleteAuxData(sqlite3 * db,AuxData ** pp,int iOp,int mask)3341 void sqlite3VdbeDeleteAuxData(sqlite3 *db, AuxData **pp, int iOp, int mask){
3342 while( *pp ){
3343 AuxData *pAux = *pp;
3344 if( (iOp<0)
3345 || (pAux->iAuxOp==iOp
3346 && pAux->iAuxArg>=0
3347 && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg))))
3348 ){
3349 testcase( pAux->iAuxArg==31 );
3350 if( pAux->xDeleteAux ){
3351 pAux->xDeleteAux(pAux->pAux);
3352 }
3353 *pp = pAux->pNextAux;
3354 sqlite3DbFree(db, pAux);
3355 }else{
3356 pp= &pAux->pNextAux;
3357 }
3358 }
3359 }
3360
3361 /*
3362 ** Free all memory associated with the Vdbe passed as the second argument,
3363 ** except for object itself, which is preserved.
3364 **
3365 ** The difference between this function and sqlite3VdbeDelete() is that
3366 ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
3367 ** the database connection and frees the object itself.
3368 */
sqlite3VdbeClearObject(sqlite3 * db,Vdbe * p)3369 void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
3370 SubProgram *pSub, *pNext;
3371 assert( p->db==0 || p->db==db );
3372 releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
3373 for(pSub=p->pProgram; pSub; pSub=pNext){
3374 pNext = pSub->pNext;
3375 vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
3376 sqlite3DbFree(db, pSub);
3377 }
3378 if( p->magic!=VDBE_MAGIC_INIT ){
3379 releaseMemArray(p->aVar, p->nVar);
3380 sqlite3DbFree(db, p->pVList);
3381 sqlite3DbFree(db, p->pFree);
3382 }
3383 vdbeFreeOpArray(db, p->aOp, p->nOp);
3384 sqlite3DbFree(db, p->aColName);
3385 sqlite3DbFree(db, p->zSql);
3386 #ifdef SQLITE_ENABLE_NORMALIZE
3387 sqlite3DbFree(db, p->zNormSql);
3388 {
3389 DblquoteStr *pThis, *pNext;
3390 for(pThis=p->pDblStr; pThis; pThis=pNext){
3391 pNext = pThis->pNextStr;
3392 sqlite3DbFree(db, pThis);
3393 }
3394 }
3395 #endif
3396 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
3397 {
3398 int i;
3399 for(i=0; i<p->nScan; i++){
3400 sqlite3DbFree(db, p->aScan[i].zName);
3401 }
3402 sqlite3DbFree(db, p->aScan);
3403 }
3404 #endif
3405 }
3406
3407 /*
3408 ** Delete an entire VDBE.
3409 */
sqlite3VdbeDelete(Vdbe * p)3410 void sqlite3VdbeDelete(Vdbe *p){
3411 sqlite3 *db;
3412
3413 assert( p!=0 );
3414 db = p->db;
3415 assert( sqlite3_mutex_held(db->mutex) );
3416 sqlite3VdbeClearObject(db, p);
3417 if( p->pPrev ){
3418 p->pPrev->pNext = p->pNext;
3419 }else{
3420 assert( db->pVdbe==p );
3421 db->pVdbe = p->pNext;
3422 }
3423 if( p->pNext ){
3424 p->pNext->pPrev = p->pPrev;
3425 }
3426 p->magic = VDBE_MAGIC_DEAD;
3427 p->db = 0;
3428 sqlite3DbFreeNN(db, p);
3429 }
3430
3431 /*
3432 ** The cursor "p" has a pending seek operation that has not yet been
3433 ** carried out. Seek the cursor now. If an error occurs, return
3434 ** the appropriate error code.
3435 */
sqlite3VdbeFinishMoveto(VdbeCursor * p)3436 int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor *p){
3437 int res, rc;
3438 #ifdef SQLITE_TEST
3439 extern int sqlite3_search_count;
3440 #endif
3441 assert( p->deferredMoveto );
3442 assert( p->isTable );
3443 assert( p->eCurType==CURTYPE_BTREE );
3444 rc = sqlite3BtreeMovetoUnpacked(p->uc.pCursor, 0, p->movetoTarget, 0, &res);
3445 if( rc ) return rc;
3446 if( res!=0 ) return SQLITE_CORRUPT_BKPT;
3447 #ifdef SQLITE_TEST
3448 sqlite3_search_count++;
3449 #endif
3450 p->deferredMoveto = 0;
3451 p->cacheStatus = CACHE_STALE;
3452 return SQLITE_OK;
3453 }
3454
3455 /*
3456 ** Something has moved cursor "p" out of place. Maybe the row it was
3457 ** pointed to was deleted out from under it. Or maybe the btree was
3458 ** rebalanced. Whatever the cause, try to restore "p" to the place it
3459 ** is supposed to be pointing. If the row was deleted out from under the
3460 ** cursor, set the cursor to point to a NULL row.
3461 */
handleMovedCursor(VdbeCursor * p)3462 static int SQLITE_NOINLINE handleMovedCursor(VdbeCursor *p){
3463 int isDifferentRow, rc;
3464 assert( p->eCurType==CURTYPE_BTREE );
3465 assert( p->uc.pCursor!=0 );
3466 assert( sqlite3BtreeCursorHasMoved(p->uc.pCursor) );
3467 rc = sqlite3BtreeCursorRestore(p->uc.pCursor, &isDifferentRow);
3468 p->cacheStatus = CACHE_STALE;
3469 if( isDifferentRow ) p->nullRow = 1;
3470 return rc;
3471 }
3472
3473 /*
3474 ** Check to ensure that the cursor is valid. Restore the cursor
3475 ** if need be. Return any I/O error from the restore operation.
3476 */
sqlite3VdbeCursorRestore(VdbeCursor * p)3477 int sqlite3VdbeCursorRestore(VdbeCursor *p){
3478 assert( p->eCurType==CURTYPE_BTREE );
3479 if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){
3480 return handleMovedCursor(p);
3481 }
3482 return SQLITE_OK;
3483 }
3484
3485 /*
3486 ** Make sure the cursor p is ready to read or write the row to which it
3487 ** was last positioned. Return an error code if an OOM fault or I/O error
3488 ** prevents us from positioning the cursor to its correct position.
3489 **
3490 ** If a MoveTo operation is pending on the given cursor, then do that
3491 ** MoveTo now. If no move is pending, check to see if the row has been
3492 ** deleted out from under the cursor and if it has, mark the row as
3493 ** a NULL row.
3494 **
3495 ** If the cursor is already pointing to the correct row and that row has
3496 ** not been deleted out from under the cursor, then this routine is a no-op.
3497 */
sqlite3VdbeCursorMoveto(VdbeCursor ** pp,int * piCol)3498 int sqlite3VdbeCursorMoveto(VdbeCursor **pp, int *piCol){
3499 VdbeCursor *p = *pp;
3500 assert( p->eCurType==CURTYPE_BTREE || p->eCurType==CURTYPE_PSEUDO );
3501 if( p->deferredMoveto ){
3502 int iMap;
3503 if( p->aAltMap && (iMap = p->aAltMap[1+*piCol])>0 ){
3504 *pp = p->pAltCursor;
3505 *piCol = iMap - 1;
3506 return SQLITE_OK;
3507 }
3508 return sqlite3VdbeFinishMoveto(p);
3509 }
3510 if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){
3511 return handleMovedCursor(p);
3512 }
3513 return SQLITE_OK;
3514 }
3515
3516 /*
3517 ** The following functions:
3518 **
3519 ** sqlite3VdbeSerialType()
3520 ** sqlite3VdbeSerialTypeLen()
3521 ** sqlite3VdbeSerialLen()
3522 ** sqlite3VdbeSerialPut()
3523 ** sqlite3VdbeSerialGet()
3524 **
3525 ** encapsulate the code that serializes values for storage in SQLite
3526 ** data and index records. Each serialized value consists of a
3527 ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
3528 ** integer, stored as a varint.
3529 **
3530 ** In an SQLite index record, the serial type is stored directly before
3531 ** the blob of data that it corresponds to. In a table record, all serial
3532 ** types are stored at the start of the record, and the blobs of data at
3533 ** the end. Hence these functions allow the caller to handle the
3534 ** serial-type and data blob separately.
3535 **
3536 ** The following table describes the various storage classes for data:
3537 **
3538 ** serial type bytes of data type
3539 ** -------------- --------------- ---------------
3540 ** 0 0 NULL
3541 ** 1 1 signed integer
3542 ** 2 2 signed integer
3543 ** 3 3 signed integer
3544 ** 4 4 signed integer
3545 ** 5 6 signed integer
3546 ** 6 8 signed integer
3547 ** 7 8 IEEE float
3548 ** 8 0 Integer constant 0
3549 ** 9 0 Integer constant 1
3550 ** 10,11 reserved for expansion
3551 ** N>=12 and even (N-12)/2 BLOB
3552 ** N>=13 and odd (N-13)/2 text
3553 **
3554 ** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions
3555 ** of SQLite will not understand those serial types.
3556 */
3557
3558 #if 0 /* Inlined into the OP_MakeRecord opcode */
3559 /*
3560 ** Return the serial-type for the value stored in pMem.
3561 **
3562 ** This routine might convert a large MEM_IntReal value into MEM_Real.
3563 **
3564 ** 2019-07-11: The primary user of this subroutine was the OP_MakeRecord
3565 ** opcode in the byte-code engine. But by moving this routine in-line, we
3566 ** can omit some redundant tests and make that opcode a lot faster. So
3567 ** this routine is now only used by the STAT3 logic and STAT3 support has
3568 ** ended. The code is kept here for historical reference only.
3569 */
3570 u32 sqlite3VdbeSerialType(Mem *pMem, int file_format, u32 *pLen){
3571 int flags = pMem->flags;
3572 u32 n;
3573
3574 assert( pLen!=0 );
3575 if( flags&MEM_Null ){
3576 *pLen = 0;
3577 return 0;
3578 }
3579 if( flags&(MEM_Int|MEM_IntReal) ){
3580 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
3581 # define MAX_6BYTE ((((i64)0x00008000)<<32)-1)
3582 i64 i = pMem->u.i;
3583 u64 u;
3584 testcase( flags & MEM_Int );
3585 testcase( flags & MEM_IntReal );
3586 if( i<0 ){
3587 u = ~i;
3588 }else{
3589 u = i;
3590 }
3591 if( u<=127 ){
3592 if( (i&1)==i && file_format>=4 ){
3593 *pLen = 0;
3594 return 8+(u32)u;
3595 }else{
3596 *pLen = 1;
3597 return 1;
3598 }
3599 }
3600 if( u<=32767 ){ *pLen = 2; return 2; }
3601 if( u<=8388607 ){ *pLen = 3; return 3; }
3602 if( u<=2147483647 ){ *pLen = 4; return 4; }
3603 if( u<=MAX_6BYTE ){ *pLen = 6; return 5; }
3604 *pLen = 8;
3605 if( flags&MEM_IntReal ){
3606 /* If the value is IntReal and is going to take up 8 bytes to store
3607 ** as an integer, then we might as well make it an 8-byte floating
3608 ** point value */
3609 pMem->u.r = (double)pMem->u.i;
3610 pMem->flags &= ~MEM_IntReal;
3611 pMem->flags |= MEM_Real;
3612 return 7;
3613 }
3614 return 6;
3615 }
3616 if( flags&MEM_Real ){
3617 *pLen = 8;
3618 return 7;
3619 }
3620 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
3621 assert( pMem->n>=0 );
3622 n = (u32)pMem->n;
3623 if( flags & MEM_Zero ){
3624 n += pMem->u.nZero;
3625 }
3626 *pLen = n;
3627 return ((n*2) + 12 + ((flags&MEM_Str)!=0));
3628 }
3629 #endif /* inlined into OP_MakeRecord */
3630
3631 /*
3632 ** The sizes for serial types less than 128
3633 */
3634 static const u8 sqlite3SmallTypeSizes[] = {
3635 /* 0 1 2 3 4 5 6 7 8 9 */
3636 /* 0 */ 0, 1, 2, 3, 4, 6, 8, 8, 0, 0,
3637 /* 10 */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3,
3638 /* 20 */ 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
3639 /* 30 */ 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,
3640 /* 40 */ 14, 14, 15, 15, 16, 16, 17, 17, 18, 18,
3641 /* 50 */ 19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
3642 /* 60 */ 24, 24, 25, 25, 26, 26, 27, 27, 28, 28,
3643 /* 70 */ 29, 29, 30, 30, 31, 31, 32, 32, 33, 33,
3644 /* 80 */ 34, 34, 35, 35, 36, 36, 37, 37, 38, 38,
3645 /* 90 */ 39, 39, 40, 40, 41, 41, 42, 42, 43, 43,
3646 /* 100 */ 44, 44, 45, 45, 46, 46, 47, 47, 48, 48,
3647 /* 110 */ 49, 49, 50, 50, 51, 51, 52, 52, 53, 53,
3648 /* 120 */ 54, 54, 55, 55, 56, 56, 57, 57
3649 };
3650
3651 /*
3652 ** Return the length of the data corresponding to the supplied serial-type.
3653 */
sqlite3VdbeSerialTypeLen(u32 serial_type)3654 u32 sqlite3VdbeSerialTypeLen(u32 serial_type){
3655 if( serial_type>=128 ){
3656 return (serial_type-12)/2;
3657 }else{
3658 assert( serial_type<12
3659 || sqlite3SmallTypeSizes[serial_type]==(serial_type - 12)/2 );
3660 return sqlite3SmallTypeSizes[serial_type];
3661 }
3662 }
sqlite3VdbeOneByteSerialTypeLen(u8 serial_type)3663 u8 sqlite3VdbeOneByteSerialTypeLen(u8 serial_type){
3664 assert( serial_type<128 );
3665 return sqlite3SmallTypeSizes[serial_type];
3666 }
3667
3668 /*
3669 ** If we are on an architecture with mixed-endian floating
3670 ** points (ex: ARM7) then swap the lower 4 bytes with the
3671 ** upper 4 bytes. Return the result.
3672 **
3673 ** For most architectures, this is a no-op.
3674 **
3675 ** (later): It is reported to me that the mixed-endian problem
3676 ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
3677 ** that early versions of GCC stored the two words of a 64-bit
3678 ** float in the wrong order. And that error has been propagated
3679 ** ever since. The blame is not necessarily with GCC, though.
3680 ** GCC might have just copying the problem from a prior compiler.
3681 ** I am also told that newer versions of GCC that follow a different
3682 ** ABI get the byte order right.
3683 **
3684 ** Developers using SQLite on an ARM7 should compile and run their
3685 ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
3686 ** enabled, some asserts below will ensure that the byte order of
3687 ** floating point values is correct.
3688 **
3689 ** (2007-08-30) Frank van Vugt has studied this problem closely
3690 ** and has send his findings to the SQLite developers. Frank
3691 ** writes that some Linux kernels offer floating point hardware
3692 ** emulation that uses only 32-bit mantissas instead of a full
3693 ** 48-bits as required by the IEEE standard. (This is the
3694 ** CONFIG_FPE_FASTFPE option.) On such systems, floating point
3695 ** byte swapping becomes very complicated. To avoid problems,
3696 ** the necessary byte swapping is carried out using a 64-bit integer
3697 ** rather than a 64-bit float. Frank assures us that the code here
3698 ** works for him. We, the developers, have no way to independently
3699 ** verify this, but Frank seems to know what he is talking about
3700 ** so we trust him.
3701 */
3702 #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
floatSwap(u64 in)3703 static u64 floatSwap(u64 in){
3704 union {
3705 u64 r;
3706 u32 i[2];
3707 } u;
3708 u32 t;
3709
3710 u.r = in;
3711 t = u.i[0];
3712 u.i[0] = u.i[1];
3713 u.i[1] = t;
3714 return u.r;
3715 }
3716 # define swapMixedEndianFloat(X) X = floatSwap(X)
3717 #else
3718 # define swapMixedEndianFloat(X)
3719 #endif
3720
3721 /*
3722 ** Write the serialized data blob for the value stored in pMem into
3723 ** buf. It is assumed that the caller has allocated sufficient space.
3724 ** Return the number of bytes written.
3725 **
3726 ** nBuf is the amount of space left in buf[]. The caller is responsible
3727 ** for allocating enough space to buf[] to hold the entire field, exclusive
3728 ** of the pMem->u.nZero bytes for a MEM_Zero value.
3729 **
3730 ** Return the number of bytes actually written into buf[]. The number
3731 ** of bytes in the zero-filled tail is included in the return value only
3732 ** if those bytes were zeroed in buf[].
3733 */
sqlite3VdbeSerialPut(u8 * buf,Mem * pMem,u32 serial_type)3734 u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){
3735 u32 len;
3736
3737 /* Integer and Real */
3738 if( serial_type<=7 && serial_type>0 ){
3739 u64 v;
3740 u32 i;
3741 if( serial_type==7 ){
3742 assert( sizeof(v)==sizeof(pMem->u.r) );
3743 memcpy(&v, &pMem->u.r, sizeof(v));
3744 swapMixedEndianFloat(v);
3745 }else{
3746 v = pMem->u.i;
3747 }
3748 len = i = sqlite3SmallTypeSizes[serial_type];
3749 assert( i>0 );
3750 do{
3751 buf[--i] = (u8)(v&0xFF);
3752 v >>= 8;
3753 }while( i );
3754 return len;
3755 }
3756
3757 /* String or blob */
3758 if( serial_type>=12 ){
3759 assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
3760 == (int)sqlite3VdbeSerialTypeLen(serial_type) );
3761 len = pMem->n;
3762 if( len>0 ) memcpy(buf, pMem->z, len);
3763 return len;
3764 }
3765
3766 /* NULL or constants 0 or 1 */
3767 return 0;
3768 }
3769
3770 /* Input "x" is a sequence of unsigned characters that represent a
3771 ** big-endian integer. Return the equivalent native integer
3772 */
3773 #define ONE_BYTE_INT(x) ((i8)(x)[0])
3774 #define TWO_BYTE_INT(x) (256*(i8)((x)[0])|(x)[1])
3775 #define THREE_BYTE_INT(x) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2])
3776 #define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
3777 #define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
3778
3779 /*
3780 ** Deserialize the data blob pointed to by buf as serial type serial_type
3781 ** and store the result in pMem. Return the number of bytes read.
3782 **
3783 ** This function is implemented as two separate routines for performance.
3784 ** The few cases that require local variables are broken out into a separate
3785 ** routine so that in most cases the overhead of moving the stack pointer
3786 ** is avoided.
3787 */
serialGet(const unsigned char * buf,u32 serial_type,Mem * pMem)3788 static u32 serialGet(
3789 const unsigned char *buf, /* Buffer to deserialize from */
3790 u32 serial_type, /* Serial type to deserialize */
3791 Mem *pMem /* Memory cell to write value into */
3792 ){
3793 u64 x = FOUR_BYTE_UINT(buf);
3794 u32 y = FOUR_BYTE_UINT(buf+4);
3795 x = (x<<32) + y;
3796 if( serial_type==6 ){
3797 /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit
3798 ** twos-complement integer. */
3799 pMem->u.i = *(i64*)&x;
3800 pMem->flags = MEM_Int;
3801 testcase( pMem->u.i<0 );
3802 }else{
3803 /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit
3804 ** floating point number. */
3805 #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
3806 /* Verify that integers and floating point values use the same
3807 ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
3808 ** defined that 64-bit floating point values really are mixed
3809 ** endian.
3810 */
3811 static const u64 t1 = ((u64)0x3ff00000)<<32;
3812 static const double r1 = 1.0;
3813 u64 t2 = t1;
3814 swapMixedEndianFloat(t2);
3815 assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
3816 #endif
3817 assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
3818 swapMixedEndianFloat(x);
3819 memcpy(&pMem->u.r, &x, sizeof(x));
3820 pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real;
3821 }
3822 return 8;
3823 }
sqlite3VdbeSerialGet(const unsigned char * buf,u32 serial_type,Mem * pMem)3824 u32 sqlite3VdbeSerialGet(
3825 const unsigned char *buf, /* Buffer to deserialize from */
3826 u32 serial_type, /* Serial type to deserialize */
3827 Mem *pMem /* Memory cell to write value into */
3828 ){
3829 switch( serial_type ){
3830 case 10: { /* Internal use only: NULL with virtual table
3831 ** UPDATE no-change flag set */
3832 pMem->flags = MEM_Null|MEM_Zero;
3833 pMem->n = 0;
3834 pMem->u.nZero = 0;
3835 break;
3836 }
3837 case 11: /* Reserved for future use */
3838 case 0: { /* Null */
3839 /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */
3840 pMem->flags = MEM_Null;
3841 break;
3842 }
3843 case 1: {
3844 /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement
3845 ** integer. */
3846 pMem->u.i = ONE_BYTE_INT(buf);
3847 pMem->flags = MEM_Int;
3848 testcase( pMem->u.i<0 );
3849 return 1;
3850 }
3851 case 2: { /* 2-byte signed integer */
3852 /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit
3853 ** twos-complement integer. */
3854 pMem->u.i = TWO_BYTE_INT(buf);
3855 pMem->flags = MEM_Int;
3856 testcase( pMem->u.i<0 );
3857 return 2;
3858 }
3859 case 3: { /* 3-byte signed integer */
3860 /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit
3861 ** twos-complement integer. */
3862 pMem->u.i = THREE_BYTE_INT(buf);
3863 pMem->flags = MEM_Int;
3864 testcase( pMem->u.i<0 );
3865 return 3;
3866 }
3867 case 4: { /* 4-byte signed integer */
3868 /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit
3869 ** twos-complement integer. */
3870 pMem->u.i = FOUR_BYTE_INT(buf);
3871 #ifdef __HP_cc
3872 /* Work around a sign-extension bug in the HP compiler for HP/UX */
3873 if( buf[0]&0x80 ) pMem->u.i |= 0xffffffff80000000LL;
3874 #endif
3875 pMem->flags = MEM_Int;
3876 testcase( pMem->u.i<0 );
3877 return 4;
3878 }
3879 case 5: { /* 6-byte signed integer */
3880 /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit
3881 ** twos-complement integer. */
3882 pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf);
3883 pMem->flags = MEM_Int;
3884 testcase( pMem->u.i<0 );
3885 return 6;
3886 }
3887 case 6: /* 8-byte signed integer */
3888 case 7: { /* IEEE floating point */
3889 /* These use local variables, so do them in a separate routine
3890 ** to avoid having to move the frame pointer in the common case */
3891 return serialGet(buf,serial_type,pMem);
3892 }
3893 case 8: /* Integer 0 */
3894 case 9: { /* Integer 1 */
3895 /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */
3896 /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */
3897 pMem->u.i = serial_type-8;
3898 pMem->flags = MEM_Int;
3899 return 0;
3900 }
3901 default: {
3902 /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in
3903 ** length.
3904 ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and
3905 ** (N-13)/2 bytes in length. */
3906 static const u16 aFlag[] = { MEM_Blob|MEM_Ephem, MEM_Str|MEM_Ephem };
3907 pMem->z = (char *)buf;
3908 pMem->n = (serial_type-12)/2;
3909 pMem->flags = aFlag[serial_type&1];
3910 return pMem->n;
3911 }
3912 }
3913 return 0;
3914 }
3915 /*
3916 ** This routine is used to allocate sufficient space for an UnpackedRecord
3917 ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
3918 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
3919 **
3920 ** The space is either allocated using sqlite3DbMallocRaw() or from within
3921 ** the unaligned buffer passed via the second and third arguments (presumably
3922 ** stack space). If the former, then *ppFree is set to a pointer that should
3923 ** be eventually freed by the caller using sqlite3DbFree(). Or, if the
3924 ** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL
3925 ** before returning.
3926 **
3927 ** If an OOM error occurs, NULL is returned.
3928 */
sqlite3VdbeAllocUnpackedRecord(KeyInfo * pKeyInfo)3929 UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(
3930 KeyInfo *pKeyInfo /* Description of the record */
3931 ){
3932 UnpackedRecord *p; /* Unpacked record to return */
3933 int nByte; /* Number of bytes required for *p */
3934 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
3935 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
3936 if( !p ) return 0;
3937 p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
3938 assert( pKeyInfo->aSortFlags!=0 );
3939 p->pKeyInfo = pKeyInfo;
3940 p->nField = pKeyInfo->nKeyField + 1;
3941 return p;
3942 }
3943
3944 /*
3945 ** Given the nKey-byte encoding of a record in pKey[], populate the
3946 ** UnpackedRecord structure indicated by the fourth argument with the
3947 ** contents of the decoded record.
3948 */
sqlite3VdbeRecordUnpack(KeyInfo * pKeyInfo,int nKey,const void * pKey,UnpackedRecord * p)3949 void sqlite3VdbeRecordUnpack(
3950 KeyInfo *pKeyInfo, /* Information about the record format */
3951 int nKey, /* Size of the binary record */
3952 const void *pKey, /* The binary record */
3953 UnpackedRecord *p /* Populate this structure before returning. */
3954 ){
3955 const unsigned char *aKey = (const unsigned char *)pKey;
3956 u32 d;
3957 u32 idx; /* Offset in aKey[] to read from */
3958 u16 u; /* Unsigned loop counter */
3959 u32 szHdr;
3960 Mem *pMem = p->aMem;
3961
3962 p->default_rc = 0;
3963 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
3964 idx = getVarint32(aKey, szHdr);
3965 d = szHdr;
3966 u = 0;
3967 while( idx<szHdr && d<=(u32)nKey ){
3968 u32 serial_type;
3969
3970 idx += getVarint32(&aKey[idx], serial_type);
3971 pMem->enc = pKeyInfo->enc;
3972 pMem->db = pKeyInfo->db;
3973 /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
3974 pMem->szMalloc = 0;
3975 pMem->z = 0;
3976 d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem);
3977 pMem++;
3978 if( (++u)>=p->nField ) break;
3979 }
3980 if( d>(u32)nKey && u ){
3981 assert( CORRUPT_DB );
3982 /* In a corrupt record entry, the last pMem might have been set up using
3983 ** uninitialized memory. Overwrite its value with NULL, to prevent
3984 ** warnings from MSAN. */
3985 sqlite3VdbeMemSetNull(pMem-1);
3986 }
3987 assert( u<=pKeyInfo->nKeyField + 1 );
3988 p->nField = u;
3989 }
3990
3991 #ifdef SQLITE_DEBUG
3992 /*
3993 ** This function compares two index or table record keys in the same way
3994 ** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(),
3995 ** this function deserializes and compares values using the
3996 ** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
3997 ** in assert() statements to ensure that the optimized code in
3998 ** sqlite3VdbeRecordCompare() returns results with these two primitives.
3999 **
4000 ** Return true if the result of comparison is equivalent to desiredResult.
4001 ** Return false if there is a disagreement.
4002 */
vdbeRecordCompareDebug(int nKey1,const void * pKey1,const UnpackedRecord * pPKey2,int desiredResult)4003 static int vdbeRecordCompareDebug(
4004 int nKey1, const void *pKey1, /* Left key */
4005 const UnpackedRecord *pPKey2, /* Right key */
4006 int desiredResult /* Correct answer */
4007 ){
4008 u32 d1; /* Offset into aKey[] of next data element */
4009 u32 idx1; /* Offset into aKey[] of next header element */
4010 u32 szHdr1; /* Number of bytes in header */
4011 int i = 0;
4012 int rc = 0;
4013 const unsigned char *aKey1 = (const unsigned char *)pKey1;
4014 KeyInfo *pKeyInfo;
4015 Mem mem1;
4016
4017 pKeyInfo = pPKey2->pKeyInfo;
4018 if( pKeyInfo->db==0 ) return 1;
4019 mem1.enc = pKeyInfo->enc;
4020 mem1.db = pKeyInfo->db;
4021 /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */
4022 VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */
4023
4024 /* Compilers may complain that mem1.u.i is potentially uninitialized.
4025 ** We could initialize it, as shown here, to silence those complaints.
4026 ** But in fact, mem1.u.i will never actually be used uninitialized, and doing
4027 ** the unnecessary initialization has a measurable negative performance
4028 ** impact, since this routine is a very high runner. And so, we choose
4029 ** to ignore the compiler warnings and leave this variable uninitialized.
4030 */
4031 /* mem1.u.i = 0; // not needed, here to silence compiler warning */
4032
4033 idx1 = getVarint32(aKey1, szHdr1);
4034 if( szHdr1>98307 ) return SQLITE_CORRUPT;
4035 d1 = szHdr1;
4036 assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB );
4037 assert( pKeyInfo->aSortFlags!=0 );
4038 assert( pKeyInfo->nKeyField>0 );
4039 assert( idx1<=szHdr1 || CORRUPT_DB );
4040 do{
4041 u32 serial_type1;
4042
4043 /* Read the serial types for the next element in each key. */
4044 idx1 += getVarint32( aKey1+idx1, serial_type1 );
4045
4046 /* Verify that there is enough key space remaining to avoid
4047 ** a buffer overread. The "d1+serial_type1+2" subexpression will
4048 ** always be greater than or equal to the amount of required key space.
4049 ** Use that approximation to avoid the more expensive call to
4050 ** sqlite3VdbeSerialTypeLen() in the common case.
4051 */
4052 if( d1+(u64)serial_type1+2>(u64)nKey1
4053 && d1+(u64)sqlite3VdbeSerialTypeLen(serial_type1)>(u64)nKey1
4054 ){
4055 break;
4056 }
4057
4058 /* Extract the values to be compared.
4059 */
4060 d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1);
4061
4062 /* Do the comparison
4063 */
4064 rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i],
4065 pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0);
4066 if( rc!=0 ){
4067 assert( mem1.szMalloc==0 ); /* See comment below */
4068 if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
4069 && ((mem1.flags & MEM_Null) || (pPKey2->aMem[i].flags & MEM_Null))
4070 ){
4071 rc = -rc;
4072 }
4073 if( pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC ){
4074 rc = -rc; /* Invert the result for DESC sort order. */
4075 }
4076 goto debugCompareEnd;
4077 }
4078 i++;
4079 }while( idx1<szHdr1 && i<pPKey2->nField );
4080
4081 /* No memory allocation is ever used on mem1. Prove this using
4082 ** the following assert(). If the assert() fails, it indicates a
4083 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).
4084 */
4085 assert( mem1.szMalloc==0 );
4086
4087 /* rc==0 here means that one of the keys ran out of fields and
4088 ** all the fields up to that point were equal. Return the default_rc
4089 ** value. */
4090 rc = pPKey2->default_rc;
4091
4092 debugCompareEnd:
4093 if( desiredResult==0 && rc==0 ) return 1;
4094 if( desiredResult<0 && rc<0 ) return 1;
4095 if( desiredResult>0 && rc>0 ) return 1;
4096 if( CORRUPT_DB ) return 1;
4097 if( pKeyInfo->db->mallocFailed ) return 1;
4098 return 0;
4099 }
4100 #endif
4101
4102 #ifdef SQLITE_DEBUG
4103 /*
4104 ** Count the number of fields (a.k.a. columns) in the record given by
4105 ** pKey,nKey. The verify that this count is less than or equal to the
4106 ** limit given by pKeyInfo->nAllField.
4107 **
4108 ** If this constraint is not satisfied, it means that the high-speed
4109 ** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will
4110 ** not work correctly. If this assert() ever fires, it probably means
4111 ** that the KeyInfo.nKeyField or KeyInfo.nAllField values were computed
4112 ** incorrectly.
4113 */
vdbeAssertFieldCountWithinLimits(int nKey,const void * pKey,const KeyInfo * pKeyInfo)4114 static void vdbeAssertFieldCountWithinLimits(
4115 int nKey, const void *pKey, /* The record to verify */
4116 const KeyInfo *pKeyInfo /* Compare size with this KeyInfo */
4117 ){
4118 int nField = 0;
4119 u32 szHdr;
4120 u32 idx;
4121 u32 notUsed;
4122 const unsigned char *aKey = (const unsigned char*)pKey;
4123
4124 if( CORRUPT_DB ) return;
4125 idx = getVarint32(aKey, szHdr);
4126 assert( nKey>=0 );
4127 assert( szHdr<=(u32)nKey );
4128 while( idx<szHdr ){
4129 idx += getVarint32(aKey+idx, notUsed);
4130 nField++;
4131 }
4132 assert( nField <= pKeyInfo->nAllField );
4133 }
4134 #else
4135 # define vdbeAssertFieldCountWithinLimits(A,B,C)
4136 #endif
4137
4138 /*
4139 ** Both *pMem1 and *pMem2 contain string values. Compare the two values
4140 ** using the collation sequence pColl. As usual, return a negative , zero
4141 ** or positive value if *pMem1 is less than, equal to or greater than
4142 ** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);".
4143 */
vdbeCompareMemString(const Mem * pMem1,const Mem * pMem2,const CollSeq * pColl,u8 * prcErr)4144 static int vdbeCompareMemString(
4145 const Mem *pMem1,
4146 const Mem *pMem2,
4147 const CollSeq *pColl,
4148 u8 *prcErr /* If an OOM occurs, set to SQLITE_NOMEM */
4149 ){
4150 if( pMem1->enc==pColl->enc ){
4151 /* The strings are already in the correct encoding. Call the
4152 ** comparison function directly */
4153 return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
4154 }else{
4155 int rc;
4156 const void *v1, *v2;
4157 Mem c1;
4158 Mem c2;
4159 sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null);
4160 sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null);
4161 sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
4162 sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
4163 v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
4164 v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
4165 if( (v1==0 || v2==0) ){
4166 if( prcErr ) *prcErr = SQLITE_NOMEM_BKPT;
4167 rc = 0;
4168 }else{
4169 rc = pColl->xCmp(pColl->pUser, c1.n, v1, c2.n, v2);
4170 }
4171 sqlite3VdbeMemRelease(&c1);
4172 sqlite3VdbeMemRelease(&c2);
4173 return rc;
4174 }
4175 }
4176
4177 /*
4178 ** The input pBlob is guaranteed to be a Blob that is not marked
4179 ** with MEM_Zero. Return true if it could be a zero-blob.
4180 */
isAllZero(const char * z,int n)4181 static int isAllZero(const char *z, int n){
4182 int i;
4183 for(i=0; i<n; i++){
4184 if( z[i] ) return 0;
4185 }
4186 return 1;
4187 }
4188
4189 /*
4190 ** Compare two blobs. Return negative, zero, or positive if the first
4191 ** is less than, equal to, or greater than the second, respectively.
4192 ** If one blob is a prefix of the other, then the shorter is the lessor.
4193 */
sqlite3BlobCompare(const Mem * pB1,const Mem * pB2)4194 SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){
4195 int c;
4196 int n1 = pB1->n;
4197 int n2 = pB2->n;
4198
4199 /* It is possible to have a Blob value that has some non-zero content
4200 ** followed by zero content. But that only comes up for Blobs formed
4201 ** by the OP_MakeRecord opcode, and such Blobs never get passed into
4202 ** sqlite3MemCompare(). */
4203 assert( (pB1->flags & MEM_Zero)==0 || n1==0 );
4204 assert( (pB2->flags & MEM_Zero)==0 || n2==0 );
4205
4206 if( (pB1->flags|pB2->flags) & MEM_Zero ){
4207 if( pB1->flags & pB2->flags & MEM_Zero ){
4208 return pB1->u.nZero - pB2->u.nZero;
4209 }else if( pB1->flags & MEM_Zero ){
4210 if( !isAllZero(pB2->z, pB2->n) ) return -1;
4211 return pB1->u.nZero - n2;
4212 }else{
4213 if( !isAllZero(pB1->z, pB1->n) ) return +1;
4214 return n1 - pB2->u.nZero;
4215 }
4216 }
4217 c = memcmp(pB1->z, pB2->z, n1>n2 ? n2 : n1);
4218 if( c ) return c;
4219 return n1 - n2;
4220 }
4221
4222 /*
4223 ** Do a comparison between a 64-bit signed integer and a 64-bit floating-point
4224 ** number. Return negative, zero, or positive if the first (i64) is less than,
4225 ** equal to, or greater than the second (double).
4226 */
sqlite3IntFloatCompare(i64 i,double r)4227 static int sqlite3IntFloatCompare(i64 i, double r){
4228 if( sizeof(LONGDOUBLE_TYPE)>8 ){
4229 LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i;
4230 if( x<r ) return -1;
4231 if( x>r ) return +1;
4232 return 0;
4233 }else{
4234 i64 y;
4235 double s;
4236 if( r<-9223372036854775808.0 ) return +1;
4237 if( r>=9223372036854775808.0 ) return -1;
4238 y = (i64)r;
4239 if( i<y ) return -1;
4240 if( i>y ) return +1;
4241 s = (double)i;
4242 if( s<r ) return -1;
4243 if( s>r ) return +1;
4244 return 0;
4245 }
4246 }
4247
4248 /*
4249 ** Compare the values contained by the two memory cells, returning
4250 ** negative, zero or positive if pMem1 is less than, equal to, or greater
4251 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
4252 ** and reals) sorted numerically, followed by text ordered by the collating
4253 ** sequence pColl and finally blob's ordered by memcmp().
4254 **
4255 ** Two NULL values are considered equal by this function.
4256 */
sqlite3MemCompare(const Mem * pMem1,const Mem * pMem2,const CollSeq * pColl)4257 int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
4258 int f1, f2;
4259 int combined_flags;
4260
4261 f1 = pMem1->flags;
4262 f2 = pMem2->flags;
4263 combined_flags = f1|f2;
4264 assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) );
4265
4266 /* If one value is NULL, it is less than the other. If both values
4267 ** are NULL, return 0.
4268 */
4269 if( combined_flags&MEM_Null ){
4270 return (f2&MEM_Null) - (f1&MEM_Null);
4271 }
4272
4273 /* At least one of the two values is a number
4274 */
4275 if( combined_flags&(MEM_Int|MEM_Real|MEM_IntReal) ){
4276 testcase( combined_flags & MEM_Int );
4277 testcase( combined_flags & MEM_Real );
4278 testcase( combined_flags & MEM_IntReal );
4279 if( (f1 & f2 & (MEM_Int|MEM_IntReal))!=0 ){
4280 testcase( f1 & f2 & MEM_Int );
4281 testcase( f1 & f2 & MEM_IntReal );
4282 if( pMem1->u.i < pMem2->u.i ) return -1;
4283 if( pMem1->u.i > pMem2->u.i ) return +1;
4284 return 0;
4285 }
4286 if( (f1 & f2 & MEM_Real)!=0 ){
4287 if( pMem1->u.r < pMem2->u.r ) return -1;
4288 if( pMem1->u.r > pMem2->u.r ) return +1;
4289 return 0;
4290 }
4291 if( (f1&(MEM_Int|MEM_IntReal))!=0 ){
4292 testcase( f1 & MEM_Int );
4293 testcase( f1 & MEM_IntReal );
4294 if( (f2&MEM_Real)!=0 ){
4295 return sqlite3IntFloatCompare(pMem1->u.i, pMem2->u.r);
4296 }else if( (f2&(MEM_Int|MEM_IntReal))!=0 ){
4297 if( pMem1->u.i < pMem2->u.i ) return -1;
4298 if( pMem1->u.i > pMem2->u.i ) return +1;
4299 return 0;
4300 }else{
4301 return -1;
4302 }
4303 }
4304 if( (f1&MEM_Real)!=0 ){
4305 if( (f2&(MEM_Int|MEM_IntReal))!=0 ){
4306 testcase( f2 & MEM_Int );
4307 testcase( f2 & MEM_IntReal );
4308 return -sqlite3IntFloatCompare(pMem2->u.i, pMem1->u.r);
4309 }else{
4310 return -1;
4311 }
4312 }
4313 return +1;
4314 }
4315
4316 /* If one value is a string and the other is a blob, the string is less.
4317 ** If both are strings, compare using the collating functions.
4318 */
4319 if( combined_flags&MEM_Str ){
4320 if( (f1 & MEM_Str)==0 ){
4321 return 1;
4322 }
4323 if( (f2 & MEM_Str)==0 ){
4324 return -1;
4325 }
4326
4327 assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed );
4328 assert( pMem1->enc==SQLITE_UTF8 ||
4329 pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
4330
4331 /* The collation sequence must be defined at this point, even if
4332 ** the user deletes the collation sequence after the vdbe program is
4333 ** compiled (this was not always the case).
4334 */
4335 assert( !pColl || pColl->xCmp );
4336
4337 if( pColl ){
4338 return vdbeCompareMemString(pMem1, pMem2, pColl, 0);
4339 }
4340 /* If a NULL pointer was passed as the collate function, fall through
4341 ** to the blob case and use memcmp(). */
4342 }
4343
4344 /* Both values must be blobs. Compare using memcmp(). */
4345 return sqlite3BlobCompare(pMem1, pMem2);
4346 }
4347
4348
4349 /*
4350 ** The first argument passed to this function is a serial-type that
4351 ** corresponds to an integer - all values between 1 and 9 inclusive
4352 ** except 7. The second points to a buffer containing an integer value
4353 ** serialized according to serial_type. This function deserializes
4354 ** and returns the value.
4355 */
vdbeRecordDecodeInt(u32 serial_type,const u8 * aKey)4356 static i64 vdbeRecordDecodeInt(u32 serial_type, const u8 *aKey){
4357 u32 y;
4358 assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) );
4359 switch( serial_type ){
4360 case 0:
4361 case 1:
4362 testcase( aKey[0]&0x80 );
4363 return ONE_BYTE_INT(aKey);
4364 case 2:
4365 testcase( aKey[0]&0x80 );
4366 return TWO_BYTE_INT(aKey);
4367 case 3:
4368 testcase( aKey[0]&0x80 );
4369 return THREE_BYTE_INT(aKey);
4370 case 4: {
4371 testcase( aKey[0]&0x80 );
4372 y = FOUR_BYTE_UINT(aKey);
4373 return (i64)*(int*)&y;
4374 }
4375 case 5: {
4376 testcase( aKey[0]&0x80 );
4377 return FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey);
4378 }
4379 case 6: {
4380 u64 x = FOUR_BYTE_UINT(aKey);
4381 testcase( aKey[0]&0x80 );
4382 x = (x<<32) | FOUR_BYTE_UINT(aKey+4);
4383 return (i64)*(i64*)&x;
4384 }
4385 }
4386
4387 return (serial_type - 8);
4388 }
4389
4390 /*
4391 ** This function compares the two table rows or index records
4392 ** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero
4393 ** or positive integer if key1 is less than, equal to or
4394 ** greater than key2. The {nKey1, pKey1} key must be a blob
4395 ** created by the OP_MakeRecord opcode of the VDBE. The pPKey2
4396 ** key must be a parsed key such as obtained from
4397 ** sqlite3VdbeParseRecord.
4398 **
4399 ** If argument bSkip is non-zero, it is assumed that the caller has already
4400 ** determined that the first fields of the keys are equal.
4401 **
4402 ** Key1 and Key2 do not have to contain the same number of fields. If all
4403 ** fields that appear in both keys are equal, then pPKey2->default_rc is
4404 ** returned.
4405 **
4406 ** If database corruption is discovered, set pPKey2->errCode to
4407 ** SQLITE_CORRUPT and return 0. If an OOM error is encountered,
4408 ** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the
4409 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
4410 */
sqlite3VdbeRecordCompareWithSkip(int nKey1,const void * pKey1,UnpackedRecord * pPKey2,int bSkip)4411 int sqlite3VdbeRecordCompareWithSkip(
4412 int nKey1, const void *pKey1, /* Left key */
4413 UnpackedRecord *pPKey2, /* Right key */
4414 int bSkip /* If true, skip the first field */
4415 ){
4416 u32 d1; /* Offset into aKey[] of next data element */
4417 int i; /* Index of next field to compare */
4418 u32 szHdr1; /* Size of record header in bytes */
4419 u32 idx1; /* Offset of first type in header */
4420 int rc = 0; /* Return value */
4421 Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */
4422 KeyInfo *pKeyInfo;
4423 const unsigned char *aKey1 = (const unsigned char *)pKey1;
4424 Mem mem1;
4425
4426 /* If bSkip is true, then the caller has already determined that the first
4427 ** two elements in the keys are equal. Fix the various stack variables so
4428 ** that this routine begins comparing at the second field. */
4429 if( bSkip ){
4430 u32 s1;
4431 idx1 = 1 + getVarint32(&aKey1[1], s1);
4432 szHdr1 = aKey1[0];
4433 d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1);
4434 i = 1;
4435 pRhs++;
4436 }else{
4437 idx1 = getVarint32(aKey1, szHdr1);
4438 d1 = szHdr1;
4439 i = 0;
4440 }
4441 if( d1>(unsigned)nKey1 ){
4442 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
4443 return 0; /* Corruption */
4444 }
4445
4446 VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */
4447 assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
4448 || CORRUPT_DB );
4449 assert( pPKey2->pKeyInfo->aSortFlags!=0 );
4450 assert( pPKey2->pKeyInfo->nKeyField>0 );
4451 assert( idx1<=szHdr1 || CORRUPT_DB );
4452 do{
4453 u32 serial_type;
4454
4455 /* RHS is an integer */
4456 if( pRhs->flags & (MEM_Int|MEM_IntReal) ){
4457 testcase( pRhs->flags & MEM_Int );
4458 testcase( pRhs->flags & MEM_IntReal );
4459 serial_type = aKey1[idx1];
4460 testcase( serial_type==12 );
4461 if( serial_type>=10 ){
4462 rc = +1;
4463 }else if( serial_type==0 ){
4464 rc = -1;
4465 }else if( serial_type==7 ){
4466 sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
4467 rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r);
4468 }else{
4469 i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]);
4470 i64 rhs = pRhs->u.i;
4471 if( lhs<rhs ){
4472 rc = -1;
4473 }else if( lhs>rhs ){
4474 rc = +1;
4475 }
4476 }
4477 }
4478
4479 /* RHS is real */
4480 else if( pRhs->flags & MEM_Real ){
4481 serial_type = aKey1[idx1];
4482 if( serial_type>=10 ){
4483 /* Serial types 12 or greater are strings and blobs (greater than
4484 ** numbers). Types 10 and 11 are currently "reserved for future
4485 ** use", so it doesn't really matter what the results of comparing
4486 ** them to numberic values are. */
4487 rc = +1;
4488 }else if( serial_type==0 ){
4489 rc = -1;
4490 }else{
4491 sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
4492 if( serial_type==7 ){
4493 if( mem1.u.r<pRhs->u.r ){
4494 rc = -1;
4495 }else if( mem1.u.r>pRhs->u.r ){
4496 rc = +1;
4497 }
4498 }else{
4499 rc = sqlite3IntFloatCompare(mem1.u.i, pRhs->u.r);
4500 }
4501 }
4502 }
4503
4504 /* RHS is a string */
4505 else if( pRhs->flags & MEM_Str ){
4506 getVarint32(&aKey1[idx1], serial_type);
4507 testcase( serial_type==12 );
4508 if( serial_type<12 ){
4509 rc = -1;
4510 }else if( !(serial_type & 0x01) ){
4511 rc = +1;
4512 }else{
4513 mem1.n = (serial_type - 12) / 2;
4514 testcase( (d1+mem1.n)==(unsigned)nKey1 );
4515 testcase( (d1+mem1.n+1)==(unsigned)nKey1 );
4516 if( (d1+mem1.n) > (unsigned)nKey1
4517 || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i
4518 ){
4519 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
4520 return 0; /* Corruption */
4521 }else if( pKeyInfo->aColl[i] ){
4522 mem1.enc = pKeyInfo->enc;
4523 mem1.db = pKeyInfo->db;
4524 mem1.flags = MEM_Str;
4525 mem1.z = (char*)&aKey1[d1];
4526 rc = vdbeCompareMemString(
4527 &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode
4528 );
4529 }else{
4530 int nCmp = MIN(mem1.n, pRhs->n);
4531 rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
4532 if( rc==0 ) rc = mem1.n - pRhs->n;
4533 }
4534 }
4535 }
4536
4537 /* RHS is a blob */
4538 else if( pRhs->flags & MEM_Blob ){
4539 assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 );
4540 getVarint32(&aKey1[idx1], serial_type);
4541 testcase( serial_type==12 );
4542 if( serial_type<12 || (serial_type & 0x01) ){
4543 rc = -1;
4544 }else{
4545 int nStr = (serial_type - 12) / 2;
4546 testcase( (d1+nStr)==(unsigned)nKey1 );
4547 testcase( (d1+nStr+1)==(unsigned)nKey1 );
4548 if( (d1+nStr) > (unsigned)nKey1 ){
4549 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
4550 return 0; /* Corruption */
4551 }else if( pRhs->flags & MEM_Zero ){
4552 if( !isAllZero((const char*)&aKey1[d1],nStr) ){
4553 rc = 1;
4554 }else{
4555 rc = nStr - pRhs->u.nZero;
4556 }
4557 }else{
4558 int nCmp = MIN(nStr, pRhs->n);
4559 rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
4560 if( rc==0 ) rc = nStr - pRhs->n;
4561 }
4562 }
4563 }
4564
4565 /* RHS is null */
4566 else{
4567 serial_type = aKey1[idx1];
4568 rc = (serial_type!=0);
4569 }
4570
4571 if( rc!=0 ){
4572 int sortFlags = pPKey2->pKeyInfo->aSortFlags[i];
4573 if( sortFlags ){
4574 if( (sortFlags & KEYINFO_ORDER_BIGNULL)==0
4575 || ((sortFlags & KEYINFO_ORDER_DESC)
4576 !=(serial_type==0 || (pRhs->flags&MEM_Null)))
4577 ){
4578 rc = -rc;
4579 }
4580 }
4581 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) );
4582 assert( mem1.szMalloc==0 ); /* See comment below */
4583 return rc;
4584 }
4585
4586 i++;
4587 if( i==pPKey2->nField ) break;
4588 pRhs++;
4589 d1 += sqlite3VdbeSerialTypeLen(serial_type);
4590 idx1 += sqlite3VarintLen(serial_type);
4591 }while( idx1<(unsigned)szHdr1 && d1<=(unsigned)nKey1 );
4592
4593 /* No memory allocation is ever used on mem1. Prove this using
4594 ** the following assert(). If the assert() fails, it indicates a
4595 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */
4596 assert( mem1.szMalloc==0 );
4597
4598 /* rc==0 here means that one or both of the keys ran out of fields and
4599 ** all the fields up to that point were equal. Return the default_rc
4600 ** value. */
4601 assert( CORRUPT_DB
4602 || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, pPKey2->default_rc)
4603 || pPKey2->pKeyInfo->db->mallocFailed
4604 );
4605 pPKey2->eqSeen = 1;
4606 return pPKey2->default_rc;
4607 }
sqlite3VdbeRecordCompare(int nKey1,const void * pKey1,UnpackedRecord * pPKey2)4608 int sqlite3VdbeRecordCompare(
4609 int nKey1, const void *pKey1, /* Left key */
4610 UnpackedRecord *pPKey2 /* Right key */
4611 ){
4612 return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 0);
4613 }
4614
4615
4616 /*
4617 ** This function is an optimized version of sqlite3VdbeRecordCompare()
4618 ** that (a) the first field of pPKey2 is an integer, and (b) the
4619 ** size-of-header varint at the start of (pKey1/nKey1) fits in a single
4620 ** byte (i.e. is less than 128).
4621 **
4622 ** To avoid concerns about buffer overreads, this routine is only used
4623 ** on schemas where the maximum valid header size is 63 bytes or less.
4624 */
vdbeRecordCompareInt(int nKey1,const void * pKey1,UnpackedRecord * pPKey2)4625 static int vdbeRecordCompareInt(
4626 int nKey1, const void *pKey1, /* Left key */
4627 UnpackedRecord *pPKey2 /* Right key */
4628 ){
4629 const u8 *aKey = &((const u8*)pKey1)[*(const u8*)pKey1 & 0x3F];
4630 int serial_type = ((const u8*)pKey1)[1];
4631 int res;
4632 u32 y;
4633 u64 x;
4634 i64 v;
4635 i64 lhs;
4636
4637 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
4638 assert( (*(u8*)pKey1)<=0x3F || CORRUPT_DB );
4639 switch( serial_type ){
4640 case 1: { /* 1-byte signed integer */
4641 lhs = ONE_BYTE_INT(aKey);
4642 testcase( lhs<0 );
4643 break;
4644 }
4645 case 2: { /* 2-byte signed integer */
4646 lhs = TWO_BYTE_INT(aKey);
4647 testcase( lhs<0 );
4648 break;
4649 }
4650 case 3: { /* 3-byte signed integer */
4651 lhs = THREE_BYTE_INT(aKey);
4652 testcase( lhs<0 );
4653 break;
4654 }
4655 case 4: { /* 4-byte signed integer */
4656 y = FOUR_BYTE_UINT(aKey);
4657 lhs = (i64)*(int*)&y;
4658 testcase( lhs<0 );
4659 break;
4660 }
4661 case 5: { /* 6-byte signed integer */
4662 lhs = FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey);
4663 testcase( lhs<0 );
4664 break;
4665 }
4666 case 6: { /* 8-byte signed integer */
4667 x = FOUR_BYTE_UINT(aKey);
4668 x = (x<<32) | FOUR_BYTE_UINT(aKey+4);
4669 lhs = *(i64*)&x;
4670 testcase( lhs<0 );
4671 break;
4672 }
4673 case 8:
4674 lhs = 0;
4675 break;
4676 case 9:
4677 lhs = 1;
4678 break;
4679
4680 /* This case could be removed without changing the results of running
4681 ** this code. Including it causes gcc to generate a faster switch
4682 ** statement (since the range of switch targets now starts at zero and
4683 ** is contiguous) but does not cause any duplicate code to be generated
4684 ** (as gcc is clever enough to combine the two like cases). Other
4685 ** compilers might be similar. */
4686 case 0: case 7:
4687 return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2);
4688
4689 default:
4690 return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2);
4691 }
4692
4693 v = pPKey2->aMem[0].u.i;
4694 if( v>lhs ){
4695 res = pPKey2->r1;
4696 }else if( v<lhs ){
4697 res = pPKey2->r2;
4698 }else if( pPKey2->nField>1 ){
4699 /* The first fields of the two keys are equal. Compare the trailing
4700 ** fields. */
4701 res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1);
4702 }else{
4703 /* The first fields of the two keys are equal and there are no trailing
4704 ** fields. Return pPKey2->default_rc in this case. */
4705 res = pPKey2->default_rc;
4706 pPKey2->eqSeen = 1;
4707 }
4708
4709 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) );
4710 return res;
4711 }
4712
4713 /*
4714 ** This function is an optimized version of sqlite3VdbeRecordCompare()
4715 ** that (a) the first field of pPKey2 is a string, that (b) the first field
4716 ** uses the collation sequence BINARY and (c) that the size-of-header varint
4717 ** at the start of (pKey1/nKey1) fits in a single byte.
4718 */
vdbeRecordCompareString(int nKey1,const void * pKey1,UnpackedRecord * pPKey2)4719 static int vdbeRecordCompareString(
4720 int nKey1, const void *pKey1, /* Left key */
4721 UnpackedRecord *pPKey2 /* Right key */
4722 ){
4723 const u8 *aKey1 = (const u8*)pKey1;
4724 int serial_type;
4725 int res;
4726
4727 assert( pPKey2->aMem[0].flags & MEM_Str );
4728 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
4729 getVarint32(&aKey1[1], serial_type);
4730 if( serial_type<12 ){
4731 res = pPKey2->r1; /* (pKey1/nKey1) is a number or a null */
4732 }else if( !(serial_type & 0x01) ){
4733 res = pPKey2->r2; /* (pKey1/nKey1) is a blob */
4734 }else{
4735 int nCmp;
4736 int nStr;
4737 int szHdr = aKey1[0];
4738
4739 nStr = (serial_type-12) / 2;
4740 if( (szHdr + nStr) > nKey1 ){
4741 pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
4742 return 0; /* Corruption */
4743 }
4744 nCmp = MIN( pPKey2->aMem[0].n, nStr );
4745 res = memcmp(&aKey1[szHdr], pPKey2->aMem[0].z, nCmp);
4746
4747 if( res>0 ){
4748 res = pPKey2->r2;
4749 }else if( res<0 ){
4750 res = pPKey2->r1;
4751 }else{
4752 res = nStr - pPKey2->aMem[0].n;
4753 if( res==0 ){
4754 if( pPKey2->nField>1 ){
4755 res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1);
4756 }else{
4757 res = pPKey2->default_rc;
4758 pPKey2->eqSeen = 1;
4759 }
4760 }else if( res>0 ){
4761 res = pPKey2->r2;
4762 }else{
4763 res = pPKey2->r1;
4764 }
4765 }
4766 }
4767
4768 assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res)
4769 || CORRUPT_DB
4770 || pPKey2->pKeyInfo->db->mallocFailed
4771 );
4772 return res;
4773 }
4774
4775 /*
4776 ** Return a pointer to an sqlite3VdbeRecordCompare() compatible function
4777 ** suitable for comparing serialized records to the unpacked record passed
4778 ** as the only argument.
4779 */
sqlite3VdbeFindCompare(UnpackedRecord * p)4780 RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){
4781 /* varintRecordCompareInt() and varintRecordCompareString() both assume
4782 ** that the size-of-header varint that occurs at the start of each record
4783 ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt()
4784 ** also assumes that it is safe to overread a buffer by at least the
4785 ** maximum possible legal header size plus 8 bytes. Because there is
4786 ** guaranteed to be at least 74 (but not 136) bytes of padding following each
4787 ** buffer passed to varintRecordCompareInt() this makes it convenient to
4788 ** limit the size of the header to 64 bytes in cases where the first field
4789 ** is an integer.
4790 **
4791 ** The easiest way to enforce this limit is to consider only records with
4792 ** 13 fields or less. If the first field is an integer, the maximum legal
4793 ** header size is (12*5 + 1 + 1) bytes. */
4794 if( p->pKeyInfo->nAllField<=13 ){
4795 int flags = p->aMem[0].flags;
4796 if( p->pKeyInfo->aSortFlags[0] ){
4797 if( p->pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL ){
4798 return sqlite3VdbeRecordCompare;
4799 }
4800 p->r1 = 1;
4801 p->r2 = -1;
4802 }else{
4803 p->r1 = -1;
4804 p->r2 = 1;
4805 }
4806 if( (flags & MEM_Int) ){
4807 return vdbeRecordCompareInt;
4808 }
4809 testcase( flags & MEM_Real );
4810 testcase( flags & MEM_Null );
4811 testcase( flags & MEM_Blob );
4812 if( (flags & (MEM_Real|MEM_IntReal|MEM_Null|MEM_Blob))==0
4813 && p->pKeyInfo->aColl[0]==0
4814 ){
4815 assert( flags & MEM_Str );
4816 return vdbeRecordCompareString;
4817 }
4818 }
4819
4820 return sqlite3VdbeRecordCompare;
4821 }
4822
4823 /*
4824 ** pCur points at an index entry created using the OP_MakeRecord opcode.
4825 ** Read the rowid (the last field in the record) and store it in *rowid.
4826 ** Return SQLITE_OK if everything works, or an error code otherwise.
4827 **
4828 ** pCur might be pointing to text obtained from a corrupt database file.
4829 ** So the content cannot be trusted. Do appropriate checks on the content.
4830 */
sqlite3VdbeIdxRowid(sqlite3 * db,BtCursor * pCur,i64 * rowid)4831 int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
4832 i64 nCellKey = 0;
4833 int rc;
4834 u32 szHdr; /* Size of the header */
4835 u32 typeRowid; /* Serial type of the rowid */
4836 u32 lenRowid; /* Size of the rowid */
4837 Mem m, v;
4838
4839 /* Get the size of the index entry. Only indices entries of less
4840 ** than 2GiB are support - anything large must be database corruption.
4841 ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so
4842 ** this code can safely assume that nCellKey is 32-bits
4843 */
4844 assert( sqlite3BtreeCursorIsValid(pCur) );
4845 nCellKey = sqlite3BtreePayloadSize(pCur);
4846 assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey );
4847
4848 /* Read in the complete content of the index entry */
4849 sqlite3VdbeMemInit(&m, db, 0);
4850 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
4851 if( rc ){
4852 return rc;
4853 }
4854
4855 /* The index entry must begin with a header size */
4856 (void)getVarint32((u8*)m.z, szHdr);
4857 testcase( szHdr==3 );
4858 testcase( szHdr==m.n );
4859 testcase( szHdr>0x7fffffff );
4860 assert( m.n>=0 );
4861 if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){
4862 goto idx_rowid_corruption;
4863 }
4864
4865 /* The last field of the index should be an integer - the ROWID.
4866 ** Verify that the last entry really is an integer. */
4867 (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid);
4868 testcase( typeRowid==1 );
4869 testcase( typeRowid==2 );
4870 testcase( typeRowid==3 );
4871 testcase( typeRowid==4 );
4872 testcase( typeRowid==5 );
4873 testcase( typeRowid==6 );
4874 testcase( typeRowid==8 );
4875 testcase( typeRowid==9 );
4876 if( unlikely(typeRowid<1 || typeRowid>9 || typeRowid==7) ){
4877 goto idx_rowid_corruption;
4878 }
4879 lenRowid = sqlite3SmallTypeSizes[typeRowid];
4880 testcase( (u32)m.n==szHdr+lenRowid );
4881 if( unlikely((u32)m.n<szHdr+lenRowid) ){
4882 goto idx_rowid_corruption;
4883 }
4884
4885 /* Fetch the integer off the end of the index record */
4886 sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
4887 *rowid = v.u.i;
4888 sqlite3VdbeMemRelease(&m);
4889 return SQLITE_OK;
4890
4891 /* Jump here if database corruption is detected after m has been
4892 ** allocated. Free the m object and return SQLITE_CORRUPT. */
4893 idx_rowid_corruption:
4894 testcase( m.szMalloc!=0 );
4895 sqlite3VdbeMemRelease(&m);
4896 return SQLITE_CORRUPT_BKPT;
4897 }
4898
4899 /*
4900 ** Compare the key of the index entry that cursor pC is pointing to against
4901 ** the key string in pUnpacked. Write into *pRes a number
4902 ** that is negative, zero, or positive if pC is less than, equal to,
4903 ** or greater than pUnpacked. Return SQLITE_OK on success.
4904 **
4905 ** pUnpacked is either created without a rowid or is truncated so that it
4906 ** omits the rowid at the end. The rowid at the end of the index entry
4907 ** is ignored as well. Hence, this routine only compares the prefixes
4908 ** of the keys prior to the final rowid, not the entire key.
4909 */
sqlite3VdbeIdxKeyCompare(sqlite3 * db,VdbeCursor * pC,UnpackedRecord * pUnpacked,int * res)4910 int sqlite3VdbeIdxKeyCompare(
4911 sqlite3 *db, /* Database connection */
4912 VdbeCursor *pC, /* The cursor to compare against */
4913 UnpackedRecord *pUnpacked, /* Unpacked version of key */
4914 int *res /* Write the comparison result here */
4915 ){
4916 i64 nCellKey = 0;
4917 int rc;
4918 BtCursor *pCur;
4919 Mem m;
4920
4921 assert( pC->eCurType==CURTYPE_BTREE );
4922 pCur = pC->uc.pCursor;
4923 assert( sqlite3BtreeCursorIsValid(pCur) );
4924 nCellKey = sqlite3BtreePayloadSize(pCur);
4925 /* nCellKey will always be between 0 and 0xffffffff because of the way
4926 ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
4927 if( nCellKey<=0 || nCellKey>0x7fffffff ){
4928 *res = 0;
4929 return SQLITE_CORRUPT_BKPT;
4930 }
4931 sqlite3VdbeMemInit(&m, db, 0);
4932 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, &m);
4933 if( rc ){
4934 return rc;
4935 }
4936 *res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, pUnpacked, 0);
4937 sqlite3VdbeMemRelease(&m);
4938 return SQLITE_OK;
4939 }
4940
4941 /*
4942 ** This routine sets the value to be returned by subsequent calls to
4943 ** sqlite3_changes() on the database handle 'db'.
4944 */
sqlite3VdbeSetChanges(sqlite3 * db,int nChange)4945 void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){
4946 assert( sqlite3_mutex_held(db->mutex) );
4947 db->nChange = nChange;
4948 db->nTotalChange += nChange;
4949 }
4950
4951 /*
4952 ** Set a flag in the vdbe to update the change counter when it is finalised
4953 ** or reset.
4954 */
sqlite3VdbeCountChanges(Vdbe * v)4955 void sqlite3VdbeCountChanges(Vdbe *v){
4956 v->changeCntOn = 1;
4957 }
4958
4959 /*
4960 ** Mark every prepared statement associated with a database connection
4961 ** as expired.
4962 **
4963 ** An expired statement means that recompilation of the statement is
4964 ** recommend. Statements expire when things happen that make their
4965 ** programs obsolete. Removing user-defined functions or collating
4966 ** sequences, or changing an authorization function are the types of
4967 ** things that make prepared statements obsolete.
4968 **
4969 ** If iCode is 1, then expiration is advisory. The statement should
4970 ** be reprepared before being restarted, but if it is already running
4971 ** it is allowed to run to completion.
4972 **
4973 ** Internally, this function just sets the Vdbe.expired flag on all
4974 ** prepared statements. The flag is set to 1 for an immediate expiration
4975 ** and set to 2 for an advisory expiration.
4976 */
sqlite3ExpirePreparedStatements(sqlite3 * db,int iCode)4977 void sqlite3ExpirePreparedStatements(sqlite3 *db, int iCode){
4978 Vdbe *p;
4979 for(p = db->pVdbe; p; p=p->pNext){
4980 p->expired = iCode+1;
4981 }
4982 }
4983
4984 /*
4985 ** Return the database associated with the Vdbe.
4986 */
sqlite3VdbeDb(Vdbe * v)4987 sqlite3 *sqlite3VdbeDb(Vdbe *v){
4988 return v->db;
4989 }
4990
4991 /*
4992 ** Return the SQLITE_PREPARE flags for a Vdbe.
4993 */
sqlite3VdbePrepareFlags(Vdbe * v)4994 u8 sqlite3VdbePrepareFlags(Vdbe *v){
4995 return v->prepFlags;
4996 }
4997
4998 /*
4999 ** Return a pointer to an sqlite3_value structure containing the value bound
5000 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
5001 ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_*
5002 ** constants) to the value before returning it.
5003 **
5004 ** The returned value must be freed by the caller using sqlite3ValueFree().
5005 */
sqlite3VdbeGetBoundValue(Vdbe * v,int iVar,u8 aff)5006 sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){
5007 assert( iVar>0 );
5008 if( v ){
5009 Mem *pMem = &v->aVar[iVar-1];
5010 assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
5011 if( 0==(pMem->flags & MEM_Null) ){
5012 sqlite3_value *pRet = sqlite3ValueNew(v->db);
5013 if( pRet ){
5014 sqlite3VdbeMemCopy((Mem *)pRet, pMem);
5015 sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8);
5016 }
5017 return pRet;
5018 }
5019 }
5020 return 0;
5021 }
5022
5023 /*
5024 ** Configure SQL variable iVar so that binding a new value to it signals
5025 ** to sqlite3_reoptimize() that re-preparing the statement may result
5026 ** in a better query plan.
5027 */
sqlite3VdbeSetVarmask(Vdbe * v,int iVar)5028 void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
5029 assert( iVar>0 );
5030 assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
5031 if( iVar>=32 ){
5032 v->expmask |= 0x80000000;
5033 }else{
5034 v->expmask |= ((u32)1 << (iVar-1));
5035 }
5036 }
5037
5038 /*
5039 ** Cause a function to throw an error if it was call from OP_PureFunc
5040 ** rather than OP_Function.
5041 **
5042 ** OP_PureFunc means that the function must be deterministic, and should
5043 ** throw an error if it is given inputs that would make it non-deterministic.
5044 ** This routine is invoked by date/time functions that use non-deterministic
5045 ** features such as 'now'.
5046 */
sqlite3NotPureFunc(sqlite3_context * pCtx)5047 int sqlite3NotPureFunc(sqlite3_context *pCtx){
5048 const VdbeOp *pOp;
5049 #ifdef SQLITE_ENABLE_STAT4
5050 if( pCtx->pVdbe==0 ) return 1;
5051 #endif
5052 pOp = pCtx->pVdbe->aOp + pCtx->iOp;
5053 if( pOp->opcode==OP_PureFunc ){
5054 const char *zContext;
5055 char *zMsg;
5056 if( pOp->p5 & NC_IsCheck ){
5057 zContext = "a CHECK constraint";
5058 }else if( pOp->p5 & NC_GenCol ){
5059 zContext = "a generated column";
5060 }else{
5061 zContext = "an index";
5062 }
5063 zMsg = sqlite3_mprintf("non-deterministic use of %s() in %s",
5064 pCtx->pFunc->zName, zContext);
5065 sqlite3_result_error(pCtx, zMsg, -1);
5066 sqlite3_free(zMsg);
5067 return 0;
5068 }
5069 return 1;
5070 }
5071
5072 #ifndef SQLITE_OMIT_VIRTUALTABLE
5073 /*
5074 ** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored
5075 ** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored
5076 ** in memory obtained from sqlite3DbMalloc).
5077 */
sqlite3VtabImportErrmsg(Vdbe * p,sqlite3_vtab * pVtab)5078 void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){
5079 if( pVtab->zErrMsg ){
5080 sqlite3 *db = p->db;
5081 sqlite3DbFree(db, p->zErrMsg);
5082 p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
5083 sqlite3_free(pVtab->zErrMsg);
5084 pVtab->zErrMsg = 0;
5085 }
5086 }
5087 #endif /* SQLITE_OMIT_VIRTUALTABLE */
5088
5089 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
5090
5091 /*
5092 ** If the second argument is not NULL, release any allocations associated
5093 ** with the memory cells in the p->aMem[] array. Also free the UnpackedRecord
5094 ** structure itself, using sqlite3DbFree().
5095 **
5096 ** This function is used to free UnpackedRecord structures allocated by
5097 ** the vdbeUnpackRecord() function found in vdbeapi.c.
5098 */
vdbeFreeUnpacked(sqlite3 * db,int nField,UnpackedRecord * p)5099 static void vdbeFreeUnpacked(sqlite3 *db, int nField, UnpackedRecord *p){
5100 if( p ){
5101 int i;
5102 for(i=0; i<nField; i++){
5103 Mem *pMem = &p->aMem[i];
5104 if( pMem->zMalloc ) sqlite3VdbeMemRelease(pMem);
5105 }
5106 sqlite3DbFreeNN(db, p);
5107 }
5108 }
5109 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
5110
5111 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
5112 /*
5113 ** Invoke the pre-update hook. If this is an UPDATE or DELETE pre-update call,
5114 ** then cursor passed as the second argument should point to the row about
5115 ** to be update or deleted. If the application calls sqlite3_preupdate_old(),
5116 ** the required value will be read from the row the cursor points to.
5117 */
sqlite3VdbePreUpdateHook(Vdbe * v,VdbeCursor * pCsr,int op,const char * zDb,Table * pTab,i64 iKey1,int iReg)5118 void sqlite3VdbePreUpdateHook(
5119 Vdbe *v, /* Vdbe pre-update hook is invoked by */
5120 VdbeCursor *pCsr, /* Cursor to grab old.* values from */
5121 int op, /* SQLITE_INSERT, UPDATE or DELETE */
5122 const char *zDb, /* Database name */
5123 Table *pTab, /* Modified table */
5124 i64 iKey1, /* Initial key value */
5125 int iReg /* Register for new.* record */
5126 ){
5127 sqlite3 *db = v->db;
5128 i64 iKey2;
5129 PreUpdate preupdate;
5130 const char *zTbl = pTab->zName;
5131 static const u8 fakeSortOrder = 0;
5132
5133 assert( db->pPreUpdate==0 );
5134 memset(&preupdate, 0, sizeof(PreUpdate));
5135 if( HasRowid(pTab)==0 ){
5136 iKey1 = iKey2 = 0;
5137 preupdate.pPk = sqlite3PrimaryKeyIndex(pTab);
5138 }else{
5139 if( op==SQLITE_UPDATE ){
5140 iKey2 = v->aMem[iReg].u.i;
5141 }else{
5142 iKey2 = iKey1;
5143 }
5144 }
5145
5146 assert( pCsr->nField==pTab->nCol
5147 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
5148 );
5149
5150 preupdate.v = v;
5151 preupdate.pCsr = pCsr;
5152 preupdate.op = op;
5153 preupdate.iNewReg = iReg;
5154 preupdate.keyinfo.db = db;
5155 preupdate.keyinfo.enc = ENC(db);
5156 preupdate.keyinfo.nKeyField = pTab->nCol;
5157 preupdate.keyinfo.aSortFlags = (u8*)&fakeSortOrder;
5158 preupdate.iKey1 = iKey1;
5159 preupdate.iKey2 = iKey2;
5160 preupdate.pTab = pTab;
5161
5162 db->pPreUpdate = &preupdate;
5163 db->xPreUpdateCallback(db->pPreUpdateArg, db, op, zDb, zTbl, iKey1, iKey2);
5164 db->pPreUpdate = 0;
5165 sqlite3DbFree(db, preupdate.aRecord);
5166 vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pUnpacked);
5167 vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pNewUnpacked);
5168 if( preupdate.aNew ){
5169 int i;
5170 for(i=0; i<pCsr->nField; i++){
5171 sqlite3VdbeMemRelease(&preupdate.aNew[i]);
5172 }
5173 sqlite3DbFreeNN(db, preupdate.aNew);
5174 }
5175 }
5176 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
5177