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