4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
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.)
15 #include "sqliteInt.h"
18 /* Forward references */
19 static void freeEphemeralFunction(sqlite3
*db
, FuncDef
*pDef
);
20 static void vdbeFreeOpArray(sqlite3
*, Op
*, int);
23 ** Create a new virtual database engine.
25 Vdbe
*sqlite3VdbeCreate(Parse
*pParse
){
26 sqlite3
*db
= pParse
->db
;
28 p
= sqlite3DbMallocRawNN(db
, sizeof(Vdbe
) );
30 memset(&p
->aOp
, 0, sizeof(Vdbe
)-offsetof(Vdbe
,aOp
));
33 db
->pVdbe
->ppVPrev
= &p
->pVNext
;
35 p
->pVNext
= db
->pVdbe
;
36 p
->ppVPrev
= &db
->pVdbe
;
38 assert( p
->eVdbeState
==VDBE_INIT_STATE
);
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);
50 ** Return the Parse object that owns a Vdbe object.
52 Parse
*sqlite3VdbeParser(Vdbe
*p
){
57 ** Change the error string stored in Vdbe.zErrMsg
59 void sqlite3VdbeError(Vdbe
*p
, const char *zFormat
, ...){
61 sqlite3DbFree(p
->db
, p
->zErrMsg
);
62 va_start(ap
, zFormat
);
63 p
->zErrMsg
= sqlite3VMPrintf(p
->db
, zFormat
, ap
);
68 ** Remember the SQL string for a prepared statement.
70 void sqlite3VdbeSetSql(Vdbe
*p
, const char *z
, int n
, u8 prepFlags
){
72 p
->prepFlags
= prepFlags
;
73 if( (prepFlags
& SQLITE_PREPARE_SAVESQL
)==0 ){
77 p
->zSql
= sqlite3DbStrNDup(p
->db
, z
, n
);
80 #ifdef SQLITE_ENABLE_NORMALIZE
82 ** Add a new element to the Vdbe->pDblStr list.
84 void sqlite3VdbeAddDblquoteStr(sqlite3
*db
, Vdbe
*p
, const char *z
){
86 int n
= sqlite3Strlen30(z
);
87 DblquoteStr
*pStr
= sqlite3DbMallocRawNN(db
,
88 sizeof(*pStr
)+n
+1-sizeof(pStr
->z
));
90 pStr
->pNextStr
= p
->pDblStr
;
92 memcpy(pStr
->z
, z
, n
+1);
98 #ifdef SQLITE_ENABLE_NORMALIZE
100 ** zId of length nId is a double-quoted identifier. Check to see if
101 ** that identifier is really used as a string literal.
103 int sqlite3VdbeUsesDoubleQuotedString(
104 Vdbe
*pVdbe
, /* The prepared statement */
105 const char *zId
/* The double-quoted identifier, already dequoted */
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;
118 ** Swap byte-code between two VDBE structures.
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
127 void sqlite3VdbeSwap(Vdbe
*pA
, Vdbe
*pB
){
128 Vdbe tmp
, *pTmp
, **ppTmp
;
130 assert( pA
->db
==pB
->db
);
135 pA
->pVNext
= pB
->pVNext
;
138 pA
->ppVPrev
= pB
->ppVPrev
;
143 #ifdef SQLITE_ENABLE_NORMALIZE
145 pA
->zNormSql
= pB
->zNormSql
;
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
]++;
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).
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).
164 static int growOpArray(Vdbe
*v
, int nOp
){
166 Parse
*p
= v
->pParse
;
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
);
179 sqlite3_int64 nNew
= (v
->nOpAlloc
? 2*(sqlite3_int64
)v
->nOpAlloc
180 : (sqlite3_int64
)(1024/sizeof(Op
)));
181 UNUSED_PARAMETER(nOp
);
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
);
190 assert( nOp
<=(int)(1024/sizeof(Op
)) );
191 assert( nNew
>=(v
->nOpAlloc
+nOp
) );
192 pNew
= sqlite3DbRealloc(p
->db
, v
->aOp
, nNew
*sizeof(Op
));
194 p
->szOpAlloc
= sqlite3DbMallocSize(p
->db
, pNew
);
195 v
->nOpAlloc
= p
->szOpAlloc
/sizeof(Op
);
198 return (pNew
? SQLITE_OK
: SQLITE_NOMEM_BKPT
);
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.
207 ** Other useful labels for breakpoints include:
208 ** test_trace_breakpoint(pc,pOp)
209 ** sqlite3CorruptError(lineno)
210 ** sqlite3MisuseError(lineno)
211 ** sqlite3CantopenError(lineno)
213 static void test_addop_breakpoint(int pc
, Op
*pOp
){
218 if( n
==LARGEST_UINT64
) abort(); /* so that n is used, preventing a warning */
223 ** Slow paths for sqlite3VdbeAddOp3() and sqlite3VdbeAddOp4Int() for the
224 ** unusual case when we need to increase the size of the Vdbe.aOp[] array
225 ** before adding the new opcode.
227 static SQLITE_NOINLINE
int growOp3(Vdbe
*p
, int op
, int p1
, int p2
, int p3
){
228 assert( p
->nOpAlloc
<=p
->nOp
);
229 if( growOpArray(p
, 1) ) return 1;
230 assert( p
->nOpAlloc
>p
->nOp
);
231 return sqlite3VdbeAddOp3(p
, op
, p1
, p2
, p3
);
233 static SQLITE_NOINLINE
int addOp4IntSlow(
234 Vdbe
*p
, /* Add the opcode to this VM */
235 int op
, /* The new opcode */
236 int p1
, /* The P1 operand */
237 int p2
, /* The P2 operand */
238 int p3
, /* The P3 operand */
239 int p4
/* The P4 operand as an integer */
241 int addr
= sqlite3VdbeAddOp3(p
, op
, p1
, p2
, p3
);
242 if( p
->db
->mallocFailed
==0 ){
243 VdbeOp
*pOp
= &p
->aOp
[addr
];
244 pOp
->p4type
= P4_INT32
;
252 ** Add a new instruction to the list of instructions current in the
253 ** VDBE. Return the address of the new instruction.
257 ** p Pointer to the VDBE
259 ** op The opcode for this instruction
261 ** p1, p2, p3, p4 Operands
263 int sqlite3VdbeAddOp0(Vdbe
*p
, int op
){
264 return sqlite3VdbeAddOp3(p
, op
, 0, 0, 0);
266 int sqlite3VdbeAddOp1(Vdbe
*p
, int op
, int p1
){
267 return sqlite3VdbeAddOp3(p
, op
, p1
, 0, 0);
269 int sqlite3VdbeAddOp2(Vdbe
*p
, int op
, int p1
, int p2
){
270 return sqlite3VdbeAddOp3(p
, op
, p1
, p2
, 0);
272 int sqlite3VdbeAddOp3(Vdbe
*p
, int op
, int p1
, int p2
, int p3
){
277 assert( p
->eVdbeState
==VDBE_INIT_STATE
);
278 assert( op
>=0 && op
<0xff );
279 if( p
->nOpAlloc
<=i
){
280 return growOp3(p
, op
, p1
, p2
, p3
);
286 pOp
->opcode
= (u8
)op
;
292 pOp
->p4type
= P4_NOTUSED
;
294 /* Replicate this logic in sqlite3VdbeAddOp4Int()
295 ** vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
296 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
299 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
304 if( p
->db
->flags
& SQLITE_VdbeAddopTrace
){
305 sqlite3VdbePrintOp(0, i
, &p
->aOp
[i
]);
306 test_addop_breakpoint(i
, &p
->aOp
[i
]);
309 #ifdef SQLITE_VDBE_COVERAGE
312 /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
313 ** Replicate in sqlite3VdbeAddOp4Int() */
317 int sqlite3VdbeAddOp4Int(
318 Vdbe
*p
, /* Add the opcode to this VM */
319 int op
, /* The new opcode */
320 int p1
, /* The P1 operand */
321 int p2
, /* The P2 operand */
322 int p3
, /* The P3 operand */
323 int p4
/* The P4 operand as an integer */
329 if( p
->nOpAlloc
<=i
){
330 return addOp4IntSlow(p
, op
, p1
, p2
, p3
, p4
);
335 pOp
->opcode
= (u8
)op
;
341 pOp
->p4type
= P4_INT32
;
343 /* Replicate this logic in sqlite3VdbeAddOp3()
344 ** vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
345 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
348 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
353 if( p
->db
->flags
& SQLITE_VdbeAddopTrace
){
354 sqlite3VdbePrintOp(0, i
, &p
->aOp
[i
]);
355 test_addop_breakpoint(i
, &p
->aOp
[i
]);
358 #ifdef SQLITE_VDBE_COVERAGE
361 /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
362 ** Replicate in sqlite3VdbeAddOp3() */
367 /* Generate code for an unconditional jump to instruction iDest
369 int sqlite3VdbeGoto(Vdbe
*p
, int iDest
){
370 return sqlite3VdbeAddOp3(p
, OP_Goto
, 0, iDest
, 0);
373 /* Generate code to cause the string zStr to be loaded into
376 int sqlite3VdbeLoadString(Vdbe
*p
, int iDest
, const char *zStr
){
377 return sqlite3VdbeAddOp4(p
, OP_String8
, 0, iDest
, 0, zStr
, 0);
381 ** Generate code that initializes multiple registers to string or integer
382 ** constants. The registers begin with iDest and increase consecutively.
383 ** One register is initialized for each characgter in zTypes[]. For each
384 ** "s" character in zTypes[], the register is a string if the argument is
385 ** not NULL, or OP_Null if the value is a null pointer. For each "i" character
386 ** in zTypes[], the register is initialized to an integer.
388 ** If the input string does not end with "X" then an OP_ResultRow instruction
389 ** is generated for the values inserted.
391 void sqlite3VdbeMultiLoad(Vdbe
*p
, int iDest
, const char *zTypes
, ...){
395 va_start(ap
, zTypes
);
396 for(i
=0; (c
= zTypes
[i
])!=0; i
++){
398 const char *z
= va_arg(ap
, const char*);
399 sqlite3VdbeAddOp4(p
, z
==0 ? OP_Null
: OP_String8
, 0, iDest
+i
, 0, z
, 0);
401 sqlite3VdbeAddOp2(p
, OP_Integer
, va_arg(ap
, int), iDest
+i
);
403 goto skip_op_resultrow
;
406 sqlite3VdbeAddOp2(p
, OP_ResultRow
, iDest
, i
);
412 ** Add an opcode that includes the p4 value as a pointer.
414 int sqlite3VdbeAddOp4(
415 Vdbe
*p
, /* Add the opcode to this VM */
416 int op
, /* The new opcode */
417 int p1
, /* The P1 operand */
418 int p2
, /* The P2 operand */
419 int p3
, /* The P3 operand */
420 const char *zP4
, /* The P4 operand */
421 int p4type
/* P4 operand type */
423 int addr
= sqlite3VdbeAddOp3(p
, op
, p1
, p2
, p3
);
424 sqlite3VdbeChangeP4(p
, addr
, zP4
, p4type
);
429 ** Add an OP_Function or OP_PureFunc opcode.
431 ** The eCallCtx argument is information (typically taken from Expr.op2)
432 ** that describes the calling context of the function. 0 means a general
433 ** function call. NC_IsCheck means called by a check constraint,
434 ** NC_IdxExpr means called as part of an index expression. NC_PartIdx
435 ** means in the WHERE clause of a partial index. NC_GenCol means called
436 ** while computing a generated column value. 0 is the usual case.
438 int sqlite3VdbeAddFunctionCall(
439 Parse
*pParse
, /* Parsing context */
440 int p1
, /* Constant argument mask */
441 int p2
, /* First argument register */
442 int p3
, /* Register into which results are written */
443 int nArg
, /* Number of argument */
444 const FuncDef
*pFunc
, /* The function to be invoked */
445 int eCallCtx
/* Calling context */
447 Vdbe
*v
= pParse
->pVdbe
;
450 sqlite3_context
*pCtx
;
452 nByte
= sizeof(*pCtx
) + (nArg
-1)*sizeof(sqlite3_value
*);
453 pCtx
= sqlite3DbMallocRawNN(pParse
->db
, nByte
);
455 assert( pParse
->db
->mallocFailed
);
456 freeEphemeralFunction(pParse
->db
, (FuncDef
*)pFunc
);
460 pCtx
->pFunc
= (FuncDef
*)pFunc
;
464 pCtx
->iOp
= sqlite3VdbeCurrentAddr(v
);
465 addr
= sqlite3VdbeAddOp4(v
, eCallCtx
? OP_PureFunc
: OP_Function
,
466 p1
, p2
, p3
, (char*)pCtx
, P4_FUNCCTX
);
467 sqlite3VdbeChangeP5(v
, eCallCtx
& NC_SelfRef
);
468 sqlite3MayAbort(pParse
);
473 ** Add an opcode that includes the p4 value with a P4_INT64 or
476 int sqlite3VdbeAddOp4Dup8(
477 Vdbe
*p
, /* Add the opcode to this VM */
478 int op
, /* The new opcode */
479 int p1
, /* The P1 operand */
480 int p2
, /* The P2 operand */
481 int p3
, /* The P3 operand */
482 const u8
*zP4
, /* The P4 operand */
483 int p4type
/* P4 operand type */
485 char *p4copy
= sqlite3DbMallocRawNN(sqlite3VdbeDb(p
), 8);
486 if( p4copy
) memcpy(p4copy
, zP4
, 8);
487 return sqlite3VdbeAddOp4(p
, op
, p1
, p2
, p3
, p4copy
, p4type
);
490 #ifndef SQLITE_OMIT_EXPLAIN
492 ** Return the address of the current EXPLAIN QUERY PLAN baseline.
495 int sqlite3VdbeExplainParent(Parse
*pParse
){
497 if( pParse
->addrExplain
==0 ) return 0;
498 pOp
= sqlite3VdbeGetOp(pParse
->pVdbe
, pParse
->addrExplain
);
503 ** Set a debugger breakpoint on the following routine in order to
504 ** monitor the EXPLAIN QUERY PLAN code generation.
506 #if defined(SQLITE_DEBUG)
507 void sqlite3ExplainBreakpoint(const char *z1
, const char *z2
){
514 ** Add a new OP_Explain opcode.
516 ** If the bPush flag is true, then make this opcode the parent for
517 ** subsequent Explains until sqlite3VdbeExplainPop() is called.
519 int sqlite3VdbeExplain(Parse
*pParse
, u8 bPush
, const char *zFmt
, ...){
521 #if !defined(SQLITE_DEBUG)
522 /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined.
523 ** But omit them (for performance) during production builds */
524 if( pParse
->explain
==2 || IS_STMT_SCANSTATUS(pParse
->db
) )
532 zMsg
= sqlite3VMPrintf(pParse
->db
, zFmt
, ap
);
536 addr
= sqlite3VdbeAddOp4(v
, OP_Explain
, iThis
, pParse
->addrExplain
, 0,
538 sqlite3ExplainBreakpoint(bPush
?"PUSH":"", sqlite3VdbeGetLastOp(v
)->p4
.z
);
540 pParse
->addrExplain
= iThis
;
542 sqlite3VdbeScanStatus(v
, iThis
, -1, -1, 0, 0);
548 ** Pop the EXPLAIN QUERY PLAN stack one level.
550 void sqlite3VdbeExplainPop(Parse
*pParse
){
551 sqlite3ExplainBreakpoint("POP", 0);
552 pParse
->addrExplain
= sqlite3VdbeExplainParent(pParse
);
554 #endif /* SQLITE_OMIT_EXPLAIN */
557 ** Add an OP_ParseSchema opcode. This routine is broken out from
558 ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
559 ** as having been used.
561 ** The zWhere string must have been obtained from sqlite3_malloc().
562 ** This routine will take ownership of the allocated memory.
564 void sqlite3VdbeAddParseSchemaOp(Vdbe
*p
, int iDb
, char *zWhere
, u16 p5
){
566 sqlite3VdbeAddOp4(p
, OP_ParseSchema
, iDb
, 0, 0, zWhere
, P4_DYNAMIC
);
567 sqlite3VdbeChangeP5(p
, p5
);
568 for(j
=0; j
<p
->db
->nDb
; j
++) sqlite3VdbeUsesBtree(p
, j
);
569 sqlite3MayAbort(p
->pParse
);
572 /* Insert the end of a co-routine
574 void sqlite3VdbeEndCoroutine(Vdbe
*v
, int regYield
){
575 sqlite3VdbeAddOp1(v
, OP_EndCoroutine
, regYield
);
577 /* Clear the temporary register cache, thereby ensuring that each
578 ** co-routine has its own independent set of registers, because co-routines
579 ** might expect their registers to be preserved across an OP_Yield, and
580 ** that could cause problems if two or more co-routines are using the same
581 ** temporary register.
583 v
->pParse
->nTempReg
= 0;
584 v
->pParse
->nRangeReg
= 0;
588 ** Create a new symbolic label for an instruction that has yet to be
589 ** coded. The symbolic label is really just a negative number. The
590 ** label can be used as the P2 value of an operation. Later, when
591 ** the label is resolved to a specific address, the VDBE will scan
592 ** through its operation list and change all values of P2 which match
593 ** the label into the resolved address.
595 ** The VDBE knows that a P2 value is a label because labels are
596 ** always negative and P2 values are suppose to be non-negative.
597 ** Hence, a negative P2 value is a label that has yet to be resolved.
598 ** (Later:) This is only true for opcodes that have the OPFLG_JUMP
601 ** Variable usage notes:
603 ** Parse.aLabel[x] Stores the address that the x-th label resolves
604 ** into. For testing (SQLITE_DEBUG), unresolved
605 ** labels stores -1, but that is not required.
606 ** Parse.nLabelAlloc Number of slots allocated to Parse.aLabel[]
607 ** Parse.nLabel The *negative* of the number of labels that have
608 ** been issued. The negative is stored because
609 ** that gives a performance improvement over storing
610 ** the equivalent positive value.
612 int sqlite3VdbeMakeLabel(Parse
*pParse
){
613 return --pParse
->nLabel
;
617 ** Resolve label "x" to be the address of the next instruction to
618 ** be inserted. The parameter "x" must have been obtained from
619 ** a prior call to sqlite3VdbeMakeLabel().
621 static SQLITE_NOINLINE
void resizeResolveLabel(Parse
*p
, Vdbe
*v
, int j
){
622 int nNewSize
= 10 - p
->nLabel
;
623 p
->aLabel
= sqlite3DbReallocOrFree(p
->db
, p
->aLabel
,
624 nNewSize
*sizeof(p
->aLabel
[0]));
630 for(i
=p
->nLabelAlloc
; i
<nNewSize
; i
++) p
->aLabel
[i
] = -1;
632 if( nNewSize
>=100 && (nNewSize
/100)>(p
->nLabelAlloc
/100) ){
633 sqlite3ProgressCheck(p
);
635 p
->nLabelAlloc
= nNewSize
;
636 p
->aLabel
[j
] = v
->nOp
;
639 void sqlite3VdbeResolveLabel(Vdbe
*v
, int x
){
640 Parse
*p
= v
->pParse
;
642 assert( v
->eVdbeState
==VDBE_INIT_STATE
);
643 assert( j
<-p
->nLabel
);
646 if( p
->db
->flags
& SQLITE_VdbeAddopTrace
){
647 printf("RESOLVE LABEL %d to %d\n", x
, v
->nOp
);
650 if( p
->nLabelAlloc
+ p
->nLabel
< 0 ){
651 resizeResolveLabel(p
,v
,j
);
653 assert( p
->aLabel
[j
]==(-1) ); /* Labels may only be resolved once */
654 p
->aLabel
[j
] = v
->nOp
;
659 ** Mark the VDBE as one that can only be run one time.
661 void sqlite3VdbeRunOnlyOnce(Vdbe
*p
){
662 sqlite3VdbeAddOp2(p
, OP_Expire
, 1, 1);
666 ** Mark the VDBE as one that can be run multiple times.
668 void sqlite3VdbeReusable(Vdbe
*p
){
670 for(i
=1; ALWAYS(i
<p
->nOp
); i
++){
671 if( ALWAYS(p
->aOp
[i
].opcode
==OP_Expire
) ){
672 p
->aOp
[1].opcode
= OP_Noop
;
678 #ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */
681 ** The following type and function are used to iterate through all opcodes
682 ** in a Vdbe main program and each of the sub-programs (triggers) it may
683 ** invoke directly or indirectly. It should be used as follows:
688 ** memset(&sIter, 0, sizeof(sIter));
689 ** sIter.v = v; // v is of type Vdbe*
690 ** while( (pOp = opIterNext(&sIter)) ){
691 ** // Do something with pOp
693 ** sqlite3DbFree(v->db, sIter.apSub);
696 typedef struct VdbeOpIter VdbeOpIter
;
698 Vdbe
*v
; /* Vdbe to iterate through the opcodes of */
699 SubProgram
**apSub
; /* Array of subprograms */
700 int nSub
; /* Number of entries in apSub */
701 int iAddr
; /* Address of next instruction to return */
702 int iSub
; /* 0 = main program, 1 = first sub-program etc. */
704 static Op
*opIterNext(VdbeOpIter
*p
){
710 if( p
->iSub
<=p
->nSub
){
716 aOp
= p
->apSub
[p
->iSub
-1]->aOp
;
717 nOp
= p
->apSub
[p
->iSub
-1]->nOp
;
719 assert( p
->iAddr
<nOp
);
721 pRet
= &aOp
[p
->iAddr
];
728 if( pRet
->p4type
==P4_SUBPROGRAM
){
729 int nByte
= (p
->nSub
+1)*sizeof(SubProgram
*);
731 for(j
=0; j
<p
->nSub
; j
++){
732 if( p
->apSub
[j
]==pRet
->p4
.pProgram
) break;
735 p
->apSub
= sqlite3DbReallocOrFree(v
->db
, p
->apSub
, nByte
);
739 p
->apSub
[p
->nSub
++] = pRet
->p4
.pProgram
;
749 ** Check if the program stored in the VM associated with pParse may
750 ** throw an ABORT exception (causing the statement, but not entire transaction
751 ** to be rolled back). This condition is true if the main program or any
752 ** sub-programs contains any of the following:
754 ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
755 ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
760 ** * OP_FkCounter with P2==0 (immediate foreign key constraint)
761 ** * OP_CreateBtree/BTREE_INTKEY and OP_InitCoroutine
762 ** (for CREATE TABLE AS SELECT ...)
764 ** Then check that the value of Parse.mayAbort is true if an
765 ** ABORT may be thrown, or false otherwise. Return true if it does
766 ** match, or false otherwise. This function is intended to be used as
767 ** part of an assert statement in the compiler. Similar to:
769 ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
771 int sqlite3VdbeAssertMayAbort(Vdbe
*v
, int mayAbort
){
773 int hasFkCounter
= 0;
774 int hasCreateTable
= 0;
775 int hasCreateIndex
= 0;
776 int hasInitCoroutine
= 0;
781 memset(&sIter
, 0, sizeof(sIter
));
784 while( (pOp
= opIterNext(&sIter
))!=0 ){
785 int opcode
= pOp
->opcode
;
786 if( opcode
==OP_Destroy
|| opcode
==OP_VUpdate
|| opcode
==OP_VRename
787 || opcode
==OP_VDestroy
788 || opcode
==OP_VCreate
789 || opcode
==OP_ParseSchema
790 || opcode
==OP_Function
|| opcode
==OP_PureFunc
791 || ((opcode
==OP_Halt
|| opcode
==OP_HaltIfNull
)
792 && ((pOp
->p1
)!=SQLITE_OK
&& pOp
->p2
==OE_Abort
))
797 if( opcode
==OP_CreateBtree
&& pOp
->p3
==BTREE_INTKEY
) hasCreateTable
= 1;
799 /* hasCreateIndex may also be set for some DELETE statements that use
800 ** OP_Clear. So this routine may end up returning true in the case
801 ** where a "DELETE FROM tbl" has a statement-journal but does not
802 ** require one. This is not so bad - it is an inefficiency, not a bug. */
803 if( opcode
==OP_CreateBtree
&& pOp
->p3
==BTREE_BLOBKEY
) hasCreateIndex
= 1;
804 if( opcode
==OP_Clear
) hasCreateIndex
= 1;
806 if( opcode
==OP_InitCoroutine
) hasInitCoroutine
= 1;
807 #ifndef SQLITE_OMIT_FOREIGN_KEY
808 if( opcode
==OP_FkCounter
&& pOp
->p1
==0 && pOp
->p2
==1 ){
813 sqlite3DbFree(v
->db
, sIter
.apSub
);
815 /* Return true if hasAbort==mayAbort. Or if a malloc failure occurred.
816 ** If malloc failed, then the while() loop above may not have iterated
817 ** through all opcodes and hasAbort may be set incorrectly. Return
818 ** true for this case to prevent the assert() in the callers frame
820 return ( v
->db
->mallocFailed
|| hasAbort
==mayAbort
|| hasFkCounter
821 || (hasCreateTable
&& hasInitCoroutine
) || hasCreateIndex
824 #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */
828 ** Increment the nWrite counter in the VDBE if the cursor is not an
829 ** ephemeral cursor, or if the cursor argument is NULL.
831 void sqlite3VdbeIncrWriteCounter(Vdbe
*p
, VdbeCursor
*pC
){
833 || (pC
->eCurType
!=CURTYPE_SORTER
834 && pC
->eCurType
!=CURTYPE_PSEUDO
844 ** Assert if an Abort at this point in time might result in a corrupt
847 void sqlite3VdbeAssertAbortable(Vdbe
*p
){
848 assert( p
->nWrite
==0 || p
->usesStmtJournal
);
853 ** This routine is called after all opcodes have been inserted. It loops
854 ** through all the opcodes and fixes up some details.
856 ** (1) For each jump instruction with a negative P2 value (a label)
857 ** resolve the P2 value to an actual address.
859 ** (2) Compute the maximum number of arguments used by any SQL function
860 ** and store that value in *pMaxFuncArgs.
862 ** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately
863 ** indicate what the prepared statement actually does.
865 ** (4) (discontinued)
867 ** (5) Reclaim the memory allocated for storing labels.
869 ** This routine will only function correctly if the mkopcodeh.tcl generator
870 ** script numbers the opcodes correctly. Changes to this routine must be
871 ** coordinated with changes to mkopcodeh.tcl.
873 static void resolveP2Values(Vdbe
*p
, int *pMaxFuncArgs
){
874 int nMaxArgs
= *pMaxFuncArgs
;
876 Parse
*pParse
= p
->pParse
;
877 int *aLabel
= pParse
->aLabel
;
879 assert( pParse
->db
->mallocFailed
==0 ); /* tag-20230419-1 */
882 pOp
= &p
->aOp
[p
->nOp
-1];
883 assert( p
->aOp
[0].opcode
==OP_Init
);
884 while( 1 /* Loop terminates when it reaches the OP_Init opcode */ ){
885 /* Only JUMP opcodes and the short list of special opcodes in the switch
886 ** below need to be considered. The mkopcodeh.tcl generator script groups
887 ** all these opcodes together near the front of the opcode list. Skip
888 ** any opcode that does not need processing by virtual of the fact that
889 ** it is larger than SQLITE_MX_JUMP_OPCODE, as a performance optimization.
891 if( pOp
->opcode
<=SQLITE_MX_JUMP_OPCODE
){
892 /* NOTE: Be sure to update mkopcodeh.tcl when adding or removing
893 ** cases from this switch! */
894 switch( pOp
->opcode
){
895 case OP_Transaction
: {
896 if( pOp
->p2
!=0 ) p
->readOnly
= 0;
897 /* no break */ deliberate_fall_through
904 #ifndef SQLITE_OMIT_WAL
908 case OP_JournalMode
: {
914 assert( pOp
->p2
>=0 );
915 goto resolve_p2_values_loop_exit
;
917 #ifndef SQLITE_OMIT_VIRTUALTABLE
919 if( pOp
->p2
>nMaxArgs
) nMaxArgs
= pOp
->p2
;
924 assert( (pOp
- p
->aOp
) >= 3 );
925 assert( pOp
[-1].opcode
==OP_Integer
);
927 if( n
>nMaxArgs
) nMaxArgs
= n
;
928 /* Fall through into the default case */
929 /* no break */ deliberate_fall_through
934 /* The mkopcodeh.tcl script has so arranged things that the only
935 ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
936 ** have non-negative values for P2. */
937 assert( (sqlite3OpcodeProperty
[pOp
->opcode
] & OPFLG_JUMP
)!=0 );
938 assert( ADDR(pOp
->p2
)<-pParse
->nLabel
);
939 assert( aLabel
!=0 ); /* True because of tag-20230419-1 */
940 pOp
->p2
= aLabel
[ADDR(pOp
->p2
)];
943 /* OPFLG_JUMP opcodes never have P2==0, though OPFLG_JUMP0 opcodes
946 || (sqlite3OpcodeProperty
[pOp
->opcode
] & OPFLG_JUMP0
)!=0 );
948 /* Jumps never go off the end of the bytecode array */
949 assert( pOp
->p2
<p
->nOp
950 || (sqlite3OpcodeProperty
[pOp
->opcode
] & OPFLG_JUMP
)==0 );
954 /* The mkopcodeh.tcl script has so arranged things that the only
955 ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
956 ** have non-negative values for P2. */
957 assert( (sqlite3OpcodeProperty
[pOp
->opcode
]&OPFLG_JUMP
)==0 || pOp
->p2
>=0);
959 assert( pOp
>p
->aOp
);
962 resolve_p2_values_loop_exit
:
964 sqlite3DbNNFreeNN(p
->db
, pParse
->aLabel
);
968 *pMaxFuncArgs
= nMaxArgs
;
969 assert( p
->bIsReader
!=0 || DbMaskAllZero(p
->btreeMask
) );
974 ** Check to see if a subroutine contains a jump to a location outside of
975 ** the subroutine. If a jump outside the subroutine is detected, add code
976 ** that will cause the program to halt with an error message.
978 ** The subroutine consists of opcodes between iFirst and iLast. Jumps to
979 ** locations within the subroutine are acceptable. iRetReg is a register
980 ** that contains the return address. Jumps to outside the range of iFirst
981 ** through iLast are also acceptable as long as the jump destination is
982 ** an OP_Return to iReturnAddr.
984 ** A jump to an unresolved label means that the jump destination will be
985 ** beyond the current address. That is normally a jump to an early
986 ** termination and is consider acceptable.
988 ** This routine only runs during debug builds. The purpose is (of course)
989 ** to detect invalid escapes out of a subroutine. The OP_Halt opcode
990 ** is generated rather than an assert() or other error, so that ".eqp full"
991 ** will still work to show the original bytecode, to aid in debugging.
993 void sqlite3VdbeNoJumpsOutsideSubrtn(
994 Vdbe
*v
, /* The byte-code program under construction */
995 int iFirst
, /* First opcode of the subroutine */
996 int iLast
, /* Last opcode of the subroutine */
997 int iRetReg
/* Subroutine return address register */
1002 sqlite3_str
*pErr
= 0;
1005 assert( pParse
!=0 );
1006 if( pParse
->nErr
) return;
1007 assert( iLast
>=iFirst
);
1008 assert( iLast
<v
->nOp
);
1009 pOp
= &v
->aOp
[iFirst
];
1010 for(i
=iFirst
; i
<=iLast
; i
++, pOp
++){
1011 if( (sqlite3OpcodeProperty
[pOp
->opcode
] & OPFLG_JUMP
)!=0 ){
1012 int iDest
= pOp
->p2
; /* Jump destination */
1013 if( iDest
==0 ) continue;
1014 if( pOp
->opcode
==OP_Gosub
) continue;
1015 if( pOp
->p3
==20230325 && pOp
->opcode
==OP_NotNull
){
1016 /* This is a deliberately taken illegal branch. tag-20230325-2 */
1020 int j
= ADDR(iDest
);
1022 if( j
>=-pParse
->nLabel
|| pParse
->aLabel
[j
]<0 ){
1025 iDest
= pParse
->aLabel
[j
];
1027 if( iDest
<iFirst
|| iDest
>iLast
){
1029 for(; j
<v
->nOp
; j
++){
1030 VdbeOp
*pX
= &v
->aOp
[j
];
1031 if( pX
->opcode
==OP_Return
){
1032 if( pX
->p1
==iRetReg
) break;
1035 if( pX
->opcode
==OP_Noop
) continue;
1036 if( pX
->opcode
==OP_Explain
) continue;
1038 pErr
= sqlite3_str_new(0);
1040 sqlite3_str_appendchar(pErr
, 1, '\n');
1042 sqlite3_str_appendf(pErr
,
1043 "Opcode at %d jumps to %d which is outside the "
1044 "subroutine at %d..%d",
1045 i
, iDest
, iFirst
, iLast
);
1052 char *zErr
= sqlite3_str_finish(pErr
);
1053 sqlite3VdbeAddOp4(v
, OP_Halt
, SQLITE_INTERNAL
, OE_Abort
, 0, zErr
, 0);
1055 sqlite3MayAbort(pParse
);
1058 #endif /* SQLITE_DEBUG */
1061 ** Return the address of the next instruction to be inserted.
1063 int sqlite3VdbeCurrentAddr(Vdbe
*p
){
1064 assert( p
->eVdbeState
==VDBE_INIT_STATE
);
1069 ** Verify that at least N opcode slots are available in p without
1070 ** having to malloc for more space (except when compiled using
1071 ** SQLITE_TEST_REALLOC_STRESS). This interface is used during testing
1072 ** to verify that certain calls to sqlite3VdbeAddOpList() can never
1073 ** fail due to a OOM fault and hence that the return value from
1074 ** sqlite3VdbeAddOpList() will always be non-NULL.
1076 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
1077 void sqlite3VdbeVerifyNoMallocRequired(Vdbe
*p
, int N
){
1078 assert( p
->nOp
+ N
<= p
->nOpAlloc
);
1083 ** Verify that the VM passed as the only argument does not contain
1084 ** an OP_ResultRow opcode. Fail an assert() if it does. This is used
1085 ** by code in pragma.c to ensure that the implementation of certain
1086 ** pragmas comports with the flags specified in the mkpragmatab.tcl
1089 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
1090 void sqlite3VdbeVerifyNoResultRow(Vdbe
*p
){
1092 for(i
=0; i
<p
->nOp
; i
++){
1093 assert( p
->aOp
[i
].opcode
!=OP_ResultRow
);
1099 ** Generate code (a single OP_Abortable opcode) that will
1100 ** verify that the VDBE program can safely call Abort in the current
1103 #if defined(SQLITE_DEBUG)
1104 void sqlite3VdbeVerifyAbortable(Vdbe
*p
, int onError
){
1105 if( onError
==OE_Abort
) sqlite3VdbeAddOp0(p
, OP_Abortable
);
1110 ** This function returns a pointer to the array of opcodes associated with
1111 ** the Vdbe passed as the first argument. It is the callers responsibility
1112 ** to arrange for the returned array to be eventually freed using the
1113 ** vdbeFreeOpArray() function.
1115 ** Before returning, *pnOp is set to the number of entries in the returned
1116 ** array. Also, *pnMaxArg is set to the larger of its current value and
1117 ** the number of entries in the Vdbe.apArg[] array required to execute the
1118 ** returned program.
1120 VdbeOp
*sqlite3VdbeTakeOpArray(Vdbe
*p
, int *pnOp
, int *pnMaxArg
){
1121 VdbeOp
*aOp
= p
->aOp
;
1122 assert( aOp
&& !p
->db
->mallocFailed
);
1124 /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
1125 assert( DbMaskAllZero(p
->btreeMask
) );
1127 resolveP2Values(p
, pnMaxArg
);
1134 ** Add a whole list of operations to the operation stack. Return a
1135 ** pointer to the first operation inserted.
1137 ** Non-zero P2 arguments to jump instructions are automatically adjusted
1138 ** so that the jump target is relative to the first operation inserted.
1140 VdbeOp
*sqlite3VdbeAddOpList(
1141 Vdbe
*p
, /* Add opcodes to the prepared statement */
1142 int nOp
, /* Number of opcodes to add */
1143 VdbeOpList
const *aOp
, /* The opcodes to be added */
1144 int iLineno
/* Source-file line number of first opcode */
1147 VdbeOp
*pOut
, *pFirst
;
1149 assert( p
->eVdbeState
==VDBE_INIT_STATE
);
1150 if( p
->nOp
+ nOp
> p
->nOpAlloc
&& growOpArray(p
, nOp
) ){
1153 pFirst
= pOut
= &p
->aOp
[p
->nOp
];
1154 for(i
=0; i
<nOp
; i
++, aOp
++, pOut
++){
1155 pOut
->opcode
= aOp
->opcode
;
1158 assert( aOp
->p2
>=0 );
1159 if( (sqlite3OpcodeProperty
[aOp
->opcode
] & OPFLG_JUMP
)!=0 && aOp
->p2
>0 ){
1163 pOut
->p4type
= P4_NOTUSED
;
1166 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1169 #ifdef SQLITE_VDBE_COVERAGE
1170 pOut
->iSrcLine
= iLineno
+i
;
1175 if( p
->db
->flags
& SQLITE_VdbeAddopTrace
){
1176 sqlite3VdbePrintOp(0, i
+p
->nOp
, &p
->aOp
[i
+p
->nOp
]);
1184 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS)
1186 ** Add an entry to the array of counters managed by sqlite3_stmt_scanstatus().
1188 void sqlite3VdbeScanStatus(
1189 Vdbe
*p
, /* VM to add scanstatus() to */
1190 int addrExplain
, /* Address of OP_Explain (or 0) */
1191 int addrLoop
, /* Address of loop counter */
1192 int addrVisit
, /* Address of rows visited counter */
1193 LogEst nEst
, /* Estimated number of output rows */
1194 const char *zName
/* Name of table or index being scanned */
1196 if( IS_STMT_SCANSTATUS(p
->db
) ){
1197 sqlite3_int64 nByte
= (p
->nScan
+1) * sizeof(ScanStatus
);
1199 aNew
= (ScanStatus
*)sqlite3DbRealloc(p
->db
, p
->aScan
, nByte
);
1201 ScanStatus
*pNew
= &aNew
[p
->nScan
++];
1202 memset(pNew
, 0, sizeof(ScanStatus
));
1203 pNew
->addrExplain
= addrExplain
;
1204 pNew
->addrLoop
= addrLoop
;
1205 pNew
->addrVisit
= addrVisit
;
1207 pNew
->zName
= sqlite3DbStrDup(p
->db
, zName
);
1214 ** Add the range of instructions from addrStart to addrEnd (inclusive) to
1215 ** the set of those corresponding to the sqlite3_stmt_scanstatus() counters
1216 ** associated with the OP_Explain instruction at addrExplain. The
1217 ** sum of the sqlite3Hwtime() values for each of these instructions
1218 ** will be returned for SQLITE_SCANSTAT_NCYCLE requests.
1220 void sqlite3VdbeScanStatusRange(
1226 if( IS_STMT_SCANSTATUS(p
->db
) ){
1227 ScanStatus
*pScan
= 0;
1229 for(ii
=p
->nScan
-1; ii
>=0; ii
--){
1230 pScan
= &p
->aScan
[ii
];
1231 if( pScan
->addrExplain
==addrExplain
) break;
1235 if( addrEnd
<0 ) addrEnd
= sqlite3VdbeCurrentAddr(p
)-1;
1236 for(ii
=0; ii
<ArraySize(pScan
->aAddrRange
); ii
+=2){
1237 if( pScan
->aAddrRange
[ii
]==0 ){
1238 pScan
->aAddrRange
[ii
] = addrStart
;
1239 pScan
->aAddrRange
[ii
+1] = addrEnd
;
1248 ** Set the addresses for the SQLITE_SCANSTAT_NLOOP and SQLITE_SCANSTAT_NROW
1249 ** counters for the query element associated with the OP_Explain at
1252 void sqlite3VdbeScanStatusCounters(
1258 if( IS_STMT_SCANSTATUS(p
->db
) ){
1259 ScanStatus
*pScan
= 0;
1261 for(ii
=p
->nScan
-1; ii
>=0; ii
--){
1262 pScan
= &p
->aScan
[ii
];
1263 if( pScan
->addrExplain
==addrExplain
) break;
1267 if( addrLoop
>0 ) pScan
->addrLoop
= addrLoop
;
1268 if( addrVisit
>0 ) pScan
->addrVisit
= addrVisit
;
1272 #endif /* defined(SQLITE_ENABLE_STMT_SCANSTATUS) */
1276 ** Change the value of the opcode, or P1, P2, P3, or P5 operands
1277 ** for a specific instruction.
1279 void sqlite3VdbeChangeOpcode(Vdbe
*p
, int addr
, u8 iNewOpcode
){
1281 sqlite3VdbeGetOp(p
,addr
)->opcode
= iNewOpcode
;
1283 void sqlite3VdbeChangeP1(Vdbe
*p
, int addr
, int val
){
1285 sqlite3VdbeGetOp(p
,addr
)->p1
= val
;
1287 void sqlite3VdbeChangeP2(Vdbe
*p
, int addr
, int val
){
1288 assert( addr
>=0 || p
->db
->mallocFailed
);
1289 sqlite3VdbeGetOp(p
,addr
)->p2
= val
;
1291 void sqlite3VdbeChangeP3(Vdbe
*p
, int addr
, int val
){
1293 sqlite3VdbeGetOp(p
,addr
)->p3
= val
;
1295 void sqlite3VdbeChangeP5(Vdbe
*p
, u16 p5
){
1296 assert( p
->nOp
>0 || p
->db
->mallocFailed
);
1297 if( p
->nOp
>0 ) p
->aOp
[p
->nOp
-1].p5
= p5
;
1301 ** If the previous opcode is an OP_Column that delivers results
1302 ** into register iDest, then add the OPFLAG_TYPEOFARG flag to that
1305 void sqlite3VdbeTypeofColumn(Vdbe
*p
, int iDest
){
1306 VdbeOp
*pOp
= sqlite3VdbeGetLastOp(p
);
1307 if( pOp
->p3
==iDest
&& pOp
->opcode
==OP_Column
){
1308 pOp
->p5
|= OPFLAG_TYPEOFARG
;
1313 ** Change the P2 operand of instruction addr so that it points to
1314 ** the address of the next instruction to be coded.
1316 void sqlite3VdbeJumpHere(Vdbe
*p
, int addr
){
1317 sqlite3VdbeChangeP2(p
, addr
, p
->nOp
);
1321 ** Change the P2 operand of the jump instruction at addr so that
1322 ** the jump lands on the next opcode. Or if the jump instruction was
1323 ** the previous opcode (and is thus a no-op) then simply back up
1324 ** the next instruction counter by one slot so that the jump is
1325 ** overwritten by the next inserted opcode.
1327 ** This routine is an optimization of sqlite3VdbeJumpHere() that
1328 ** strives to omit useless byte-code like this:
1333 void sqlite3VdbeJumpHereOrPopInst(Vdbe
*p
, int addr
){
1334 if( addr
==p
->nOp
-1 ){
1335 assert( p
->aOp
[addr
].opcode
==OP_Once
1336 || p
->aOp
[addr
].opcode
==OP_If
1337 || p
->aOp
[addr
].opcode
==OP_FkIfZero
);
1338 assert( p
->aOp
[addr
].p4type
==0 );
1339 #ifdef SQLITE_VDBE_COVERAGE
1340 sqlite3VdbeGetLastOp(p
)->iSrcLine
= 0; /* Erase VdbeCoverage() macros */
1344 sqlite3VdbeChangeP2(p
, addr
, p
->nOp
);
1350 ** If the input FuncDef structure is ephemeral, then free it. If
1351 ** the FuncDef is not ephemeral, then do nothing.
1353 static void freeEphemeralFunction(sqlite3
*db
, FuncDef
*pDef
){
1355 if( (pDef
->funcFlags
& SQLITE_FUNC_EPHEM
)!=0 ){
1356 sqlite3DbNNFreeNN(db
, pDef
);
1361 ** Delete a P4 value if necessary.
1363 static SQLITE_NOINLINE
void freeP4Mem(sqlite3
*db
, Mem
*p
){
1364 if( p
->szMalloc
) sqlite3DbFree(db
, p
->zMalloc
);
1365 sqlite3DbNNFreeNN(db
, p
);
1367 static SQLITE_NOINLINE
void freeP4FuncCtx(sqlite3
*db
, sqlite3_context
*p
){
1369 freeEphemeralFunction(db
, p
->pFunc
);
1370 sqlite3DbNNFreeNN(db
, p
);
1372 static void freeP4(sqlite3
*db
, int p4type
, void *p4
){
1376 freeP4FuncCtx(db
, (sqlite3_context
*)p4
);
1383 if( p4
) sqlite3DbNNFreeNN(db
, p4
);
1387 if( db
->pnBytesFreed
==0 ) sqlite3KeyInfoUnref((KeyInfo
*)p4
);
1390 #ifdef SQLITE_ENABLE_CURSOR_HINTS
1392 sqlite3ExprDelete(db
, (Expr
*)p4
);
1397 freeEphemeralFunction(db
, (FuncDef
*)p4
);
1401 if( db
->pnBytesFreed
==0 ){
1402 sqlite3ValueFree((sqlite3_value
*)p4
);
1404 freeP4Mem(db
, (Mem
*)p4
);
1409 if( db
->pnBytesFreed
==0 ) sqlite3VtabUnlock((VTable
*)p4
);
1413 if( db
->pnBytesFreed
==0 ) sqlite3DeleteTable(db
, (Table
*)p4
);
1416 case P4_SUBRTNSIG
: {
1417 SubrtnSig
*pSig
= (SubrtnSig
*)p4
;
1418 sqlite3DbFree(db
, pSig
->zAff
);
1419 sqlite3DbFree(db
, pSig
);
1426 ** Free the space allocated for aOp and any p4 values allocated for the
1427 ** opcodes contained within. If aOp is not NULL it is assumed to contain
1430 static void vdbeFreeOpArray(sqlite3
*db
, Op
*aOp
, int nOp
){
1434 Op
*pOp
= &aOp
[nOp
-1];
1435 while(1){ /* Exit via break */
1436 if( pOp
->p4type
<= P4_FREE_IF_LE
) freeP4(db
, pOp
->p4type
, pOp
->p4
.p
);
1437 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1438 sqlite3DbFree(db
, pOp
->zComment
);
1440 if( pOp
==aOp
) break;
1443 sqlite3DbNNFreeNN(db
, aOp
);
1448 ** Link the SubProgram object passed as the second argument into the linked
1449 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
1450 ** objects when the VM is no longer required.
1452 void sqlite3VdbeLinkSubProgram(Vdbe
*pVdbe
, SubProgram
*p
){
1453 p
->pNext
= pVdbe
->pProgram
;
1454 pVdbe
->pProgram
= p
;
1458 ** Return true if the given Vdbe has any SubPrograms.
1460 int sqlite3VdbeHasSubProgram(Vdbe
*pVdbe
){
1461 return pVdbe
->pProgram
!=0;
1465 ** Change the opcode at addr into OP_Noop
1467 int sqlite3VdbeChangeToNoop(Vdbe
*p
, int addr
){
1469 if( p
->db
->mallocFailed
) return 0;
1470 assert( addr
>=0 && addr
<p
->nOp
);
1471 pOp
= &p
->aOp
[addr
];
1472 freeP4(p
->db
, pOp
->p4type
, pOp
->p4
.p
);
1473 pOp
->p4type
= P4_NOTUSED
;
1475 pOp
->opcode
= OP_Noop
;
1480 ** If the last opcode is "op" and it is not a jump destination,
1481 ** then remove it. Return true if and only if an opcode was removed.
1483 int sqlite3VdbeDeletePriorOpcode(Vdbe
*p
, u8 op
){
1484 if( p
->nOp
>0 && p
->aOp
[p
->nOp
-1].opcode
==op
){
1485 return sqlite3VdbeChangeToNoop(p
, p
->nOp
-1);
1493 ** Generate an OP_ReleaseReg opcode to indicate that a range of
1494 ** registers, except any identified by mask, are no longer in use.
1496 void sqlite3VdbeReleaseRegisters(
1497 Parse
*pParse
, /* Parsing context */
1498 int iFirst
, /* Index of first register to be released */
1499 int N
, /* Number of registers to release */
1500 u32 mask
, /* Mask of registers to NOT release */
1501 int bUndefine
/* If true, mark registers as undefined */
1503 if( N
==0 || OptimizationDisabled(pParse
->db
, SQLITE_ReleaseReg
) ) return;
1504 assert( pParse
->pVdbe
);
1505 assert( iFirst
>=1 );
1506 assert( iFirst
+N
-1<=pParse
->nMem
);
1507 if( N
<=31 && mask
!=0 ){
1508 while( N
>0 && (mask
&1)!=0 ){
1513 while( N
>0 && N
<=32 && (mask
& MASKBIT32(N
-1))!=0 ){
1514 mask
&= ~MASKBIT32(N
-1);
1519 sqlite3VdbeAddOp3(pParse
->pVdbe
, OP_ReleaseReg
, iFirst
, N
, *(int*)&mask
);
1520 if( bUndefine
) sqlite3VdbeChangeP5(pParse
->pVdbe
, 1);
1523 #endif /* SQLITE_DEBUG */
1526 ** Change the value of the P4 operand for a specific instruction.
1527 ** This routine is useful when a large program is loaded from a
1528 ** static array using sqlite3VdbeAddOpList but we want to make a
1529 ** few minor changes to the program.
1531 ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
1532 ** the string is made into memory obtained from sqlite3_malloc().
1533 ** A value of n==0 means copy bytes of zP4 up to and including the
1534 ** first null byte. If n>0 then copy n+1 bytes of zP4.
1536 ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
1537 ** to a string or structure that is guaranteed to exist for the lifetime of
1538 ** the Vdbe. In these cases we can just copy the pointer.
1540 ** If addr<0 then change P4 on the most recently inserted instruction.
1542 static void SQLITE_NOINLINE
vdbeChangeP4Full(
1549 assert( pOp
->p4type
> P4_FREE_IF_LE
);
1554 sqlite3VdbeChangeP4(p
, (int)(pOp
- p
->aOp
), zP4
, n
);
1556 if( n
==0 ) n
= sqlite3Strlen30(zP4
);
1557 pOp
->p4
.z
= sqlite3DbStrNDup(p
->db
, zP4
, n
);
1558 pOp
->p4type
= P4_DYNAMIC
;
1561 void sqlite3VdbeChangeP4(Vdbe
*p
, int addr
, const char *zP4
, int n
){
1566 assert( p
->eVdbeState
==VDBE_INIT_STATE
);
1567 assert( p
->aOp
!=0 || db
->mallocFailed
);
1568 if( db
->mallocFailed
){
1569 if( n
!=P4_VTAB
) freeP4(db
, n
, (void*)*(char**)&zP4
);
1573 assert( addr
<p
->nOp
);
1577 pOp
= &p
->aOp
[addr
];
1578 if( n
>=0 || pOp
->p4type
){
1579 vdbeChangeP4Full(p
, pOp
, zP4
, n
);
1583 /* Note: this cast is safe, because the origin data point was an int
1584 ** that was cast to a (const char *). */
1585 pOp
->p4
.i
= SQLITE_PTR_TO_INT(zP4
);
1586 pOp
->p4type
= P4_INT32
;
1589 pOp
->p4
.p
= (void*)zP4
;
1590 pOp
->p4type
= (signed char)n
;
1591 if( n
==P4_VTAB
) sqlite3VtabLock((VTable
*)zP4
);
1596 ** Change the P4 operand of the most recently coded instruction
1597 ** to the value defined by the arguments. This is a high-speed
1598 ** version of sqlite3VdbeChangeP4().
1600 ** The P4 operand must not have been previously defined. And the new
1601 ** P4 must not be P4_INT32. Use sqlite3VdbeChangeP4() in either of
1604 void sqlite3VdbeAppendP4(Vdbe
*p
, void *pP4
, int n
){
1606 assert( n
!=P4_INT32
&& n
!=P4_VTAB
);
1608 if( p
->db
->mallocFailed
){
1609 freeP4(p
->db
, n
, pP4
);
1611 assert( pP4
!=0 || n
==P4_DYNAMIC
);
1613 pOp
= &p
->aOp
[p
->nOp
-1];
1614 assert( pOp
->p4type
==P4_NOTUSED
);
1621 ** Set the P4 on the most recently added opcode to the KeyInfo for the
1624 void sqlite3VdbeSetP4KeyInfo(Parse
*pParse
, Index
*pIdx
){
1625 Vdbe
*v
= pParse
->pVdbe
;
1629 pKeyInfo
= sqlite3KeyInfoOfIndex(pParse
, pIdx
);
1630 if( pKeyInfo
) sqlite3VdbeAppendP4(v
, pKeyInfo
, P4_KEYINFO
);
1633 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1635 ** Change the comment on the most recently coded instruction. Or
1636 ** insert a No-op and add the comment to that new instruction. This
1637 ** makes the code easier to read during debugging. None of this happens
1638 ** in a production build.
1640 static void vdbeVComment(Vdbe
*p
, const char *zFormat
, va_list ap
){
1641 assert( p
->nOp
>0 || p
->aOp
==0 );
1642 assert( p
->aOp
==0 || p
->aOp
[p
->nOp
-1].zComment
==0 || p
->pParse
->nErr
>0 );
1645 sqlite3DbFree(p
->db
, p
->aOp
[p
->nOp
-1].zComment
);
1646 p
->aOp
[p
->nOp
-1].zComment
= sqlite3VMPrintf(p
->db
, zFormat
, ap
);
1649 void sqlite3VdbeComment(Vdbe
*p
, const char *zFormat
, ...){
1652 va_start(ap
, zFormat
);
1653 vdbeVComment(p
, zFormat
, ap
);
1657 void sqlite3VdbeNoopComment(Vdbe
*p
, const char *zFormat
, ...){
1660 sqlite3VdbeAddOp0(p
, OP_Noop
);
1661 va_start(ap
, zFormat
);
1662 vdbeVComment(p
, zFormat
, ap
);
1668 #ifdef SQLITE_VDBE_COVERAGE
1670 ** Set the value if the iSrcLine field for the previously coded instruction.
1672 void sqlite3VdbeSetLineNumber(Vdbe
*v
, int iLine
){
1673 sqlite3VdbeGetLastOp(v
)->iSrcLine
= iLine
;
1675 #endif /* SQLITE_VDBE_COVERAGE */
1678 ** Return the opcode for a given address. The address must be non-negative.
1679 ** See sqlite3VdbeGetLastOp() to get the most recently added opcode.
1681 ** If a memory allocation error has occurred prior to the calling of this
1682 ** routine, then a pointer to a dummy VdbeOp will be returned. That opcode
1683 ** is readable but not writable, though it is cast to a writable value.
1684 ** The return of a dummy opcode allows the call to continue functioning
1685 ** after an OOM fault without having to check to see if the return from
1686 ** this routine is a valid pointer. But because the dummy.opcode is 0,
1687 ** dummy will never be written to. This is verified by code inspection and
1688 ** by running with Valgrind.
1690 VdbeOp
*sqlite3VdbeGetOp(Vdbe
*p
, int addr
){
1691 /* C89 specifies that the constant "dummy" will be initialized to all
1692 ** zeros, which is correct. MSVC generates a warning, nevertheless. */
1693 static VdbeOp dummy
; /* Ignore the MSVC warning about no initializer */
1694 assert( p
->eVdbeState
==VDBE_INIT_STATE
);
1695 assert( (addr
>=0 && addr
<p
->nOp
) || p
->db
->mallocFailed
);
1696 if( p
->db
->mallocFailed
){
1697 return (VdbeOp
*)&dummy
;
1699 return &p
->aOp
[addr
];
1703 /* Return the most recently added opcode
1705 VdbeOp
*sqlite3VdbeGetLastOp(Vdbe
*p
){
1706 return sqlite3VdbeGetOp(p
, p
->nOp
- 1);
1709 #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS)
1711 ** Return an integer value for one of the parameters to the opcode pOp
1712 ** determined by character c.
1714 static int translateP(char c
, const Op
*pOp
){
1715 if( c
=='1' ) return pOp
->p1
;
1716 if( c
=='2' ) return pOp
->p2
;
1717 if( c
=='3' ) return pOp
->p3
;
1718 if( c
=='4' ) return pOp
->p4
.i
;
1723 ** Compute a string for the "comment" field of a VDBE opcode listing.
1725 ** The Synopsis: field in comments in the vdbe.c source file gets converted
1726 ** to an extra string that is appended to the sqlite3OpcodeName(). In the
1727 ** absence of other comments, this synopsis becomes the comment on the opcode.
1728 ** Some translation occurs:
1731 ** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1
1732 ** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0
1733 ** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x
1735 char *sqlite3VdbeDisplayComment(
1736 sqlite3
*db
, /* Optional - Oom error reporting only */
1737 const Op
*pOp
, /* The opcode to be commented */
1738 const char *zP4
/* Previously obtained value for P4 */
1740 const char *zOpName
;
1741 const char *zSynopsis
;
1747 sqlite3StrAccumInit(&x
, 0, 0, 0, SQLITE_MAX_LENGTH
);
1748 zOpName
= sqlite3OpcodeName(pOp
->opcode
);
1749 nOpName
= sqlite3Strlen30(zOpName
);
1750 if( zOpName
[nOpName
+1] ){
1753 zSynopsis
= zOpName
+ nOpName
+ 1;
1754 if( strncmp(zSynopsis
,"IF ",3)==0 ){
1755 sqlite3_snprintf(sizeof(zAlt
), zAlt
, "if %s goto P2", zSynopsis
+3);
1758 for(ii
=0; (c
= zSynopsis
[ii
])!=0; ii
++){
1760 c
= zSynopsis
[++ii
];
1762 sqlite3_str_appendall(&x
, zP4
);
1764 if( pOp
->zComment
&& pOp
->zComment
[0] ){
1765 sqlite3_str_appendall(&x
, pOp
->zComment
);
1770 int v1
= translateP(c
, pOp
);
1772 if( strncmp(zSynopsis
+ii
+1, "@P", 2)==0 ){
1774 v2
= translateP(zSynopsis
[ii
], pOp
);
1775 if( strncmp(zSynopsis
+ii
+1,"+1",2)==0 ){
1780 sqlite3_str_appendf(&x
, "%d", v1
);
1782 sqlite3_str_appendf(&x
, "%d..%d", v1
, v1
+v2
-1);
1784 }else if( strncmp(zSynopsis
+ii
+1, "@NP", 3)==0 ){
1785 sqlite3_context
*pCtx
= pOp
->p4
.pCtx
;
1786 if( pOp
->p4type
!=P4_FUNCCTX
|| pCtx
->argc
==1 ){
1787 sqlite3_str_appendf(&x
, "%d", v1
);
1788 }else if( pCtx
->argc
>1 ){
1789 sqlite3_str_appendf(&x
, "%d..%d", v1
, v1
+pCtx
->argc
-1);
1790 }else if( x
.accError
==0 ){
1791 assert( x
.nChar
>2 );
1797 sqlite3_str_appendf(&x
, "%d", v1
);
1798 if( strncmp(zSynopsis
+ii
+1, "..P3", 4)==0 && pOp
->p3
==0 ){
1804 sqlite3_str_appendchar(&x
, 1, c
);
1807 if( !seenCom
&& pOp
->zComment
){
1808 sqlite3_str_appendf(&x
, "; %s", pOp
->zComment
);
1810 }else if( pOp
->zComment
){
1811 sqlite3_str_appendall(&x
, pOp
->zComment
);
1813 if( (x
.accError
& SQLITE_NOMEM
)!=0 && db
!=0 ){
1814 sqlite3OomFault(db
);
1816 return sqlite3StrAccumFinish(&x
);
1818 #endif /* SQLITE_ENABLE_EXPLAIN_COMMENTS */
1820 #if VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS)
1822 ** Translate the P4.pExpr value for an OP_CursorHint opcode into text
1823 ** that can be displayed in the P4 column of EXPLAIN output.
1825 static void displayP4Expr(StrAccum
*p
, Expr
*pExpr
){
1826 const char *zOp
= 0;
1827 switch( pExpr
->op
){
1829 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
1830 sqlite3_str_appendf(p
, "%Q", pExpr
->u
.zToken
);
1833 sqlite3_str_appendf(p
, "%d", pExpr
->u
.iValue
);
1836 sqlite3_str_appendf(p
, "NULL");
1839 sqlite3_str_appendf(p
, "r[%d]", pExpr
->iTable
);
1843 if( pExpr
->iColumn
<0 ){
1844 sqlite3_str_appendf(p
, "rowid");
1846 sqlite3_str_appendf(p
, "c%d", (int)pExpr
->iColumn
);
1850 case TK_LT
: zOp
= "LT"; break;
1851 case TK_LE
: zOp
= "LE"; break;
1852 case TK_GT
: zOp
= "GT"; break;
1853 case TK_GE
: zOp
= "GE"; break;
1854 case TK_NE
: zOp
= "NE"; break;
1855 case TK_EQ
: zOp
= "EQ"; break;
1856 case TK_IS
: zOp
= "IS"; break;
1857 case TK_ISNOT
: zOp
= "ISNOT"; break;
1858 case TK_AND
: zOp
= "AND"; break;
1859 case TK_OR
: zOp
= "OR"; break;
1860 case TK_PLUS
: zOp
= "ADD"; break;
1861 case TK_STAR
: zOp
= "MUL"; break;
1862 case TK_MINUS
: zOp
= "SUB"; break;
1863 case TK_REM
: zOp
= "REM"; break;
1864 case TK_BITAND
: zOp
= "BITAND"; break;
1865 case TK_BITOR
: zOp
= "BITOR"; break;
1866 case TK_SLASH
: zOp
= "DIV"; break;
1867 case TK_LSHIFT
: zOp
= "LSHIFT"; break;
1868 case TK_RSHIFT
: zOp
= "RSHIFT"; break;
1869 case TK_CONCAT
: zOp
= "CONCAT"; break;
1870 case TK_UMINUS
: zOp
= "MINUS"; break;
1871 case TK_UPLUS
: zOp
= "PLUS"; break;
1872 case TK_BITNOT
: zOp
= "BITNOT"; break;
1873 case TK_NOT
: zOp
= "NOT"; break;
1874 case TK_ISNULL
: zOp
= "ISNULL"; break;
1875 case TK_NOTNULL
: zOp
= "NOTNULL"; break;
1878 sqlite3_str_appendf(p
, "%s", "expr");
1883 sqlite3_str_appendf(p
, "%s(", zOp
);
1884 displayP4Expr(p
, pExpr
->pLeft
);
1885 if( pExpr
->pRight
){
1886 sqlite3_str_append(p
, ",", 1);
1887 displayP4Expr(p
, pExpr
->pRight
);
1889 sqlite3_str_append(p
, ")", 1);
1892 #endif /* VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) */
1897 ** Compute a string that describes the P4 parameter for an opcode.
1898 ** Use zTemp for any required temporary buffer space.
1900 char *sqlite3VdbeDisplayP4(sqlite3
*db
, Op
*pOp
){
1904 sqlite3StrAccumInit(&x
, 0, 0, 0, SQLITE_MAX_LENGTH
);
1905 switch( pOp
->p4type
){
1908 KeyInfo
*pKeyInfo
= pOp
->p4
.pKeyInfo
;
1909 assert( pKeyInfo
->aSortFlags
!=0 );
1910 sqlite3_str_appendf(&x
, "k(%d", pKeyInfo
->nKeyField
);
1911 for(j
=0; j
<pKeyInfo
->nKeyField
; j
++){
1912 CollSeq
*pColl
= pKeyInfo
->aColl
[j
];
1913 const char *zColl
= pColl
? pColl
->zName
: "";
1914 if( strcmp(zColl
, "BINARY")==0 ) zColl
= "B";
1915 sqlite3_str_appendf(&x
, ",%s%s%s",
1916 (pKeyInfo
->aSortFlags
[j
] & KEYINFO_ORDER_DESC
) ? "-" : "",
1917 (pKeyInfo
->aSortFlags
[j
] & KEYINFO_ORDER_BIGNULL
)? "N." : "",
1920 sqlite3_str_append(&x
, ")", 1);
1923 #ifdef SQLITE_ENABLE_CURSOR_HINTS
1925 displayP4Expr(&x
, pOp
->p4
.pExpr
);
1930 static const char *const encnames
[] = {"?", "8", "16LE", "16BE"};
1931 CollSeq
*pColl
= pOp
->p4
.pColl
;
1932 assert( pColl
->enc
<4 );
1933 sqlite3_str_appendf(&x
, "%.18s-%s", pColl
->zName
,
1934 encnames
[pColl
->enc
]);
1938 FuncDef
*pDef
= pOp
->p4
.pFunc
;
1939 sqlite3_str_appendf(&x
, "%s(%d)", pDef
->zName
, pDef
->nArg
);
1943 FuncDef
*pDef
= pOp
->p4
.pCtx
->pFunc
;
1944 sqlite3_str_appendf(&x
, "%s(%d)", pDef
->zName
, pDef
->nArg
);
1948 sqlite3_str_appendf(&x
, "%lld", *pOp
->p4
.pI64
);
1952 sqlite3_str_appendf(&x
, "%d", pOp
->p4
.i
);
1956 sqlite3_str_appendf(&x
, "%.16g", *pOp
->p4
.pReal
);
1960 Mem
*pMem
= pOp
->p4
.pMem
;
1961 if( pMem
->flags
& MEM_Str
){
1963 }else if( pMem
->flags
& (MEM_Int
|MEM_IntReal
) ){
1964 sqlite3_str_appendf(&x
, "%lld", pMem
->u
.i
);
1965 }else if( pMem
->flags
& MEM_Real
){
1966 sqlite3_str_appendf(&x
, "%.16g", pMem
->u
.r
);
1967 }else if( pMem
->flags
& MEM_Null
){
1970 assert( pMem
->flags
& MEM_Blob
);
1975 #ifndef SQLITE_OMIT_VIRTUALTABLE
1977 sqlite3_vtab
*pVtab
= pOp
->p4
.pVtab
->pVtab
;
1978 sqlite3_str_appendf(&x
, "vtab:%p", pVtab
);
1984 u32
*ai
= pOp
->p4
.ai
;
1985 u32 n
= ai
[0]; /* The first element of an INTARRAY is always the
1986 ** count of the number of elements to follow */
1987 for(i
=1; i
<=n
; i
++){
1988 sqlite3_str_appendf(&x
, "%c%u", (i
==1 ? '[' : ','), ai
[i
]);
1990 sqlite3_str_append(&x
, "]", 1);
1993 case P4_SUBPROGRAM
: {
1998 zP4
= pOp
->p4
.pTab
->zName
;
2001 case P4_SUBRTNSIG
: {
2002 SubrtnSig
*pSig
= pOp
->p4
.pSubrtnSig
;
2003 sqlite3_str_appendf(&x
, "subrtnsig:%d,%s", pSig
->selId
, pSig
->zAff
);
2010 if( zP4
) sqlite3_str_appendall(&x
, zP4
);
2011 if( (x
.accError
& SQLITE_NOMEM
)!=0 ){
2012 sqlite3OomFault(db
);
2014 return sqlite3StrAccumFinish(&x
);
2016 #endif /* VDBE_DISPLAY_P4 */
2019 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
2021 ** The prepared statements need to know in advance the complete set of
2022 ** attached databases that will be use. A mask of these databases
2023 ** is maintained in p->btreeMask. The p->lockMask value is the subset of
2024 ** p->btreeMask of databases that will require a lock.
2026 void sqlite3VdbeUsesBtree(Vdbe
*p
, int i
){
2027 assert( i
>=0 && i
<p
->db
->nDb
&& i
<(int)sizeof(yDbMask
)*8 );
2028 assert( i
<(int)sizeof(p
->btreeMask
)*8 );
2029 DbMaskSet(p
->btreeMask
, i
);
2030 if( i
!=1 && sqlite3BtreeSharable(p
->db
->aDb
[i
].pBt
) ){
2031 DbMaskSet(p
->lockMask
, i
);
2035 #if !defined(SQLITE_OMIT_SHARED_CACHE)
2037 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
2038 ** this routine obtains the mutex associated with each BtShared structure
2039 ** that may be accessed by the VM passed as an argument. In doing so it also
2040 ** sets the BtShared.db member of each of the BtShared structures, ensuring
2041 ** that the correct busy-handler callback is invoked if required.
2043 ** If SQLite is not threadsafe but does support shared-cache mode, then
2044 ** sqlite3BtreeEnter() is invoked to set the BtShared.db variables
2045 ** of all of BtShared structures accessible via the database handle
2046 ** associated with the VM.
2048 ** If SQLite is not threadsafe and does not support shared-cache mode, this
2049 ** function is a no-op.
2051 ** The p->btreeMask field is a bitmask of all btrees that the prepared
2052 ** statement p will ever use. Let N be the number of bits in p->btreeMask
2053 ** corresponding to btrees that use shared cache. Then the runtime of
2054 ** this routine is N*N. But as N is rarely more than 1, this should not
2057 void sqlite3VdbeEnter(Vdbe
*p
){
2062 if( DbMaskAllZero(p
->lockMask
) ) return; /* The common case */
2066 for(i
=0; i
<nDb
; i
++){
2067 if( i
!=1 && DbMaskTest(p
->lockMask
,i
) && ALWAYS(aDb
[i
].pBt
!=0) ){
2068 sqlite3BtreeEnter(aDb
[i
].pBt
);
2074 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
2076 ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter().
2078 static SQLITE_NOINLINE
void vdbeLeave(Vdbe
*p
){
2086 for(i
=0; i
<nDb
; i
++){
2087 if( i
!=1 && DbMaskTest(p
->lockMask
,i
) && ALWAYS(aDb
[i
].pBt
!=0) ){
2088 sqlite3BtreeLeave(aDb
[i
].pBt
);
2092 void sqlite3VdbeLeave(Vdbe
*p
){
2093 if( DbMaskAllZero(p
->lockMask
) ) return; /* The common case */
2098 #if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
2100 ** Print a single opcode. This routine is used for debugging only.
2102 void sqlite3VdbePrintOp(FILE *pOut
, int pc
, VdbeOp
*pOp
){
2106 static const char *zFormat1
= "%4d %-13s %4d %4d %4d %-13s %.2X %s\n";
2107 if( pOut
==0 ) pOut
= stdout
;
2108 sqlite3BeginBenignMalloc();
2109 dummyDb
.mallocFailed
= 1;
2110 zP4
= sqlite3VdbeDisplayP4(&dummyDb
, pOp
);
2111 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
2112 zCom
= sqlite3VdbeDisplayComment(0, pOp
, zP4
);
2116 /* NB: The sqlite3OpcodeName() function is implemented by code created
2117 ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the
2118 ** information from the vdbe.c source text */
2119 fprintf(pOut
, zFormat1
, pc
,
2120 sqlite3OpcodeName(pOp
->opcode
), pOp
->p1
, pOp
->p2
, pOp
->p3
,
2121 zP4
? zP4
: "", pOp
->p5
,
2127 sqlite3EndBenignMalloc();
2132 ** Initialize an array of N Mem element.
2134 ** This is a high-runner, so only those fields that really do need to
2135 ** be initialized are set. The Mem structure is organized so that
2136 ** the fields that get initialized are nearby and hopefully on the same
2139 ** Mem.flags = flags
2143 ** All other fields of Mem can safely remain uninitialized for now. They
2144 ** will be initialized before use.
2146 static void initMemArray(Mem
*p
, int N
, sqlite3
*db
, u16 flags
){
2161 ** Release auxiliary memory held in an array of N Mem elements.
2163 ** After this routine returns, all Mem elements in the array will still
2164 ** be valid. Those Mem elements that were not holding auxiliary resources
2165 ** will be unchanged. Mem elements which had something freed will be
2166 ** set to MEM_Undefined.
2168 static void releaseMemArray(Mem
*p
, int N
){
2171 sqlite3
*db
= p
->db
;
2172 if( db
->pnBytesFreed
){
2174 if( p
->szMalloc
) sqlite3DbFree(db
, p
->zMalloc
);
2175 }while( (++p
)<pEnd
);
2179 assert( (&p
[1])==pEnd
|| p
[0].db
==p
[1].db
);
2180 assert( sqlite3VdbeCheckMemInvariants(p
) );
2182 /* This block is really an inlined version of sqlite3VdbeMemRelease()
2183 ** that takes advantage of the fact that the memory cell value is
2184 ** being set to NULL after releasing any dynamic resources.
2186 ** The justification for duplicating code is that according to
2187 ** callgrind, this causes a certain test case to hit the CPU 4.7
2188 ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
2189 ** sqlite3MemRelease() were called from here. With -O2, this jumps
2190 ** to 6.6 percent. The test case is inserting 1000 rows into a table
2191 ** with no indexes using a single prepared INSERT statement, bind()
2192 ** and reset(). Inserts are grouped into a transaction.
2194 testcase( p
->flags
& MEM_Agg
);
2195 testcase( p
->flags
& MEM_Dyn
);
2196 if( p
->flags
&(MEM_Agg
|MEM_Dyn
) ){
2197 testcase( (p
->flags
& MEM_Dyn
)!=0 && p
->xDel
==sqlite3VdbeFrameMemDel
);
2198 sqlite3VdbeMemRelease(p
);
2199 p
->flags
= MEM_Undefined
;
2200 }else if( p
->szMalloc
){
2201 sqlite3DbNNFreeNN(db
, p
->zMalloc
);
2203 p
->flags
= MEM_Undefined
;
2207 p
->flags
= MEM_Undefined
;
2210 }while( (++p
)<pEnd
);
2216 ** Verify that pFrame is a valid VdbeFrame pointer. Return true if it is
2217 ** and false if something is wrong.
2219 ** This routine is intended for use inside of assert() statements only.
2221 int sqlite3VdbeFrameIsValid(VdbeFrame
*pFrame
){
2222 if( pFrame
->iFrameMagic
!=SQLITE_FRAME_MAGIC
) return 0;
2229 ** This is a destructor on a Mem object (which is really an sqlite3_value)
2230 ** that deletes the Frame object that is attached to it as a blob.
2232 ** This routine does not delete the Frame right away. It merely adds the
2233 ** frame to a list of frames to be deleted when the Vdbe halts.
2235 void sqlite3VdbeFrameMemDel(void *pArg
){
2236 VdbeFrame
*pFrame
= (VdbeFrame
*)pArg
;
2237 assert( sqlite3VdbeFrameIsValid(pFrame
) );
2238 pFrame
->pParent
= pFrame
->v
->pDelFrame
;
2239 pFrame
->v
->pDelFrame
= pFrame
;
2242 #if defined(SQLITE_ENABLE_BYTECODE_VTAB) || !defined(SQLITE_OMIT_EXPLAIN)
2244 ** Locate the next opcode to be displayed in EXPLAIN or EXPLAIN
2245 ** QUERY PLAN output.
2247 ** Return SQLITE_ROW on success. Return SQLITE_DONE if there are no
2248 ** more opcodes to be displayed.
2250 int sqlite3VdbeNextOpcode(
2251 Vdbe
*p
, /* The statement being explained */
2252 Mem
*pSub
, /* Storage for keeping track of subprogram nesting */
2253 int eMode
, /* 0: normal. 1: EQP. 2: TablesUsed */
2254 int *piPc
, /* IN/OUT: Current rowid. Overwritten with next rowid */
2255 int *piAddr
, /* OUT: Write index into (*paOp)[] here */
2256 Op
**paOp
/* OUT: Write the opcode array here */
2258 int nRow
; /* Stop when row count reaches this */
2259 int nSub
= 0; /* Number of sub-vdbes seen so far */
2260 SubProgram
**apSub
= 0; /* Array of sub-vdbes */
2261 int i
; /* Next instruction address */
2262 int rc
= SQLITE_OK
; /* Result code */
2263 Op
*aOp
= 0; /* Opcode array */
2264 int iPc
; /* Rowid. Copy of value in *piPc */
2266 /* When the number of output rows reaches nRow, that means the
2267 ** listing has finished and sqlite3_step() should return SQLITE_DONE.
2268 ** nRow is the sum of the number of rows in the main program, plus
2269 ** the sum of the number of rows in all trigger subprograms encountered
2270 ** so far. The nRow value will increase as new trigger subprograms are
2271 ** encountered, but p->pc will eventually catch up to nRow.
2275 if( pSub
->flags
&MEM_Blob
){
2276 /* pSub is initiallly NULL. It is initialized to a BLOB by
2277 ** the P4_SUBPROGRAM processing logic below */
2278 nSub
= pSub
->n
/sizeof(Vdbe
*);
2279 apSub
= (SubProgram
**)pSub
->z
;
2281 for(i
=0; i
<nSub
; i
++){
2282 nRow
+= apSub
[i
]->nOp
;
2286 while(1){ /* Loop exits via break */
2294 /* The rowid is small enough that we are still in the
2298 /* We are currently listing subprograms. Figure out which one and
2299 ** pick up the appropriate opcode. */
2304 for(j
=0; i
>=apSub
[j
]->nOp
; j
++){
2306 assert( i
<apSub
[j
]->nOp
|| j
+1<nSub
);
2308 aOp
= apSub
[j
]->aOp
;
2311 /* When an OP_Program opcode is encounter (the only opcode that has
2312 ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms
2313 ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
2314 ** has not already been seen.
2316 if( pSub
!=0 && aOp
[i
].p4type
==P4_SUBPROGRAM
){
2317 int nByte
= (nSub
+1)*sizeof(SubProgram
*);
2319 for(j
=0; j
<nSub
; j
++){
2320 if( apSub
[j
]==aOp
[i
].p4
.pProgram
) break;
2323 p
->rc
= sqlite3VdbeMemGrow(pSub
, nByte
, nSub
!=0);
2324 if( p
->rc
!=SQLITE_OK
){
2328 apSub
= (SubProgram
**)pSub
->z
;
2329 apSub
[nSub
++] = aOp
[i
].p4
.pProgram
;
2330 MemSetTypeFlag(pSub
, MEM_Blob
);
2331 pSub
->n
= nSub
*sizeof(SubProgram
*);
2332 nRow
+= aOp
[i
].p4
.pProgram
->nOp
;
2335 if( eMode
==0 ) break;
2336 #ifdef SQLITE_ENABLE_BYTECODE_VTAB
2339 if( pOp
->opcode
==OP_OpenRead
) break;
2340 if( pOp
->opcode
==OP_OpenWrite
&& (pOp
->p5
& OPFLAG_P2ISREG
)==0 ) break;
2341 if( pOp
->opcode
==OP_ReopenIdx
) break;
2346 if( aOp
[i
].opcode
==OP_Explain
) break;
2347 if( aOp
[i
].opcode
==OP_Init
&& iPc
>1 ) break;
2355 #endif /* SQLITE_ENABLE_BYTECODE_VTAB || !SQLITE_OMIT_EXPLAIN */
2359 ** Delete a VdbeFrame object and its contents. VdbeFrame objects are
2360 ** allocated by the OP_Program opcode in sqlite3VdbeExec().
2362 void sqlite3VdbeFrameDelete(VdbeFrame
*p
){
2364 Mem
*aMem
= VdbeFrameMem(p
);
2365 VdbeCursor
**apCsr
= (VdbeCursor
**)&aMem
[p
->nChildMem
];
2366 assert( sqlite3VdbeFrameIsValid(p
) );
2367 for(i
=0; i
<p
->nChildCsr
; i
++){
2368 if( apCsr
[i
] ) sqlite3VdbeFreeCursorNN(p
->v
, apCsr
[i
]);
2370 releaseMemArray(aMem
, p
->nChildMem
);
2371 sqlite3VdbeDeleteAuxData(p
->v
->db
, &p
->pAuxData
, -1, 0);
2372 sqlite3DbFree(p
->v
->db
, p
);
2375 #ifndef SQLITE_OMIT_EXPLAIN
2377 ** Give a listing of the program in the virtual machine.
2379 ** The interface is the same as sqlite3VdbeExec(). But instead of
2380 ** running the code, it invokes the callback once for each instruction.
2381 ** This feature is used to implement "EXPLAIN".
2383 ** When p->explain==1, each instruction is listed. When
2384 ** p->explain==2, only OP_Explain instructions are listed and these
2385 ** are shown in a different format. p->explain==2 is used to implement
2386 ** EXPLAIN QUERY PLAN.
2387 ** 2018-04-24: In p->explain==2 mode, the OP_Init opcodes of triggers
2388 ** are also shown, so that the boundaries between the main program and
2389 ** each trigger are clear.
2391 ** When p->explain==1, first the main program is listed, then each of
2392 ** the trigger subprograms are listed one by one.
2394 int sqlite3VdbeList(
2395 Vdbe
*p
/* The VDBE */
2397 Mem
*pSub
= 0; /* Memory cell hold array of subprogs */
2398 sqlite3
*db
= p
->db
; /* The database connection */
2399 int i
; /* Loop counter */
2400 int rc
= SQLITE_OK
; /* Return code */
2401 Mem
*pMem
= &p
->aMem
[1]; /* First Mem of result set */
2402 int bListSubprogs
= (p
->explain
==1 || (db
->flags
& SQLITE_TriggerEQP
)!=0);
2403 Op
*aOp
; /* Array of opcodes */
2404 Op
*pOp
; /* Current opcode */
2406 assert( p
->explain
);
2407 assert( p
->eVdbeState
==VDBE_RUN_STATE
);
2408 assert( p
->rc
==SQLITE_OK
|| p
->rc
==SQLITE_BUSY
|| p
->rc
==SQLITE_NOMEM
);
2410 /* Even though this opcode does not use dynamic strings for
2411 ** the result, result columns may become dynamic if the user calls
2412 ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
2414 releaseMemArray(pMem
, 8);
2416 if( p
->rc
==SQLITE_NOMEM
){
2417 /* This happens if a malloc() inside a call to sqlite3_column_text() or
2418 ** sqlite3_column_text16() failed. */
2419 sqlite3OomFault(db
);
2420 return SQLITE_ERROR
;
2423 if( bListSubprogs
){
2424 /* The first 8 memory cells are used for the result set. So we will
2425 ** commandeer the 9th cell to use as storage for an array of pointers
2426 ** to trigger subprograms. The VDBE is guaranteed to have at least 9
2428 assert( p
->nMem
>9 );
2434 /* Figure out which opcode is next to display */
2435 rc
= sqlite3VdbeNextOpcode(p
, pSub
, p
->explain
==2, &p
->pc
, &i
, &aOp
);
2437 if( rc
==SQLITE_OK
){
2439 if( AtomicLoad(&db
->u1
.isInterrupted
) ){
2440 p
->rc
= SQLITE_INTERRUPT
;
2442 sqlite3VdbeError(p
, sqlite3ErrStr(p
->rc
));
2444 char *zP4
= sqlite3VdbeDisplayP4(db
, pOp
);
2445 if( p
->explain
==2 ){
2446 sqlite3VdbeMemSetInt64(pMem
, pOp
->p1
);
2447 sqlite3VdbeMemSetInt64(pMem
+1, pOp
->p2
);
2448 sqlite3VdbeMemSetInt64(pMem
+2, pOp
->p3
);
2449 sqlite3VdbeMemSetStr(pMem
+3, zP4
, -1, SQLITE_UTF8
, sqlite3_free
);
2450 assert( p
->nResColumn
==4 );
2452 sqlite3VdbeMemSetInt64(pMem
+0, i
);
2453 sqlite3VdbeMemSetStr(pMem
+1, (char*)sqlite3OpcodeName(pOp
->opcode
),
2454 -1, SQLITE_UTF8
, SQLITE_STATIC
);
2455 sqlite3VdbeMemSetInt64(pMem
+2, pOp
->p1
);
2456 sqlite3VdbeMemSetInt64(pMem
+3, pOp
->p2
);
2457 sqlite3VdbeMemSetInt64(pMem
+4, pOp
->p3
);
2458 /* pMem+5 for p4 is done last */
2459 sqlite3VdbeMemSetInt64(pMem
+6, pOp
->p5
);
2460 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
2462 char *zCom
= sqlite3VdbeDisplayComment(db
, pOp
, zP4
);
2463 sqlite3VdbeMemSetStr(pMem
+7, zCom
, -1, SQLITE_UTF8
, sqlite3_free
);
2466 sqlite3VdbeMemSetNull(pMem
+7);
2468 sqlite3VdbeMemSetStr(pMem
+5, zP4
, -1, SQLITE_UTF8
, sqlite3_free
);
2469 assert( p
->nResColumn
==8 );
2471 p
->pResultRow
= pMem
;
2472 if( db
->mallocFailed
){
2473 p
->rc
= SQLITE_NOMEM
;
2483 #endif /* SQLITE_OMIT_EXPLAIN */
2487 ** Print the SQL that was used to generate a VDBE program.
2489 void sqlite3VdbePrintSql(Vdbe
*p
){
2493 }else if( p
->nOp
>=1 ){
2494 const VdbeOp
*pOp
= &p
->aOp
[0];
2495 if( pOp
->opcode
==OP_Init
&& pOp
->p4
.z
!=0 ){
2497 while( sqlite3Isspace(*z
) ) z
++;
2500 if( z
) printf("SQL: [%s]\n", z
);
2504 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
2506 ** Print an IOTRACE message showing SQL content.
2508 void sqlite3VdbeIOTraceSql(Vdbe
*p
){
2511 if( sqlite3IoTrace
==0 ) return;
2514 if( pOp
->opcode
==OP_Init
&& pOp
->p4
.z
!=0 ){
2517 sqlite3_snprintf(sizeof(z
), z
, "%s", pOp
->p4
.z
);
2518 for(i
=0; sqlite3Isspace(z
[i
]); i
++){}
2519 for(j
=0; z
[i
]; i
++){
2520 if( sqlite3Isspace(z
[i
]) ){
2529 sqlite3IoTrace("SQL %s\n", z
);
2532 #endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */
2534 /* An instance of this object describes bulk memory available for use
2535 ** by subcomponents of a prepared statement. Space is allocated out
2536 ** of a ReusableSpace object by the allocSpace() routine below.
2538 struct ReusableSpace
{
2539 u8
*pSpace
; /* Available memory */
2540 sqlite3_int64 nFree
; /* Bytes of available memory */
2541 sqlite3_int64 nNeeded
; /* Total bytes that could not be allocated */
2544 /* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf
2545 ** from the ReusableSpace object. Return a pointer to the allocated
2546 ** memory on success. If insufficient memory is available in the
2547 ** ReusableSpace object, increase the ReusableSpace.nNeeded
2548 ** value by the amount needed and return NULL.
2550 ** If pBuf is not initially NULL, that means that the memory has already
2551 ** been allocated by a prior call to this routine, so just return a copy
2552 ** of pBuf and leave ReusableSpace unchanged.
2554 ** This allocator is employed to repurpose unused slots at the end of the
2555 ** opcode array of prepared state for other memory needs of the prepared
2558 static void *allocSpace(
2559 struct ReusableSpace
*p
, /* Bulk memory available for allocation */
2560 void *pBuf
, /* Pointer to a prior allocation */
2561 sqlite3_int64 nByte
/* Bytes of memory needed. */
2563 assert( EIGHT_BYTE_ALIGNMENT(p
->pSpace
) );
2565 nByte
= ROUND8P(nByte
);
2566 if( nByte
<= p
->nFree
){
2568 pBuf
= &p
->pSpace
[p
->nFree
];
2570 p
->nNeeded
+= nByte
;
2573 assert( EIGHT_BYTE_ALIGNMENT(pBuf
) );
2578 ** Rewind the VDBE back to the beginning in preparation for
2581 void sqlite3VdbeRewind(Vdbe
*p
){
2582 #if defined(SQLITE_DEBUG)
2586 assert( p
->eVdbeState
==VDBE_INIT_STATE
2587 || p
->eVdbeState
==VDBE_READY_STATE
2588 || p
->eVdbeState
==VDBE_HALT_STATE
);
2590 /* There should be at least one opcode.
2594 p
->eVdbeState
= VDBE_READY_STATE
;
2597 for(i
=0; i
<p
->nMem
; i
++){
2598 assert( p
->aMem
[i
].db
==p
->db
);
2603 p
->errorAction
= OE_Abort
;
2606 p
->minWriteFileFormat
= 255;
2608 p
->nFkConstraint
= 0;
2610 for(i
=0; i
<p
->nOp
; i
++){
2611 p
->aOp
[i
].nExec
= 0;
2612 p
->aOp
[i
].nCycle
= 0;
2618 ** Prepare a virtual machine for execution for the first time after
2619 ** creating the virtual machine. This involves things such
2620 ** as allocating registers and initializing the program counter.
2621 ** After the VDBE has be prepped, it can be executed by one or more
2622 ** calls to sqlite3VdbeExec().
2624 ** This function may be called exactly once on each virtual machine.
2625 ** After this routine is called the VM has been "packaged" and is ready
2626 ** to run. After this routine is called, further calls to
2627 ** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects
2628 ** the Vdbe from the Parse object that helped generate it so that the
2629 ** the Vdbe becomes an independent entity and the Parse object can be
2632 ** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back
2633 ** to its initial state after it has been run.
2635 void sqlite3VdbeMakeReady(
2636 Vdbe
*p
, /* The VDBE */
2637 Parse
*pParse
/* Parsing context */
2639 sqlite3
*db
; /* The database connection */
2640 int nVar
; /* Number of parameters */
2641 int nMem
; /* Number of VM memory registers */
2642 int nCursor
; /* Number of cursors required */
2643 int nArg
; /* Number of arguments in subprograms */
2644 int n
; /* Loop counter */
2645 struct ReusableSpace x
; /* Reusable bulk memory */
2649 assert( pParse
!=0 );
2650 assert( p
->eVdbeState
==VDBE_INIT_STATE
);
2651 assert( pParse
==p
->pParse
);
2652 p
->pVList
= pParse
->pVList
;
2655 assert( db
->mallocFailed
==0 );
2656 nVar
= pParse
->nVar
;
2657 nMem
= pParse
->nMem
;
2658 nCursor
= pParse
->nTab
;
2659 nArg
= pParse
->nMaxArg
;
2661 /* Each cursor uses a memory cell. The first cursor (cursor 0) can
2662 ** use aMem[0] which is not otherwise used by the VDBE program. Allocate
2663 ** space at the end of aMem[] for cursors 1 and greater.
2664 ** See also: allocateCursor().
2667 if( nCursor
==0 && nMem
>0 ) nMem
++; /* Space for aMem[0] even if not used */
2669 /* Figure out how much reusable memory is available at the end of the
2670 ** opcode array. This extra memory will be reallocated for other elements
2671 ** of the prepared statement.
2673 n
= ROUND8P(sizeof(Op
)*p
->nOp
); /* Bytes of opcode memory used */
2674 x
.pSpace
= &((u8
*)p
->aOp
)[n
]; /* Unused opcode memory */
2675 assert( EIGHT_BYTE_ALIGNMENT(x
.pSpace
) );
2676 x
.nFree
= ROUNDDOWN8(pParse
->szOpAlloc
- n
); /* Bytes of unused memory */
2677 assert( x
.nFree
>=0 );
2678 assert( EIGHT_BYTE_ALIGNMENT(&x
.pSpace
[x
.nFree
]) );
2680 resolveP2Values(p
, &nArg
);
2681 p
->usesStmtJournal
= (u8
)(pParse
->isMultiWrite
&& pParse
->mayAbort
);
2682 if( pParse
->explain
){
2683 if( nMem
<10 ) nMem
= 10;
2684 p
->explain
= pParse
->explain
;
2685 p
->nResColumn
= 12 - 4*p
->explain
;
2689 /* Memory for registers, parameters, cursor, etc, is allocated in one or two
2690 ** passes. On the first pass, we try to reuse unused memory at the
2691 ** end of the opcode array. If we are unable to satisfy all memory
2692 ** requirements by reusing the opcode array tail, then the second
2693 ** pass will fill in the remainder using a fresh memory allocation.
2695 ** This two-pass approach that reuses as much memory as possible from
2696 ** the leftover memory at the end of the opcode array. This can significantly
2697 ** reduce the amount of memory held by a prepared statement.
2700 p
->aMem
= allocSpace(&x
, 0, nMem
*sizeof(Mem
));
2701 p
->aVar
= allocSpace(&x
, 0, nVar
*sizeof(Mem
));
2702 p
->apArg
= allocSpace(&x
, 0, nArg
*sizeof(Mem
*));
2703 p
->apCsr
= allocSpace(&x
, 0, nCursor
*sizeof(VdbeCursor
*));
2705 x
.pSpace
= p
->pFree
= sqlite3DbMallocRawNN(db
, x
.nNeeded
);
2706 x
.nFree
= x
.nNeeded
;
2707 if( !db
->mallocFailed
){
2708 p
->aMem
= allocSpace(&x
, p
->aMem
, nMem
*sizeof(Mem
));
2709 p
->aVar
= allocSpace(&x
, p
->aVar
, nVar
*sizeof(Mem
));
2710 p
->apArg
= allocSpace(&x
, p
->apArg
, nArg
*sizeof(Mem
*));
2711 p
->apCsr
= allocSpace(&x
, p
->apCsr
, nCursor
*sizeof(VdbeCursor
*));
2715 if( db
->mallocFailed
){
2720 p
->nCursor
= nCursor
;
2721 p
->nVar
= (ynVar
)nVar
;
2722 initMemArray(p
->aVar
, nVar
, db
, MEM_Null
);
2724 initMemArray(p
->aMem
, nMem
, db
, MEM_Undefined
);
2725 memset(p
->apCsr
, 0, nCursor
*sizeof(VdbeCursor
*));
2727 sqlite3VdbeRewind(p
);
2731 ** Close a VDBE cursor and release all the resources that cursor
2734 void sqlite3VdbeFreeCursor(Vdbe
*p
, VdbeCursor
*pCx
){
2735 if( pCx
) sqlite3VdbeFreeCursorNN(p
,pCx
);
2737 static SQLITE_NOINLINE
void freeCursorWithCache(Vdbe
*p
, VdbeCursor
*pCx
){
2738 VdbeTxtBlbCache
*pCache
= pCx
->pCache
;
2739 assert( pCx
->colCache
);
2742 if( pCache
->pCValue
){
2743 sqlite3RCStrUnref(pCache
->pCValue
);
2744 pCache
->pCValue
= 0;
2746 sqlite3DbFree(p
->db
, pCache
);
2747 sqlite3VdbeFreeCursorNN(p
, pCx
);
2749 void sqlite3VdbeFreeCursorNN(Vdbe
*p
, VdbeCursor
*pCx
){
2750 if( pCx
->colCache
){
2751 freeCursorWithCache(p
, pCx
);
2754 switch( pCx
->eCurType
){
2755 case CURTYPE_SORTER
: {
2756 sqlite3VdbeSorterClose(p
->db
, pCx
);
2759 case CURTYPE_BTREE
: {
2760 assert( pCx
->uc
.pCursor
!=0 );
2761 sqlite3BtreeCloseCursor(pCx
->uc
.pCursor
);
2764 #ifndef SQLITE_OMIT_VIRTUALTABLE
2765 case CURTYPE_VTAB
: {
2766 sqlite3_vtab_cursor
*pVCur
= pCx
->uc
.pVCur
;
2767 const sqlite3_module
*pModule
= pVCur
->pVtab
->pModule
;
2768 assert( pVCur
->pVtab
->nRef
>0 );
2769 pVCur
->pVtab
->nRef
--;
2770 pModule
->xClose(pVCur
);
2778 ** Close all cursors in the current frame.
2780 static void closeCursorsInFrame(Vdbe
*p
){
2782 for(i
=0; i
<p
->nCursor
; i
++){
2783 VdbeCursor
*pC
= p
->apCsr
[i
];
2785 sqlite3VdbeFreeCursorNN(p
, pC
);
2792 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
2793 ** is used, for example, when a trigger sub-program is halted to restore
2794 ** control to the main program.
2796 int sqlite3VdbeFrameRestore(VdbeFrame
*pFrame
){
2797 Vdbe
*v
= pFrame
->v
;
2798 closeCursorsInFrame(v
);
2799 v
->aOp
= pFrame
->aOp
;
2800 v
->nOp
= pFrame
->nOp
;
2801 v
->aMem
= pFrame
->aMem
;
2802 v
->nMem
= pFrame
->nMem
;
2803 v
->apCsr
= pFrame
->apCsr
;
2804 v
->nCursor
= pFrame
->nCursor
;
2805 v
->db
->lastRowid
= pFrame
->lastRowid
;
2806 v
->nChange
= pFrame
->nChange
;
2807 v
->db
->nChange
= pFrame
->nDbChange
;
2808 sqlite3VdbeDeleteAuxData(v
->db
, &v
->pAuxData
, -1, 0);
2809 v
->pAuxData
= pFrame
->pAuxData
;
2810 pFrame
->pAuxData
= 0;
2815 ** Close all cursors.
2817 ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory
2818 ** cell array. This is necessary as the memory cell array may contain
2819 ** pointers to VdbeFrame objects, which may in turn contain pointers to
2822 static void closeAllCursors(Vdbe
*p
){
2825 for(pFrame
=p
->pFrame
; pFrame
->pParent
; pFrame
=pFrame
->pParent
);
2826 sqlite3VdbeFrameRestore(pFrame
);
2830 assert( p
->nFrame
==0 );
2831 closeCursorsInFrame(p
);
2832 releaseMemArray(p
->aMem
, p
->nMem
);
2833 while( p
->pDelFrame
){
2834 VdbeFrame
*pDel
= p
->pDelFrame
;
2835 p
->pDelFrame
= pDel
->pParent
;
2836 sqlite3VdbeFrameDelete(pDel
);
2839 /* Delete any auxdata allocations made by the VM */
2840 if( p
->pAuxData
) sqlite3VdbeDeleteAuxData(p
->db
, &p
->pAuxData
, -1, 0);
2841 assert( p
->pAuxData
==0 );
2845 ** Set the number of result columns that will be returned by this SQL
2846 ** statement. This is now set at compile time, rather than during
2847 ** execution of the vdbe program so that sqlite3_column_count() can
2848 ** be called on an SQL statement before sqlite3_step().
2850 void sqlite3VdbeSetNumCols(Vdbe
*p
, int nResColumn
){
2852 sqlite3
*db
= p
->db
;
2855 releaseMemArray(p
->aColName
, p
->nResAlloc
*COLNAME_N
);
2856 sqlite3DbFree(db
, p
->aColName
);
2858 n
= nResColumn
*COLNAME_N
;
2859 p
->nResColumn
= p
->nResAlloc
= (u16
)nResColumn
;
2860 p
->aColName
= (Mem
*)sqlite3DbMallocRawNN(db
, sizeof(Mem
)*n
);
2861 if( p
->aColName
==0 ) return;
2862 initMemArray(p
->aColName
, n
, db
, MEM_Null
);
2866 ** Set the name of the idx'th column to be returned by the SQL statement.
2867 ** zName must be a pointer to a nul terminated string.
2869 ** This call must be made after a call to sqlite3VdbeSetNumCols().
2871 ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
2872 ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
2873 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
2875 int sqlite3VdbeSetColName(
2876 Vdbe
*p
, /* Vdbe being configured */
2877 int idx
, /* Index of column zName applies to */
2878 int var
, /* One of the COLNAME_* constants */
2879 const char *zName
, /* Pointer to buffer containing name */
2880 void (*xDel
)(void*) /* Memory management strategy for zName */
2884 assert( idx
<p
->nResAlloc
);
2885 assert( var
<COLNAME_N
);
2886 if( p
->db
->mallocFailed
){
2887 assert( !zName
|| xDel
!=SQLITE_DYNAMIC
);
2888 return SQLITE_NOMEM_BKPT
;
2890 assert( p
->aColName
!=0 );
2891 pColName
= &(p
->aColName
[idx
+var
*p
->nResAlloc
]);
2892 rc
= sqlite3VdbeMemSetStr(pColName
, zName
, -1, SQLITE_UTF8
, xDel
);
2893 assert( rc
!=0 || !zName
|| (pColName
->flags
&MEM_Term
)!=0 );
2898 ** A read or write transaction may or may not be active on database handle
2899 ** db. If a transaction is active, commit it. If there is a
2900 ** write-transaction spanning more than one database file, this routine
2901 ** takes care of the super-journal trickery.
2903 static int vdbeCommit(sqlite3
*db
, Vdbe
*p
){
2905 int nTrans
= 0; /* Number of databases with an active write-transaction
2906 ** that are candidates for a two-phase commit using a
2909 int needXcommit
= 0;
2911 #ifdef SQLITE_OMIT_VIRTUALTABLE
2912 /* With this option, sqlite3VtabSync() is defined to be simply
2913 ** SQLITE_OK so p is not used.
2915 UNUSED_PARAMETER(p
);
2918 /* Before doing anything else, call the xSync() callback for any
2919 ** virtual module tables written in this transaction. This has to
2920 ** be done before determining whether a super-journal file is
2921 ** required, as an xSync() callback may add an attached database
2922 ** to the transaction.
2924 rc
= sqlite3VtabSync(db
, p
);
2926 /* This loop determines (a) if the commit hook should be invoked and
2927 ** (b) how many database files have open write transactions, not
2928 ** including the temp database. (b) is important because if more than
2929 ** one database file has an open write transaction, a super-journal
2930 ** file is required for an atomic commit.
2932 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2933 Btree
*pBt
= db
->aDb
[i
].pBt
;
2934 if( sqlite3BtreeTxnState(pBt
)==SQLITE_TXN_WRITE
){
2935 /* Whether or not a database might need a super-journal depends upon
2936 ** its journal mode (among other things). This matrix determines which
2937 ** journal modes use a super-journal and which do not */
2938 static const u8 aMJNeeded
[] = {
2946 Pager
*pPager
; /* Pager associated with pBt */
2948 sqlite3BtreeEnter(pBt
);
2949 pPager
= sqlite3BtreePager(pBt
);
2950 if( db
->aDb
[i
].safety_level
!=PAGER_SYNCHRONOUS_OFF
2951 && aMJNeeded
[sqlite3PagerGetJournalMode(pPager
)]
2952 && sqlite3PagerIsMemdb(pPager
)==0
2957 rc
= sqlite3PagerExclusiveLock(pPager
);
2958 sqlite3BtreeLeave(pBt
);
2961 if( rc
!=SQLITE_OK
){
2965 /* If there are any write-transactions at all, invoke the commit hook */
2966 if( needXcommit
&& db
->xCommitCallback
){
2967 rc
= db
->xCommitCallback(db
->pCommitArg
);
2969 return SQLITE_CONSTRAINT_COMMITHOOK
;
2973 /* The simple case - no more than one database file (not counting the
2974 ** TEMP database) has a transaction active. There is no need for the
2977 ** If the return value of sqlite3BtreeGetFilename() is a zero length
2978 ** string, it means the main database is :memory: or a temp file. In
2979 ** that case we do not support atomic multi-file commits, so use the
2980 ** simple case then too.
2982 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db
->aDb
[0].pBt
))
2985 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2986 Btree
*pBt
= db
->aDb
[i
].pBt
;
2988 rc
= sqlite3BtreeCommitPhaseOne(pBt
, 0);
2992 /* Do the commit only if all databases successfully complete phase 1.
2993 ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
2994 ** IO error while deleting or truncating a journal file. It is unlikely,
2995 ** but could happen. In this case abandon processing and return the error.
2997 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2998 Btree
*pBt
= db
->aDb
[i
].pBt
;
3000 rc
= sqlite3BtreeCommitPhaseTwo(pBt
, 0);
3003 if( rc
==SQLITE_OK
){
3004 sqlite3VtabCommit(db
);
3008 /* The complex case - There is a multi-file write-transaction active.
3009 ** This requires a super-journal file to ensure the transaction is
3010 ** committed atomically.
3012 #ifndef SQLITE_OMIT_DISKIO
3014 sqlite3_vfs
*pVfs
= db
->pVfs
;
3015 char *zSuper
= 0; /* File-name for the super-journal */
3016 char const *zMainFile
= sqlite3BtreeGetFilename(db
->aDb
[0].pBt
);
3017 sqlite3_file
*pSuperJrnl
= 0;
3023 /* Select a super-journal file name */
3024 nMainFile
= sqlite3Strlen30(zMainFile
);
3025 zSuper
= sqlite3MPrintf(db
, "%.4c%s%.16c", 0,zMainFile
,0);
3026 if( zSuper
==0 ) return SQLITE_NOMEM_BKPT
;
3031 if( retryCount
>100 ){
3032 sqlite3_log(SQLITE_FULL
, "MJ delete: %s", zSuper
);
3033 sqlite3OsDelete(pVfs
, zSuper
, 0);
3035 }else if( retryCount
==1 ){
3036 sqlite3_log(SQLITE_FULL
, "MJ collide: %s", zSuper
);
3040 sqlite3_randomness(sizeof(iRandom
), &iRandom
);
3041 sqlite3_snprintf(13, &zSuper
[nMainFile
], "-mj%06X9%02X",
3042 (iRandom
>>8)&0xffffff, iRandom
&0xff);
3043 /* The antipenultimate character of the super-journal name must
3044 ** be "9" to avoid name collisions when using 8+3 filenames. */
3045 assert( zSuper
[sqlite3Strlen30(zSuper
)-3]=='9' );
3046 sqlite3FileSuffix3(zMainFile
, zSuper
);
3047 rc
= sqlite3OsAccess(pVfs
, zSuper
, SQLITE_ACCESS_EXISTS
, &res
);
3048 }while( rc
==SQLITE_OK
&& res
);
3049 if( rc
==SQLITE_OK
){
3050 /* Open the super-journal. */
3051 rc
= sqlite3OsOpenMalloc(pVfs
, zSuper
, &pSuperJrnl
,
3052 SQLITE_OPEN_READWRITE
|SQLITE_OPEN_CREATE
|
3053 SQLITE_OPEN_EXCLUSIVE
|SQLITE_OPEN_SUPER_JOURNAL
, 0
3056 if( rc
!=SQLITE_OK
){
3057 sqlite3DbFree(db
, zSuper
-4);
3061 /* Write the name of each database file in the transaction into the new
3062 ** super-journal file. If an error occurs at this point close
3063 ** and delete the super-journal file. All the individual journal files
3064 ** still have 'null' as the super-journal pointer, so they will roll
3065 ** back independently if a failure occurs.
3067 for(i
=0; i
<db
->nDb
; i
++){
3068 Btree
*pBt
= db
->aDb
[i
].pBt
;
3069 if( sqlite3BtreeTxnState(pBt
)==SQLITE_TXN_WRITE
){
3070 char const *zFile
= sqlite3BtreeGetJournalname(pBt
);
3072 continue; /* Ignore TEMP and :memory: databases */
3074 assert( zFile
[0]!=0 );
3075 rc
= sqlite3OsWrite(pSuperJrnl
, zFile
, sqlite3Strlen30(zFile
)+1,offset
);
3076 offset
+= sqlite3Strlen30(zFile
)+1;
3077 if( rc
!=SQLITE_OK
){
3078 sqlite3OsCloseFree(pSuperJrnl
);
3079 sqlite3OsDelete(pVfs
, zSuper
, 0);
3080 sqlite3DbFree(db
, zSuper
-4);
3086 /* Sync the super-journal file. If the IOCAP_SEQUENTIAL device
3087 ** flag is set this is not required.
3089 if( 0==(sqlite3OsDeviceCharacteristics(pSuperJrnl
)&SQLITE_IOCAP_SEQUENTIAL
)
3090 && SQLITE_OK
!=(rc
= sqlite3OsSync(pSuperJrnl
, SQLITE_SYNC_NORMAL
))
3092 sqlite3OsCloseFree(pSuperJrnl
);
3093 sqlite3OsDelete(pVfs
, zSuper
, 0);
3094 sqlite3DbFree(db
, zSuper
-4);
3098 /* Sync all the db files involved in the transaction. The same call
3099 ** sets the super-journal pointer in each individual journal. If
3100 ** an error occurs here, do not delete the super-journal file.
3102 ** If the error occurs during the first call to
3103 ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
3104 ** super-journal file will be orphaned. But we cannot delete it,
3105 ** in case the super-journal file name was written into the journal
3106 ** file before the failure occurred.
3108 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
3109 Btree
*pBt
= db
->aDb
[i
].pBt
;
3111 rc
= sqlite3BtreeCommitPhaseOne(pBt
, zSuper
);
3114 sqlite3OsCloseFree(pSuperJrnl
);
3115 assert( rc
!=SQLITE_BUSY
);
3116 if( rc
!=SQLITE_OK
){
3117 sqlite3DbFree(db
, zSuper
-4);
3121 /* Delete the super-journal file. This commits the transaction. After
3122 ** doing this the directory is synced again before any individual
3123 ** transaction files are deleted.
3125 rc
= sqlite3OsDelete(pVfs
, zSuper
, 1);
3126 sqlite3DbFree(db
, zSuper
-4);
3132 /* All files and directories have already been synced, so the following
3133 ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
3134 ** deleting or truncating journals. If something goes wrong while
3135 ** this is happening we don't really care. The integrity of the
3136 ** transaction is already guaranteed, but some stray 'cold' journals
3137 ** may be lying around. Returning an error code won't help matters.
3139 disable_simulated_io_errors();
3140 sqlite3BeginBenignMalloc();
3141 for(i
=0; i
<db
->nDb
; i
++){
3142 Btree
*pBt
= db
->aDb
[i
].pBt
;
3144 sqlite3BtreeCommitPhaseTwo(pBt
, 1);
3147 sqlite3EndBenignMalloc();
3148 enable_simulated_io_errors();
3150 sqlite3VtabCommit(db
);
3158 ** This routine checks that the sqlite3.nVdbeActive count variable
3159 ** matches the number of vdbe's in the list sqlite3.pVdbe that are
3160 ** currently active. An assertion fails if the two counts do not match.
3161 ** This is an internal self-check only - it is not an essential processing
3164 ** This is a no-op if NDEBUG is defined.
3167 static void checkActiveVdbeCnt(sqlite3
*db
){
3174 if( sqlite3_stmt_busy((sqlite3_stmt
*)p
) ){
3176 if( p
->readOnly
==0 ) nWrite
++;
3177 if( p
->bIsReader
) nRead
++;
3181 assert( cnt
==db
->nVdbeActive
);
3182 assert( nWrite
==db
->nVdbeWrite
);
3183 assert( nRead
==db
->nVdbeRead
);
3186 #define checkActiveVdbeCnt(x)
3190 ** If the Vdbe passed as the first argument opened a statement-transaction,
3191 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
3192 ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
3193 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
3194 ** statement transaction is committed.
3196 ** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned.
3197 ** Otherwise SQLITE_OK.
3199 static SQLITE_NOINLINE
int vdbeCloseStatement(Vdbe
*p
, int eOp
){
3200 sqlite3
*const db
= p
->db
;
3203 const int iSavepoint
= p
->iStatement
-1;
3205 assert( eOp
==SAVEPOINT_ROLLBACK
|| eOp
==SAVEPOINT_RELEASE
);
3206 assert( db
->nStatement
>0 );
3207 assert( p
->iStatement
==(db
->nStatement
+db
->nSavepoint
) );
3209 for(i
=0; i
<db
->nDb
; i
++){
3210 int rc2
= SQLITE_OK
;
3211 Btree
*pBt
= db
->aDb
[i
].pBt
;
3213 if( eOp
==SAVEPOINT_ROLLBACK
){
3214 rc2
= sqlite3BtreeSavepoint(pBt
, SAVEPOINT_ROLLBACK
, iSavepoint
);
3216 if( rc2
==SQLITE_OK
){
3217 rc2
= sqlite3BtreeSavepoint(pBt
, SAVEPOINT_RELEASE
, iSavepoint
);
3219 if( rc
==SQLITE_OK
){
3227 if( rc
==SQLITE_OK
){
3228 if( eOp
==SAVEPOINT_ROLLBACK
){
3229 rc
= sqlite3VtabSavepoint(db
, SAVEPOINT_ROLLBACK
, iSavepoint
);
3231 if( rc
==SQLITE_OK
){
3232 rc
= sqlite3VtabSavepoint(db
, SAVEPOINT_RELEASE
, iSavepoint
);
3236 /* If the statement transaction is being rolled back, also restore the
3237 ** database handles deferred constraint counter to the value it had when
3238 ** the statement transaction was opened. */
3239 if( eOp
==SAVEPOINT_ROLLBACK
){
3240 db
->nDeferredCons
= p
->nStmtDefCons
;
3241 db
->nDeferredImmCons
= p
->nStmtDefImmCons
;
3245 int sqlite3VdbeCloseStatement(Vdbe
*p
, int eOp
){
3246 if( p
->db
->nStatement
&& p
->iStatement
){
3247 return vdbeCloseStatement(p
, eOp
);
3254 ** This function is called when a transaction opened by the database
3255 ** handle associated with the VM passed as an argument is about to be
3256 ** committed. If there are outstanding deferred foreign key constraint
3257 ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
3259 ** If there are outstanding FK violations and this function returns
3260 ** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY
3261 ** and write an error message to it. Then return SQLITE_ERROR.
3263 #ifndef SQLITE_OMIT_FOREIGN_KEY
3264 int sqlite3VdbeCheckFk(Vdbe
*p
, int deferred
){
3265 sqlite3
*db
= p
->db
;
3266 if( (deferred
&& (db
->nDeferredCons
+db
->nDeferredImmCons
)>0)
3267 || (!deferred
&& p
->nFkConstraint
>0)
3269 p
->rc
= SQLITE_CONSTRAINT_FOREIGNKEY
;
3270 p
->errorAction
= OE_Abort
;
3271 sqlite3VdbeError(p
, "FOREIGN KEY constraint failed");
3272 if( (p
->prepFlags
& SQLITE_PREPARE_SAVESQL
)==0 ) return SQLITE_ERROR
;
3273 return SQLITE_CONSTRAINT_FOREIGNKEY
;
3280 ** This routine is called the when a VDBE tries to halt. If the VDBE
3281 ** has made changes and is in autocommit mode, then commit those
3282 ** changes. If a rollback is needed, then do the rollback.
3284 ** This routine is the only way to move the sqlite3eOpenState of a VM from
3285 ** SQLITE_STATE_RUN to SQLITE_STATE_HALT. It is harmless to
3286 ** call this on a VM that is in the SQLITE_STATE_HALT state.
3288 ** Return an error code. If the commit could not complete because of
3289 ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it
3290 ** means the close did not happen and needs to be repeated.
3292 int sqlite3VdbeHalt(Vdbe
*p
){
3293 int rc
; /* Used to store transient return codes */
3294 sqlite3
*db
= p
->db
;
3296 /* This function contains the logic that determines if a statement or
3297 ** transaction will be committed or rolled back as a result of the
3298 ** execution of this virtual machine.
3300 ** If any of the following errors occur:
3307 ** Then the internal cache might have been left in an inconsistent
3308 ** state. We need to rollback the statement transaction, if there is
3309 ** one, or the complete transaction if there is no statement transaction.
3312 assert( p
->eVdbeState
==VDBE_RUN_STATE
);
3313 if( db
->mallocFailed
){
3314 p
->rc
= SQLITE_NOMEM_BKPT
;
3317 checkActiveVdbeCnt(db
);
3319 /* No commit or rollback needed if the program never started or if the
3320 ** SQL statement does not read or write a database file. */
3322 int mrc
; /* Primary error code from p->rc */
3323 int eStatementOp
= 0;
3324 int isSpecialError
; /* Set to true if a 'special' error */
3326 /* Lock all btrees used by the statement */
3327 sqlite3VdbeEnter(p
);
3329 /* Check for one of the special errors */
3332 isSpecialError
= mrc
==SQLITE_NOMEM
3333 || mrc
==SQLITE_IOERR
3334 || mrc
==SQLITE_INTERRUPT
3335 || mrc
==SQLITE_FULL
;
3337 mrc
= isSpecialError
= 0;
3339 if( isSpecialError
){
3340 /* If the query was read-only and the error code is SQLITE_INTERRUPT,
3341 ** no rollback is necessary. Otherwise, at least a savepoint
3342 ** transaction must be rolled back to restore the database to a
3343 ** consistent state.
3345 ** Even if the statement is read-only, it is important to perform
3346 ** a statement or transaction rollback operation. If the error
3347 ** occurred while writing to the journal, sub-journal or database
3348 ** file as part of an effort to free up cache space (see function
3349 ** pagerStress() in pager.c), the rollback is required to restore
3350 ** the pager to a consistent state.
3352 if( !p
->readOnly
|| mrc
!=SQLITE_INTERRUPT
){
3353 if( (mrc
==SQLITE_NOMEM
|| mrc
==SQLITE_FULL
) && p
->usesStmtJournal
){
3354 eStatementOp
= SAVEPOINT_ROLLBACK
;
3356 /* We are forced to roll back the active transaction. Before doing
3357 ** so, abort any other statements this handle currently has active.
3359 sqlite3RollbackAll(db
, SQLITE_ABORT_ROLLBACK
);
3360 sqlite3CloseSavepoints(db
);
3367 /* Check for immediate foreign key violations. */
3368 if( p
->rc
==SQLITE_OK
|| (p
->errorAction
==OE_Fail
&& !isSpecialError
) ){
3369 (void)sqlite3VdbeCheckFk(p
, 0);
3372 /* If the auto-commit flag is set and this is the only active writer
3373 ** VM, then we do either a commit or rollback of the current transaction.
3375 ** Note: This block also runs if one of the special errors handled
3376 ** above has occurred.
3378 if( !sqlite3VtabInSync(db
)
3380 && db
->nVdbeWrite
==(p
->readOnly
==0)
3382 if( p
->rc
==SQLITE_OK
|| (p
->errorAction
==OE_Fail
&& !isSpecialError
) ){
3383 rc
= sqlite3VdbeCheckFk(p
, 1);
3384 if( rc
!=SQLITE_OK
){
3385 if( NEVER(p
->readOnly
) ){
3386 sqlite3VdbeLeave(p
);
3387 return SQLITE_ERROR
;
3389 rc
= SQLITE_CONSTRAINT_FOREIGNKEY
;
3390 }else if( db
->flags
& SQLITE_CorruptRdOnly
){
3391 rc
= SQLITE_CORRUPT
;
3392 db
->flags
&= ~SQLITE_CorruptRdOnly
;
3394 /* The auto-commit flag is true, the vdbe program was successful
3395 ** or hit an 'OR FAIL' constraint and there are no deferred foreign
3396 ** key constraints to hold up the transaction. This means a commit
3398 rc
= vdbeCommit(db
, p
);
3400 if( rc
==SQLITE_BUSY
&& p
->readOnly
){
3401 sqlite3VdbeLeave(p
);
3403 }else if( rc
!=SQLITE_OK
){
3404 sqlite3SystemError(db
, rc
);
3406 sqlite3RollbackAll(db
, SQLITE_OK
);
3409 db
->nDeferredCons
= 0;
3410 db
->nDeferredImmCons
= 0;
3411 db
->flags
&= ~(u64
)SQLITE_DeferFKs
;
3412 sqlite3CommitInternalChanges(db
);
3414 }else if( p
->rc
==SQLITE_SCHEMA
&& db
->nVdbeActive
>1 ){
3417 sqlite3RollbackAll(db
, SQLITE_OK
);
3421 }else if( eStatementOp
==0 ){
3422 if( p
->rc
==SQLITE_OK
|| p
->errorAction
==OE_Fail
){
3423 eStatementOp
= SAVEPOINT_RELEASE
;
3424 }else if( p
->errorAction
==OE_Abort
){
3425 eStatementOp
= SAVEPOINT_ROLLBACK
;
3427 sqlite3RollbackAll(db
, SQLITE_ABORT_ROLLBACK
);
3428 sqlite3CloseSavepoints(db
);
3434 /* If eStatementOp is non-zero, then a statement transaction needs to
3435 ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to
3436 ** do so. If this operation returns an error, and the current statement
3437 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
3438 ** current statement error code.
3441 rc
= sqlite3VdbeCloseStatement(p
, eStatementOp
);
3443 if( p
->rc
==SQLITE_OK
|| (p
->rc
&0xff)==SQLITE_CONSTRAINT
){
3445 sqlite3DbFree(db
, p
->zErrMsg
);
3448 sqlite3RollbackAll(db
, SQLITE_ABORT_ROLLBACK
);
3449 sqlite3CloseSavepoints(db
);
3455 /* If this was an INSERT, UPDATE or DELETE and no statement transaction
3456 ** has been rolled back, update the database connection change-counter.
3458 if( p
->changeCntOn
){
3459 if( eStatementOp
!=SAVEPOINT_ROLLBACK
){
3460 sqlite3VdbeSetChanges(db
, p
->nChange
);
3462 sqlite3VdbeSetChanges(db
, 0);
3467 /* Release the locks */
3468 sqlite3VdbeLeave(p
);
3471 /* We have successfully halted and closed the VM. Record this fact. */
3473 if( !p
->readOnly
) db
->nVdbeWrite
--;
3474 if( p
->bIsReader
) db
->nVdbeRead
--;
3475 assert( db
->nVdbeActive
>=db
->nVdbeRead
);
3476 assert( db
->nVdbeRead
>=db
->nVdbeWrite
);
3477 assert( db
->nVdbeWrite
>=0 );
3478 p
->eVdbeState
= VDBE_HALT_STATE
;
3479 checkActiveVdbeCnt(db
);
3480 if( db
->mallocFailed
){
3481 p
->rc
= SQLITE_NOMEM_BKPT
;
3484 /* If the auto-commit flag is set to true, then any locks that were held
3485 ** by connection db have now been released. Call sqlite3ConnectionUnlocked()
3486 ** to invoke any required unlock-notify callbacks.
3488 if( db
->autoCommit
){
3489 sqlite3ConnectionUnlocked(db
);
3492 assert( db
->nVdbeActive
>0 || db
->autoCommit
==0 || db
->nStatement
==0 );
3493 return (p
->rc
==SQLITE_BUSY
? SQLITE_BUSY
: SQLITE_OK
);
3498 ** Each VDBE holds the result of the most recent sqlite3_step() call
3499 ** in p->rc. This routine sets that result back to SQLITE_OK.
3501 void sqlite3VdbeResetStepResult(Vdbe
*p
){
3506 ** Copy the error code and error message belonging to the VDBE passed
3507 ** as the first argument to its database handle (so that they will be
3508 ** returned by calls to sqlite3_errcode() and sqlite3_errmsg()).
3510 ** This function does not clear the VDBE error code or message, just
3511 ** copies them to the database handle.
3513 int sqlite3VdbeTransferError(Vdbe
*p
){
3514 sqlite3
*db
= p
->db
;
3517 db
->bBenignMalloc
++;
3518 sqlite3BeginBenignMalloc();
3519 if( db
->pErr
==0 ) db
->pErr
= sqlite3ValueNew(db
);
3520 sqlite3ValueSetStr(db
->pErr
, -1, p
->zErrMsg
, SQLITE_UTF8
, SQLITE_TRANSIENT
);
3521 sqlite3EndBenignMalloc();
3522 db
->bBenignMalloc
--;
3523 }else if( db
->pErr
){
3524 sqlite3ValueSetNull(db
->pErr
);
3527 db
->errByteOffset
= -1;
3531 #ifdef SQLITE_ENABLE_SQLLOG
3533 ** If an SQLITE_CONFIG_SQLLOG hook is registered and the VM has been run,
3536 static void vdbeInvokeSqllog(Vdbe
*v
){
3537 if( sqlite3GlobalConfig
.xSqllog
&& v
->rc
==SQLITE_OK
&& v
->zSql
&& v
->pc
>=0 ){
3538 char *zExpanded
= sqlite3VdbeExpandSql(v
, v
->zSql
);
3539 assert( v
->db
->init
.busy
==0 );
3541 sqlite3GlobalConfig
.xSqllog(
3542 sqlite3GlobalConfig
.pSqllogArg
, v
->db
, zExpanded
, 1
3544 sqlite3DbFree(v
->db
, zExpanded
);
3549 # define vdbeInvokeSqllog(x)
3553 ** Clean up a VDBE after execution but do not delete the VDBE just yet.
3554 ** Write any error messages into *pzErrMsg. Return the result code.
3556 ** After this routine is run, the VDBE should be ready to be executed
3559 ** To look at it another way, this routine resets the state of the
3560 ** virtual machine from VDBE_RUN_STATE or VDBE_HALT_STATE back to
3561 ** VDBE_READY_STATE.
3563 int sqlite3VdbeReset(Vdbe
*p
){
3564 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
3571 /* If the VM did not run to completion or if it encountered an
3572 ** error, then it might not have been halted properly. So halt
3575 if( p
->eVdbeState
==VDBE_RUN_STATE
) sqlite3VdbeHalt(p
);
3577 /* If the VDBE has been run even partially, then transfer the error code
3578 ** and error message from the VDBE into the main database structure. But
3579 ** if the VDBE has just been set to run but has not actually executed any
3580 ** instructions yet, leave the main database error information unchanged.
3583 vdbeInvokeSqllog(p
);
3584 if( db
->pErr
|| p
->zErrMsg
){
3585 sqlite3VdbeTransferError(p
);
3587 db
->errCode
= p
->rc
;
3591 /* Reset register contents and reclaim error message memory.
3594 /* Execute assert() statements to ensure that the Vdbe.apCsr[] and
3595 ** Vdbe.aMem[] arrays have already been cleaned up. */
3596 if( p
->apCsr
) for(i
=0; i
<p
->nCursor
; i
++) assert( p
->apCsr
[i
]==0 );
3598 for(i
=0; i
<p
->nMem
; i
++) assert( p
->aMem
[i
].flags
==MEM_Undefined
);
3602 sqlite3DbFree(db
, p
->zErrMsg
);
3610 /* Save profiling information from this VDBE run.
3614 FILE *out
= fopen("vdbe_profile.out", "a");
3616 fprintf(out
, "---- ");
3617 for(i
=0; i
<p
->nOp
; i
++){
3618 fprintf(out
, "%02x", p
->aOp
[i
].opcode
);
3623 fprintf(out
, "-- ");
3624 for(i
=0; (c
= p
->zSql
[i
])!=0; i
++){
3625 if( pc
=='\n' ) fprintf(out
, "-- ");
3629 if( pc
!='\n' ) fprintf(out
, "\n");
3631 for(i
=0; i
<p
->nOp
; i
++){
3633 i64 cnt
= p
->aOp
[i
].nExec
;
3634 i64 cycles
= p
->aOp
[i
].nCycle
;
3635 sqlite3_snprintf(sizeof(zHdr
), zHdr
, "%6u %12llu %8llu ",
3638 cnt
>0 ? cycles
/cnt
: 0
3640 fprintf(out
, "%s", zHdr
);
3641 sqlite3VdbePrintOp(out
, i
, &p
->aOp
[i
]);
3647 return p
->rc
& db
->errMask
;
3651 ** Clean up and delete a VDBE after execution. Return an integer which is
3652 ** the result code. Write any error message text into *pzErrMsg.
3654 int sqlite3VdbeFinalize(Vdbe
*p
){
3656 assert( VDBE_RUN_STATE
>VDBE_READY_STATE
);
3657 assert( VDBE_HALT_STATE
>VDBE_READY_STATE
);
3658 assert( VDBE_INIT_STATE
<VDBE_READY_STATE
);
3659 if( p
->eVdbeState
>=VDBE_READY_STATE
){
3660 rc
= sqlite3VdbeReset(p
);
3661 assert( (rc
& p
->db
->errMask
)==rc
);
3663 sqlite3VdbeDelete(p
);
3668 ** If parameter iOp is less than zero, then invoke the destructor for
3669 ** all auxiliary data pointers currently cached by the VM passed as
3670 ** the first argument.
3672 ** Or, if iOp is greater than or equal to zero, then the destructor is
3673 ** only invoked for those auxiliary data pointers created by the user
3674 ** function invoked by the OP_Function opcode at instruction iOp of
3675 ** VM pVdbe, and only then if:
3677 ** * the associated function parameter is the 32nd or later (counting
3678 ** from left to right), or
3680 ** * the corresponding bit in argument mask is clear (where the first
3681 ** function parameter corresponds to bit 0 etc.).
3683 void sqlite3VdbeDeleteAuxData(sqlite3
*db
, AuxData
**pp
, int iOp
, int mask
){
3685 AuxData
*pAux
= *pp
;
3687 || (pAux
->iAuxOp
==iOp
3689 && (pAux
->iAuxArg
>31 || !(mask
& MASKBIT32(pAux
->iAuxArg
))))
3691 testcase( pAux
->iAuxArg
==31 );
3692 if( pAux
->xDeleteAux
){
3693 pAux
->xDeleteAux(pAux
->pAux
);
3695 *pp
= pAux
->pNextAux
;
3696 sqlite3DbFree(db
, pAux
);
3698 pp
= &pAux
->pNextAux
;
3704 ** Free all memory associated with the Vdbe passed as the second argument,
3705 ** except for object itself, which is preserved.
3707 ** The difference between this function and sqlite3VdbeDelete() is that
3708 ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
3709 ** the database connection and frees the object itself.
3711 static void sqlite3VdbeClearObject(sqlite3
*db
, Vdbe
*p
){
3712 SubProgram
*pSub
, *pNext
;
3714 assert( p
->db
==0 || p
->db
==db
);
3716 releaseMemArray(p
->aColName
, p
->nResAlloc
*COLNAME_N
);
3717 sqlite3DbNNFreeNN(db
, p
->aColName
);
3719 for(pSub
=p
->pProgram
; pSub
; pSub
=pNext
){
3720 pNext
= pSub
->pNext
;
3721 vdbeFreeOpArray(db
, pSub
->aOp
, pSub
->nOp
);
3722 sqlite3DbFree(db
, pSub
);
3724 if( p
->eVdbeState
!=VDBE_INIT_STATE
){
3725 releaseMemArray(p
->aVar
, p
->nVar
);
3726 if( p
->pVList
) sqlite3DbNNFreeNN(db
, p
->pVList
);
3727 if( p
->pFree
) sqlite3DbNNFreeNN(db
, p
->pFree
);
3729 vdbeFreeOpArray(db
, p
->aOp
, p
->nOp
);
3730 if( p
->zSql
) sqlite3DbNNFreeNN(db
, p
->zSql
);
3731 #ifdef SQLITE_ENABLE_NORMALIZE
3732 sqlite3DbFree(db
, p
->zNormSql
);
3734 DblquoteStr
*pThis
, *pNxt
;
3735 for(pThis
=p
->pDblStr
; pThis
; pThis
=pNxt
){
3736 pNxt
= pThis
->pNextStr
;
3737 sqlite3DbFree(db
, pThis
);
3741 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
3744 for(i
=0; i
<p
->nScan
; i
++){
3745 sqlite3DbFree(db
, p
->aScan
[i
].zName
);
3747 sqlite3DbFree(db
, p
->aScan
);
3753 ** Delete an entire VDBE.
3755 void sqlite3VdbeDelete(Vdbe
*p
){
3761 assert( sqlite3_mutex_held(db
->mutex
) );
3762 sqlite3VdbeClearObject(db
, p
);
3763 if( db
->pnBytesFreed
==0 ){
3764 assert( p
->ppVPrev
!=0 );
3765 *p
->ppVPrev
= p
->pVNext
;
3767 p
->pVNext
->ppVPrev
= p
->ppVPrev
;
3770 sqlite3DbNNFreeNN(db
, p
);
3774 ** The cursor "p" has a pending seek operation that has not yet been
3775 ** carried out. Seek the cursor now. If an error occurs, return
3776 ** the appropriate error code.
3778 int SQLITE_NOINLINE
sqlite3VdbeFinishMoveto(VdbeCursor
*p
){
3781 extern int sqlite3_search_count
;
3783 assert( p
->deferredMoveto
);
3784 assert( p
->isTable
);
3785 assert( p
->eCurType
==CURTYPE_BTREE
);
3786 rc
= sqlite3BtreeTableMoveto(p
->uc
.pCursor
, p
->movetoTarget
, 0, &res
);
3788 if( res
!=0 ) return SQLITE_CORRUPT_BKPT
;
3790 sqlite3_search_count
++;
3792 p
->deferredMoveto
= 0;
3793 p
->cacheStatus
= CACHE_STALE
;
3798 ** Something has moved cursor "p" out of place. Maybe the row it was
3799 ** pointed to was deleted out from under it. Or maybe the btree was
3800 ** rebalanced. Whatever the cause, try to restore "p" to the place it
3801 ** is supposed to be pointing. If the row was deleted out from under the
3802 ** cursor, set the cursor to point to a NULL row.
3804 int SQLITE_NOINLINE
sqlite3VdbeHandleMovedCursor(VdbeCursor
*p
){
3805 int isDifferentRow
, rc
;
3806 assert( p
->eCurType
==CURTYPE_BTREE
);
3807 assert( p
->uc
.pCursor
!=0 );
3808 assert( sqlite3BtreeCursorHasMoved(p
->uc
.pCursor
) );
3809 rc
= sqlite3BtreeCursorRestore(p
->uc
.pCursor
, &isDifferentRow
);
3810 p
->cacheStatus
= CACHE_STALE
;
3811 if( isDifferentRow
) p
->nullRow
= 1;
3816 ** Check to ensure that the cursor is valid. Restore the cursor
3817 ** if need be. Return any I/O error from the restore operation.
3819 int sqlite3VdbeCursorRestore(VdbeCursor
*p
){
3820 assert( p
->eCurType
==CURTYPE_BTREE
|| IsNullCursor(p
) );
3821 if( sqlite3BtreeCursorHasMoved(p
->uc
.pCursor
) ){
3822 return sqlite3VdbeHandleMovedCursor(p
);
3828 ** The following functions:
3830 ** sqlite3VdbeSerialType()
3831 ** sqlite3VdbeSerialTypeLen()
3832 ** sqlite3VdbeSerialLen()
3833 ** sqlite3VdbeSerialPut() <--- in-lined into OP_MakeRecord as of 2022-04-02
3834 ** sqlite3VdbeSerialGet()
3836 ** encapsulate the code that serializes values for storage in SQLite
3837 ** data and index records. Each serialized value consists of a
3838 ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
3839 ** integer, stored as a varint.
3841 ** In an SQLite index record, the serial type is stored directly before
3842 ** the blob of data that it corresponds to. In a table record, all serial
3843 ** types are stored at the start of the record, and the blobs of data at
3844 ** the end. Hence these functions allow the caller to handle the
3845 ** serial-type and data blob separately.
3847 ** The following table describes the various storage classes for data:
3849 ** serial type bytes of data type
3850 ** -------------- --------------- ---------------
3852 ** 1 1 signed integer
3853 ** 2 2 signed integer
3854 ** 3 3 signed integer
3855 ** 4 4 signed integer
3856 ** 5 6 signed integer
3857 ** 6 8 signed integer
3859 ** 8 0 Integer constant 0
3860 ** 9 0 Integer constant 1
3861 ** 10,11 reserved for expansion
3862 ** N>=12 and even (N-12)/2 BLOB
3863 ** N>=13 and odd (N-13)/2 text
3865 ** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions
3866 ** of SQLite will not understand those serial types.
3869 #if 0 /* Inlined into the OP_MakeRecord opcode */
3871 ** Return the serial-type for the value stored in pMem.
3873 ** This routine might convert a large MEM_IntReal value into MEM_Real.
3875 ** 2019-07-11: The primary user of this subroutine was the OP_MakeRecord
3876 ** opcode in the byte-code engine. But by moving this routine in-line, we
3877 ** can omit some redundant tests and make that opcode a lot faster. So
3878 ** this routine is now only used by the STAT3 logic and STAT3 support has
3879 ** ended. The code is kept here for historical reference only.
3881 u32
sqlite3VdbeSerialType(Mem
*pMem
, int file_format
, u32
*pLen
){
3882 int flags
= pMem
->flags
;
3886 if( flags
&MEM_Null
){
3890 if( flags
&(MEM_Int
|MEM_IntReal
) ){
3891 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
3892 # define MAX_6BYTE ((((i64)0x00008000)<<32)-1)
3895 testcase( flags
& MEM_Int
);
3896 testcase( flags
& MEM_IntReal
);
3903 if( (i
&1)==i
&& file_format
>=4 ){
3911 if( u
<=32767 ){ *pLen
= 2; return 2; }
3912 if( u
<=8388607 ){ *pLen
= 3; return 3; }
3913 if( u
<=2147483647 ){ *pLen
= 4; return 4; }
3914 if( u
<=MAX_6BYTE
){ *pLen
= 6; return 5; }
3916 if( flags
&MEM_IntReal
){
3917 /* If the value is IntReal and is going to take up 8 bytes to store
3918 ** as an integer, then we might as well make it an 8-byte floating
3920 pMem
->u
.r
= (double)pMem
->u
.i
;
3921 pMem
->flags
&= ~MEM_IntReal
;
3922 pMem
->flags
|= MEM_Real
;
3927 if( flags
&MEM_Real
){
3931 assert( pMem
->db
->mallocFailed
|| flags
&(MEM_Str
|MEM_Blob
) );
3932 assert( pMem
->n
>=0 );
3934 if( flags
& MEM_Zero
){
3938 return ((n
*2) + 12 + ((flags
&MEM_Str
)!=0));
3940 #endif /* inlined into OP_MakeRecord */
3943 ** The sizes for serial types less than 128
3945 const u8 sqlite3SmallTypeSizes
[128] = {
3946 /* 0 1 2 3 4 5 6 7 8 9 */
3947 /* 0 */ 0, 1, 2, 3, 4, 6, 8, 8, 0, 0,
3948 /* 10 */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3,
3949 /* 20 */ 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
3950 /* 30 */ 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,
3951 /* 40 */ 14, 14, 15, 15, 16, 16, 17, 17, 18, 18,
3952 /* 50 */ 19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
3953 /* 60 */ 24, 24, 25, 25, 26, 26, 27, 27, 28, 28,
3954 /* 70 */ 29, 29, 30, 30, 31, 31, 32, 32, 33, 33,
3955 /* 80 */ 34, 34, 35, 35, 36, 36, 37, 37, 38, 38,
3956 /* 90 */ 39, 39, 40, 40, 41, 41, 42, 42, 43, 43,
3957 /* 100 */ 44, 44, 45, 45, 46, 46, 47, 47, 48, 48,
3958 /* 110 */ 49, 49, 50, 50, 51, 51, 52, 52, 53, 53,
3959 /* 120 */ 54, 54, 55, 55, 56, 56, 57, 57
3963 ** Return the length of the data corresponding to the supplied serial-type.
3965 u32
sqlite3VdbeSerialTypeLen(u32 serial_type
){
3966 if( serial_type
>=128 ){
3967 return (serial_type
-12)/2;
3969 assert( serial_type
<12
3970 || sqlite3SmallTypeSizes
[serial_type
]==(serial_type
- 12)/2 );
3971 return sqlite3SmallTypeSizes
[serial_type
];
3974 u8
sqlite3VdbeOneByteSerialTypeLen(u8 serial_type
){
3975 assert( serial_type
<128 );
3976 return sqlite3SmallTypeSizes
[serial_type
];
3980 ** If we are on an architecture with mixed-endian floating
3981 ** points (ex: ARM7) then swap the lower 4 bytes with the
3982 ** upper 4 bytes. Return the result.
3984 ** For most architectures, this is a no-op.
3986 ** (later): It is reported to me that the mixed-endian problem
3987 ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
3988 ** that early versions of GCC stored the two words of a 64-bit
3989 ** float in the wrong order. And that error has been propagated
3990 ** ever since. The blame is not necessarily with GCC, though.
3991 ** GCC might have just copying the problem from a prior compiler.
3992 ** I am also told that newer versions of GCC that follow a different
3993 ** ABI get the byte order right.
3995 ** Developers using SQLite on an ARM7 should compile and run their
3996 ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
3997 ** enabled, some asserts below will ensure that the byte order of
3998 ** floating point values is correct.
4000 ** (2007-08-30) Frank van Vugt has studied this problem closely
4001 ** and has send his findings to the SQLite developers. Frank
4002 ** writes that some Linux kernels offer floating point hardware
4003 ** emulation that uses only 32-bit mantissas instead of a full
4004 ** 48-bits as required by the IEEE standard. (This is the
4005 ** CONFIG_FPE_FASTFPE option.) On such systems, floating point
4006 ** byte swapping becomes very complicated. To avoid problems,
4007 ** the necessary byte swapping is carried out using a 64-bit integer
4008 ** rather than a 64-bit float. Frank assures us that the code here
4009 ** works for him. We, the developers, have no way to independently
4010 ** verify this, but Frank seems to know what he is talking about
4013 #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
4014 u64
sqlite3FloatSwap(u64 in
){
4027 #endif /* SQLITE_MIXED_ENDIAN_64BIT_FLOAT */
4030 /* Input "x" is a sequence of unsigned characters that represent a
4031 ** big-endian integer. Return the equivalent native integer
4033 #define ONE_BYTE_INT(x) ((i8)(x)[0])
4034 #define TWO_BYTE_INT(x) (256*(i8)((x)[0])|(x)[1])
4035 #define THREE_BYTE_INT(x) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2])
4036 #define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
4037 #define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
4040 ** Deserialize the data blob pointed to by buf as serial type serial_type
4041 ** and store the result in pMem.
4043 ** This function is implemented as two separate routines for performance.
4044 ** The few cases that require local variables are broken out into a separate
4045 ** routine so that in most cases the overhead of moving the stack pointer
4048 static void serialGet(
4049 const unsigned char *buf
, /* Buffer to deserialize from */
4050 u32 serial_type
, /* Serial type to deserialize */
4051 Mem
*pMem
/* Memory cell to write value into */
4053 u64 x
= FOUR_BYTE_UINT(buf
);
4054 u32 y
= FOUR_BYTE_UINT(buf
+4);
4056 if( serial_type
==6 ){
4057 /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit
4058 ** twos-complement integer. */
4059 pMem
->u
.i
= *(i64
*)&x
;
4060 pMem
->flags
= MEM_Int
;
4061 testcase( pMem
->u
.i
<0 );
4063 /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit
4064 ** floating point number. */
4065 #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
4066 /* Verify that integers and floating point values use the same
4067 ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
4068 ** defined that 64-bit floating point values really are mixed
4071 static const u64 t1
= ((u64
)0x3ff00000)<<32;
4072 static const double r1
= 1.0;
4074 swapMixedEndianFloat(t2
);
4075 assert( sizeof(r1
)==sizeof(t2
) && memcmp(&r1
, &t2
, sizeof(r1
))==0 );
4077 assert( sizeof(x
)==8 && sizeof(pMem
->u
.r
)==8 );
4078 swapMixedEndianFloat(x
);
4079 memcpy(&pMem
->u
.r
, &x
, sizeof(x
));
4080 pMem
->flags
= IsNaN(x
) ? MEM_Null
: MEM_Real
;
4083 static int serialGet7(
4084 const unsigned char *buf
, /* Buffer to deserialize from */
4085 Mem
*pMem
/* Memory cell to write value into */
4087 u64 x
= FOUR_BYTE_UINT(buf
);
4088 u32 y
= FOUR_BYTE_UINT(buf
+4);
4090 assert( sizeof(x
)==8 && sizeof(pMem
->u
.r
)==8 );
4091 swapMixedEndianFloat(x
);
4092 memcpy(&pMem
->u
.r
, &x
, sizeof(x
));
4094 pMem
->flags
= MEM_Null
;
4097 pMem
->flags
= MEM_Real
;
4100 void sqlite3VdbeSerialGet(
4101 const unsigned char *buf
, /* Buffer to deserialize from */
4102 u32 serial_type
, /* Serial type to deserialize */
4103 Mem
*pMem
/* Memory cell to write value into */
4105 switch( serial_type
){
4106 case 10: { /* Internal use only: NULL with virtual table
4107 ** UPDATE no-change flag set */
4108 pMem
->flags
= MEM_Null
|MEM_Zero
;
4113 case 11: /* Reserved for future use */
4114 case 0: { /* Null */
4115 /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */
4116 pMem
->flags
= MEM_Null
;
4120 /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement
4122 pMem
->u
.i
= ONE_BYTE_INT(buf
);
4123 pMem
->flags
= MEM_Int
;
4124 testcase( pMem
->u
.i
<0 );
4127 case 2: { /* 2-byte signed integer */
4128 /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit
4129 ** twos-complement integer. */
4130 pMem
->u
.i
= TWO_BYTE_INT(buf
);
4131 pMem
->flags
= MEM_Int
;
4132 testcase( pMem
->u
.i
<0 );
4135 case 3: { /* 3-byte signed integer */
4136 /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit
4137 ** twos-complement integer. */
4138 pMem
->u
.i
= THREE_BYTE_INT(buf
);
4139 pMem
->flags
= MEM_Int
;
4140 testcase( pMem
->u
.i
<0 );
4143 case 4: { /* 4-byte signed integer */
4144 /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit
4145 ** twos-complement integer. */
4146 pMem
->u
.i
= FOUR_BYTE_INT(buf
);
4148 /* Work around a sign-extension bug in the HP compiler for HP/UX */
4149 if( buf
[0]&0x80 ) pMem
->u
.i
|= 0xffffffff80000000LL
;
4151 pMem
->flags
= MEM_Int
;
4152 testcase( pMem
->u
.i
<0 );
4155 case 5: { /* 6-byte signed integer */
4156 /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit
4157 ** twos-complement integer. */
4158 pMem
->u
.i
= FOUR_BYTE_UINT(buf
+2) + (((i64
)1)<<32)*TWO_BYTE_INT(buf
);
4159 pMem
->flags
= MEM_Int
;
4160 testcase( pMem
->u
.i
<0 );
4163 case 6: /* 8-byte signed integer */
4164 case 7: { /* IEEE floating point */
4165 /* These use local variables, so do them in a separate routine
4166 ** to avoid having to move the frame pointer in the common case */
4167 serialGet(buf
,serial_type
,pMem
);
4170 case 8: /* Integer 0 */
4171 case 9: { /* Integer 1 */
4172 /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */
4173 /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */
4174 pMem
->u
.i
= serial_type
-8;
4175 pMem
->flags
= MEM_Int
;
4179 /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in
4181 ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and
4182 ** (N-13)/2 bytes in length. */
4183 static const u16 aFlag
[] = { MEM_Blob
|MEM_Ephem
, MEM_Str
|MEM_Ephem
};
4184 pMem
->z
= (char *)buf
;
4185 pMem
->n
= (serial_type
-12)/2;
4186 pMem
->flags
= aFlag
[serial_type
&1];
4193 ** This routine is used to allocate sufficient space for an UnpackedRecord
4194 ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
4195 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
4197 ** The space is either allocated using sqlite3DbMallocRaw() or from within
4198 ** the unaligned buffer passed via the second and third arguments (presumably
4199 ** stack space). If the former, then *ppFree is set to a pointer that should
4200 ** be eventually freed by the caller using sqlite3DbFree(). Or, if the
4201 ** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL
4202 ** before returning.
4204 ** If an OOM error occurs, NULL is returned.
4206 UnpackedRecord
*sqlite3VdbeAllocUnpackedRecord(
4207 KeyInfo
*pKeyInfo
/* Description of the record */
4209 UnpackedRecord
*p
; /* Unpacked record to return */
4210 int nByte
; /* Number of bytes required for *p */
4211 nByte
= ROUND8P(sizeof(UnpackedRecord
)) + sizeof(Mem
)*(pKeyInfo
->nKeyField
+1);
4212 p
= (UnpackedRecord
*)sqlite3DbMallocRaw(pKeyInfo
->db
, nByte
);
4214 p
->aMem
= (Mem
*)&((char*)p
)[ROUND8P(sizeof(UnpackedRecord
))];
4215 assert( pKeyInfo
->aSortFlags
!=0 );
4216 p
->pKeyInfo
= pKeyInfo
;
4217 p
->nField
= pKeyInfo
->nKeyField
+ 1;
4222 ** Given the nKey-byte encoding of a record in pKey[], populate the
4223 ** UnpackedRecord structure indicated by the fourth argument with the
4224 ** contents of the decoded record.
4226 void sqlite3VdbeRecordUnpack(
4227 KeyInfo
*pKeyInfo
, /* Information about the record format */
4228 int nKey
, /* Size of the binary record */
4229 const void *pKey
, /* The binary record */
4230 UnpackedRecord
*p
/* Populate this structure before returning. */
4232 const unsigned char *aKey
= (const unsigned char *)pKey
;
4234 u32 idx
; /* Offset in aKey[] to read from */
4235 u16 u
; /* Unsigned loop counter */
4237 Mem
*pMem
= p
->aMem
;
4240 assert( EIGHT_BYTE_ALIGNMENT(pMem
) );
4241 idx
= getVarint32(aKey
, szHdr
);
4244 while( idx
<szHdr
&& d
<=(u32
)nKey
){
4247 idx
+= getVarint32(&aKey
[idx
], serial_type
);
4248 pMem
->enc
= pKeyInfo
->enc
;
4249 pMem
->db
= pKeyInfo
->db
;
4250 /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
4253 sqlite3VdbeSerialGet(&aKey
[d
], serial_type
, pMem
);
4254 d
+= sqlite3VdbeSerialTypeLen(serial_type
);
4256 if( (++u
)>=p
->nField
) break;
4258 if( d
>(u32
)nKey
&& u
){
4259 assert( CORRUPT_DB
);
4260 /* In a corrupt record entry, the last pMem might have been set up using
4261 ** uninitialized memory. Overwrite its value with NULL, to prevent
4262 ** warnings from MSAN. */
4263 sqlite3VdbeMemSetNull(pMem
-1);
4265 assert( u
<=pKeyInfo
->nKeyField
+ 1 );
4271 ** This function compares two index or table record keys in the same way
4272 ** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(),
4273 ** this function deserializes and compares values using the
4274 ** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
4275 ** in assert() statements to ensure that the optimized code in
4276 ** sqlite3VdbeRecordCompare() returns results with these two primitives.
4278 ** Return true if the result of comparison is equivalent to desiredResult.
4279 ** Return false if there is a disagreement.
4281 static int vdbeRecordCompareDebug(
4282 int nKey1
, const void *pKey1
, /* Left key */
4283 const UnpackedRecord
*pPKey2
, /* Right key */
4284 int desiredResult
/* Correct answer */
4286 u32 d1
; /* Offset into aKey[] of next data element */
4287 u32 idx1
; /* Offset into aKey[] of next header element */
4288 u32 szHdr1
; /* Number of bytes in header */
4291 const unsigned char *aKey1
= (const unsigned char *)pKey1
;
4295 pKeyInfo
= pPKey2
->pKeyInfo
;
4296 if( pKeyInfo
->db
==0 ) return 1;
4297 mem1
.enc
= pKeyInfo
->enc
;
4298 mem1
.db
= pKeyInfo
->db
;
4299 /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */
4300 VVA_ONLY( mem1
.szMalloc
= 0; ) /* Only needed by assert() statements */
4302 /* Compilers may complain that mem1.u.i is potentially uninitialized.
4303 ** We could initialize it, as shown here, to silence those complaints.
4304 ** But in fact, mem1.u.i will never actually be used uninitialized, and doing
4305 ** the unnecessary initialization has a measurable negative performance
4306 ** impact, since this routine is a very high runner. And so, we choose
4307 ** to ignore the compiler warnings and leave this variable uninitialized.
4309 /* mem1.u.i = 0; // not needed, here to silence compiler warning */
4311 idx1
= getVarint32(aKey1
, szHdr1
);
4312 if( szHdr1
>98307 ) return SQLITE_CORRUPT
;
4314 assert( pKeyInfo
->nAllField
>=pPKey2
->nField
|| CORRUPT_DB
);
4315 assert( pKeyInfo
->aSortFlags
!=0 );
4316 assert( pKeyInfo
->nKeyField
>0 );
4317 assert( idx1
<=szHdr1
|| CORRUPT_DB
);
4321 /* Read the serial types for the next element in each key. */
4322 idx1
+= getVarint32( aKey1
+idx1
, serial_type1
);
4324 /* Verify that there is enough key space remaining to avoid
4325 ** a buffer overread. The "d1+serial_type1+2" subexpression will
4326 ** always be greater than or equal to the amount of required key space.
4327 ** Use that approximation to avoid the more expensive call to
4328 ** sqlite3VdbeSerialTypeLen() in the common case.
4330 if( d1
+(u64
)serial_type1
+2>(u64
)nKey1
4331 && d1
+(u64
)sqlite3VdbeSerialTypeLen(serial_type1
)>(u64
)nKey1
4335 && d1
+(u64
)sqlite3VdbeSerialTypeLen(serial_type1
)<=(u64
)nKey1
+8
4338 return 1; /* corrupt record not detected by
4339 ** sqlite3VdbeRecordCompareWithSkip(). Return true
4340 ** to avoid firing the assert() */
4345 /* Extract the values to be compared.
4347 sqlite3VdbeSerialGet(&aKey1
[d1
], serial_type1
, &mem1
);
4348 d1
+= sqlite3VdbeSerialTypeLen(serial_type1
);
4350 /* Do the comparison
4352 rc
= sqlite3MemCompare(&mem1
, &pPKey2
->aMem
[i
],
4353 pKeyInfo
->nAllField
>i
? pKeyInfo
->aColl
[i
] : 0);
4355 assert( mem1
.szMalloc
==0 ); /* See comment below */
4356 if( (pKeyInfo
->aSortFlags
[i
] & KEYINFO_ORDER_BIGNULL
)
4357 && ((mem1
.flags
& MEM_Null
) || (pPKey2
->aMem
[i
].flags
& MEM_Null
))
4361 if( pKeyInfo
->aSortFlags
[i
] & KEYINFO_ORDER_DESC
){
4362 rc
= -rc
; /* Invert the result for DESC sort order. */
4364 goto debugCompareEnd
;
4367 }while( idx1
<szHdr1
&& i
<pPKey2
->nField
);
4369 /* No memory allocation is ever used on mem1. Prove this using
4370 ** the following assert(). If the assert() fails, it indicates a
4371 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).
4373 assert( mem1
.szMalloc
==0 );
4375 /* rc==0 here means that one of the keys ran out of fields and
4376 ** all the fields up to that point were equal. Return the default_rc
4378 rc
= pPKey2
->default_rc
;
4381 if( desiredResult
==0 && rc
==0 ) return 1;
4382 if( desiredResult
<0 && rc
<0 ) return 1;
4383 if( desiredResult
>0 && rc
>0 ) return 1;
4384 if( CORRUPT_DB
) return 1;
4385 if( pKeyInfo
->db
->mallocFailed
) return 1;
4392 ** Count the number of fields (a.k.a. columns) in the record given by
4393 ** pKey,nKey. The verify that this count is less than or equal to the
4394 ** limit given by pKeyInfo->nAllField.
4396 ** If this constraint is not satisfied, it means that the high-speed
4397 ** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will
4398 ** not work correctly. If this assert() ever fires, it probably means
4399 ** that the KeyInfo.nKeyField or KeyInfo.nAllField values were computed
4402 static void vdbeAssertFieldCountWithinLimits(
4403 int nKey
, const void *pKey
, /* The record to verify */
4404 const KeyInfo
*pKeyInfo
/* Compare size with this KeyInfo */
4410 const unsigned char *aKey
= (const unsigned char*)pKey
;
4412 if( CORRUPT_DB
) return;
4413 idx
= getVarint32(aKey
, szHdr
);
4415 assert( szHdr
<=(u32
)nKey
);
4417 idx
+= getVarint32(aKey
+idx
, notUsed
);
4420 assert( nField
<= pKeyInfo
->nAllField
);
4423 # define vdbeAssertFieldCountWithinLimits(A,B,C)
4427 ** Both *pMem1 and *pMem2 contain string values. Compare the two values
4428 ** using the collation sequence pColl. As usual, return a negative , zero
4429 ** or positive value if *pMem1 is less than, equal to or greater than
4430 ** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);".
4432 static int vdbeCompareMemString(
4435 const CollSeq
*pColl
,
4436 u8
*prcErr
/* If an OOM occurs, set to SQLITE_NOMEM */
4438 if( pMem1
->enc
==pColl
->enc
){
4439 /* The strings are already in the correct encoding. Call the
4440 ** comparison function directly */
4441 return pColl
->xCmp(pColl
->pUser
,pMem1
->n
,pMem1
->z
,pMem2
->n
,pMem2
->z
);
4444 const void *v1
, *v2
;
4447 sqlite3VdbeMemInit(&c1
, pMem1
->db
, MEM_Null
);
4448 sqlite3VdbeMemInit(&c2
, pMem1
->db
, MEM_Null
);
4449 sqlite3VdbeMemShallowCopy(&c1
, pMem1
, MEM_Ephem
);
4450 sqlite3VdbeMemShallowCopy(&c2
, pMem2
, MEM_Ephem
);
4451 v1
= sqlite3ValueText((sqlite3_value
*)&c1
, pColl
->enc
);
4452 v2
= sqlite3ValueText((sqlite3_value
*)&c2
, pColl
->enc
);
4453 if( (v1
==0 || v2
==0) ){
4454 if( prcErr
) *prcErr
= SQLITE_NOMEM_BKPT
;
4457 rc
= pColl
->xCmp(pColl
->pUser
, c1
.n
, v1
, c2
.n
, v2
);
4459 sqlite3VdbeMemReleaseMalloc(&c1
);
4460 sqlite3VdbeMemReleaseMalloc(&c2
);
4466 ** The input pBlob is guaranteed to be a Blob that is not marked
4467 ** with MEM_Zero. Return true if it could be a zero-blob.
4469 static int isAllZero(const char *z
, int n
){
4472 if( z
[i
] ) return 0;
4478 ** Compare two blobs. Return negative, zero, or positive if the first
4479 ** is less than, equal to, or greater than the second, respectively.
4480 ** If one blob is a prefix of the other, then the shorter is the lessor.
4482 SQLITE_NOINLINE
int sqlite3BlobCompare(const Mem
*pB1
, const Mem
*pB2
){
4487 /* It is possible to have a Blob value that has some non-zero content
4488 ** followed by zero content. But that only comes up for Blobs formed
4489 ** by the OP_MakeRecord opcode, and such Blobs never get passed into
4490 ** sqlite3MemCompare(). */
4491 assert( (pB1
->flags
& MEM_Zero
)==0 || n1
==0 );
4492 assert( (pB2
->flags
& MEM_Zero
)==0 || n2
==0 );
4494 if( (pB1
->flags
|pB2
->flags
) & MEM_Zero
){
4495 if( pB1
->flags
& pB2
->flags
& MEM_Zero
){
4496 return pB1
->u
.nZero
- pB2
->u
.nZero
;
4497 }else if( pB1
->flags
& MEM_Zero
){
4498 if( !isAllZero(pB2
->z
, pB2
->n
) ) return -1;
4499 return pB1
->u
.nZero
- n2
;
4501 if( !isAllZero(pB1
->z
, pB1
->n
) ) return +1;
4502 return n1
- pB2
->u
.nZero
;
4505 c
= memcmp(pB1
->z
, pB2
->z
, n1
>n2
? n2
: n1
);
4510 /* The following two functions are used only within testcase() to prove
4511 ** test coverage. These functions do no exist for production builds.
4512 ** We must use separate SQLITE_NOINLINE functions here, since otherwise
4513 ** optimizer code movement causes gcov to become very confused.
4515 #if (defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)) \
4516 && (!defined(SQLITE_USE_LONG_DOUBLE) || SQLITE_USE_LONG_DOUBLE+0==0)
4517 static int SQLITE_NOINLINE
doubleLt(double a
, double b
){ return a
<b
; }
4518 static int SQLITE_NOINLINE
doubleEq(double a
, double b
){ return a
==b
; }
4520 # define doubleLt(A,B) 1
4521 # define doubleEq(A,B) 1
4525 ** Do a comparison between a 64-bit signed integer and a 64-bit floating-point
4526 ** number. Return negative, zero, or positive if the first (i64) is less than,
4527 ** equal to, or greater than the second (double).
4529 int sqlite3IntFloatCompare(i64 i
, double r
){
4530 if( sqlite3IsNaN(r
) ){
4531 /* SQLite considers NaN to be a NULL. And all integer values are greater
4535 if( SqliteUseLongDouble
){
4536 LONGDOUBLE_TYPE x
= (LONGDOUBLE_TYPE
)i
;
4540 return (x
<r
) ? -1 : (x
>r
);
4543 if( r
<-9223372036854775808.0 ) return +1;
4544 if( r
>=9223372036854775808.0 ) return -1;
4546 if( i
<y
) return -1;
4547 if( i
>y
) return +1;
4548 testcase( doubleLt(((double)i
),r
) );
4549 testcase( doubleLt(r
,((double)i
)) );
4550 testcase( doubleEq(r
,((double)i
)) );
4551 return (((double)i
)<r
) ? -1 : (((double)i
)>r
);
4556 ** Compare the values contained by the two memory cells, returning
4557 ** negative, zero or positive if pMem1 is less than, equal to, or greater
4558 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
4559 ** and reals) sorted numerically, followed by text ordered by the collating
4560 ** sequence pColl and finally blob's ordered by memcmp().
4562 ** Two NULL values are considered equal by this function.
4564 int sqlite3MemCompare(const Mem
*pMem1
, const Mem
*pMem2
, const CollSeq
*pColl
){
4570 combined_flags
= f1
|f2
;
4571 assert( !sqlite3VdbeMemIsRowSet(pMem1
) && !sqlite3VdbeMemIsRowSet(pMem2
) );
4573 /* If one value is NULL, it is less than the other. If both values
4574 ** are NULL, return 0.
4576 if( combined_flags
&MEM_Null
){
4577 return (f2
&MEM_Null
) - (f1
&MEM_Null
);
4580 /* At least one of the two values is a number
4582 if( combined_flags
&(MEM_Int
|MEM_Real
|MEM_IntReal
) ){
4583 testcase( combined_flags
& MEM_Int
);
4584 testcase( combined_flags
& MEM_Real
);
4585 testcase( combined_flags
& MEM_IntReal
);
4586 if( (f1
& f2
& (MEM_Int
|MEM_IntReal
))!=0 ){
4587 testcase( f1
& f2
& MEM_Int
);
4588 testcase( f1
& f2
& MEM_IntReal
);
4589 if( pMem1
->u
.i
< pMem2
->u
.i
) return -1;
4590 if( pMem1
->u
.i
> pMem2
->u
.i
) return +1;
4593 if( (f1
& f2
& MEM_Real
)!=0 ){
4594 if( pMem1
->u
.r
< pMem2
->u
.r
) return -1;
4595 if( pMem1
->u
.r
> pMem2
->u
.r
) return +1;
4598 if( (f1
&(MEM_Int
|MEM_IntReal
))!=0 ){
4599 testcase( f1
& MEM_Int
);
4600 testcase( f1
& MEM_IntReal
);
4601 if( (f2
&MEM_Real
)!=0 ){
4602 return sqlite3IntFloatCompare(pMem1
->u
.i
, pMem2
->u
.r
);
4603 }else if( (f2
&(MEM_Int
|MEM_IntReal
))!=0 ){
4604 if( pMem1
->u
.i
< pMem2
->u
.i
) return -1;
4605 if( pMem1
->u
.i
> pMem2
->u
.i
) return +1;
4611 if( (f1
&MEM_Real
)!=0 ){
4612 if( (f2
&(MEM_Int
|MEM_IntReal
))!=0 ){
4613 testcase( f2
& MEM_Int
);
4614 testcase( f2
& MEM_IntReal
);
4615 return -sqlite3IntFloatCompare(pMem2
->u
.i
, pMem1
->u
.r
);
4623 /* If one value is a string and the other is a blob, the string is less.
4624 ** If both are strings, compare using the collating functions.
4626 if( combined_flags
&MEM_Str
){
4627 if( (f1
& MEM_Str
)==0 ){
4630 if( (f2
& MEM_Str
)==0 ){
4634 assert( pMem1
->enc
==pMem2
->enc
|| pMem1
->db
->mallocFailed
);
4635 assert( pMem1
->enc
==SQLITE_UTF8
||
4636 pMem1
->enc
==SQLITE_UTF16LE
|| pMem1
->enc
==SQLITE_UTF16BE
);
4638 /* The collation sequence must be defined at this point, even if
4639 ** the user deletes the collation sequence after the vdbe program is
4640 ** compiled (this was not always the case).
4642 assert( !pColl
|| pColl
->xCmp
);
4645 return vdbeCompareMemString(pMem1
, pMem2
, pColl
, 0);
4647 /* If a NULL pointer was passed as the collate function, fall through
4648 ** to the blob case and use memcmp(). */
4651 /* Both values must be blobs. Compare using memcmp(). */
4652 return sqlite3BlobCompare(pMem1
, pMem2
);
4657 ** The first argument passed to this function is a serial-type that
4658 ** corresponds to an integer - all values between 1 and 9 inclusive
4659 ** except 7. The second points to a buffer containing an integer value
4660 ** serialized according to serial_type. This function deserializes
4661 ** and returns the value.
4663 static i64
vdbeRecordDecodeInt(u32 serial_type
, const u8
*aKey
){
4665 assert( CORRUPT_DB
|| (serial_type
>=1 && serial_type
<=9 && serial_type
!=7) );
4666 switch( serial_type
){
4669 testcase( aKey
[0]&0x80 );
4670 return ONE_BYTE_INT(aKey
);
4672 testcase( aKey
[0]&0x80 );
4673 return TWO_BYTE_INT(aKey
);
4675 testcase( aKey
[0]&0x80 );
4676 return THREE_BYTE_INT(aKey
);
4678 testcase( aKey
[0]&0x80 );
4679 y
= FOUR_BYTE_UINT(aKey
);
4680 return (i64
)*(int*)&y
;
4683 testcase( aKey
[0]&0x80 );
4684 return FOUR_BYTE_UINT(aKey
+2) + (((i64
)1)<<32)*TWO_BYTE_INT(aKey
);
4687 u64 x
= FOUR_BYTE_UINT(aKey
);
4688 testcase( aKey
[0]&0x80 );
4689 x
= (x
<<32) | FOUR_BYTE_UINT(aKey
+4);
4690 return (i64
)*(i64
*)&x
;
4694 return (serial_type
- 8);
4698 ** This function compares the two table rows or index records
4699 ** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero
4700 ** or positive integer if key1 is less than, equal to or
4701 ** greater than key2. The {nKey1, pKey1} key must be a blob
4702 ** created by the OP_MakeRecord opcode of the VDBE. The pPKey2
4703 ** key must be a parsed key such as obtained from
4704 ** sqlite3VdbeParseRecord.
4706 ** If argument bSkip is non-zero, it is assumed that the caller has already
4707 ** determined that the first fields of the keys are equal.
4709 ** Key1 and Key2 do not have to contain the same number of fields. If all
4710 ** fields that appear in both keys are equal, then pPKey2->default_rc is
4713 ** If database corruption is discovered, set pPKey2->errCode to
4714 ** SQLITE_CORRUPT and return 0. If an OOM error is encountered,
4715 ** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the
4716 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
4718 int sqlite3VdbeRecordCompareWithSkip(
4719 int nKey1
, const void *pKey1
, /* Left key */
4720 UnpackedRecord
*pPKey2
, /* Right key */
4721 int bSkip
/* If true, skip the first field */
4723 u32 d1
; /* Offset into aKey[] of next data element */
4724 int i
; /* Index of next field to compare */
4725 u32 szHdr1
; /* Size of record header in bytes */
4726 u32 idx1
; /* Offset of first type in header */
4727 int rc
= 0; /* Return value */
4728 Mem
*pRhs
= pPKey2
->aMem
; /* Next field of pPKey2 to compare */
4730 const unsigned char *aKey1
= (const unsigned char *)pKey1
;
4733 /* If bSkip is true, then the caller has already determined that the first
4734 ** two elements in the keys are equal. Fix the various stack variables so
4735 ** that this routine begins comparing at the second field. */
4741 idx1
= 1 + sqlite3GetVarint32(&aKey1
[1], &s1
);
4744 d1
= szHdr1
+ sqlite3VdbeSerialTypeLen(s1
);
4748 if( (szHdr1
= aKey1
[0])<0x80 ){
4751 idx1
= sqlite3GetVarint32(aKey1
, &szHdr1
);
4756 if( d1
>(unsigned)nKey1
){
4757 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
4758 return 0; /* Corruption */
4761 VVA_ONLY( mem1
.szMalloc
= 0; ) /* Only needed by assert() statements */
4762 assert( pPKey2
->pKeyInfo
->nAllField
>=pPKey2
->nField
4764 assert( pPKey2
->pKeyInfo
->aSortFlags
!=0 );
4765 assert( pPKey2
->pKeyInfo
->nKeyField
>0 );
4766 assert( idx1
<=szHdr1
|| CORRUPT_DB
);
4767 while( 1 /*exit-by-break*/ ){
4770 /* RHS is an integer */
4771 if( pRhs
->flags
& (MEM_Int
|MEM_IntReal
) ){
4772 testcase( pRhs
->flags
& MEM_Int
);
4773 testcase( pRhs
->flags
& MEM_IntReal
);
4774 serial_type
= aKey1
[idx1
];
4775 testcase( serial_type
==12 );
4776 if( serial_type
>=10 ){
4777 rc
= serial_type
==10 ? -1 : +1;
4778 }else if( serial_type
==0 ){
4780 }else if( serial_type
==7 ){
4781 serialGet7(&aKey1
[d1
], &mem1
);
4782 rc
= -sqlite3IntFloatCompare(pRhs
->u
.i
, mem1
.u
.r
);
4784 i64 lhs
= vdbeRecordDecodeInt(serial_type
, &aKey1
[d1
]);
4785 i64 rhs
= pRhs
->u
.i
;
4788 }else if( lhs
>rhs
){
4795 else if( pRhs
->flags
& MEM_Real
){
4796 serial_type
= aKey1
[idx1
];
4797 if( serial_type
>=10 ){
4798 /* Serial types 12 or greater are strings and blobs (greater than
4799 ** numbers). Types 10 and 11 are currently "reserved for future
4800 ** use", so it doesn't really matter what the results of comparing
4801 ** them to numeric values are. */
4802 rc
= serial_type
==10 ? -1 : +1;
4803 }else if( serial_type
==0 ){
4806 if( serial_type
==7 ){
4807 if( serialGet7(&aKey1
[d1
], &mem1
) ){
4808 rc
= -1; /* mem1 is a NaN */
4809 }else if( mem1
.u
.r
<pRhs
->u
.r
){
4811 }else if( mem1
.u
.r
>pRhs
->u
.r
){
4817 sqlite3VdbeSerialGet(&aKey1
[d1
], serial_type
, &mem1
);
4818 rc
= sqlite3IntFloatCompare(mem1
.u
.i
, pRhs
->u
.r
);
4823 /* RHS is a string */
4824 else if( pRhs
->flags
& MEM_Str
){
4825 getVarint32NR(&aKey1
[idx1
], serial_type
);
4826 testcase( serial_type
==12 );
4827 if( serial_type
<12 ){
4829 }else if( !(serial_type
& 0x01) ){
4832 mem1
.n
= (serial_type
- 12) / 2;
4833 testcase( (d1
+mem1
.n
)==(unsigned)nKey1
);
4834 testcase( (d1
+mem1
.n
+1)==(unsigned)nKey1
);
4835 if( (d1
+mem1
.n
) > (unsigned)nKey1
4836 || (pKeyInfo
= pPKey2
->pKeyInfo
)->nAllField
<=i
4838 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
4839 return 0; /* Corruption */
4840 }else if( pKeyInfo
->aColl
[i
] ){
4841 mem1
.enc
= pKeyInfo
->enc
;
4842 mem1
.db
= pKeyInfo
->db
;
4843 mem1
.flags
= MEM_Str
;
4844 mem1
.z
= (char*)&aKey1
[d1
];
4845 rc
= vdbeCompareMemString(
4846 &mem1
, pRhs
, pKeyInfo
->aColl
[i
], &pPKey2
->errCode
4849 int nCmp
= MIN(mem1
.n
, pRhs
->n
);
4850 rc
= memcmp(&aKey1
[d1
], pRhs
->z
, nCmp
);
4851 if( rc
==0 ) rc
= mem1
.n
- pRhs
->n
;
4857 else if( pRhs
->flags
& MEM_Blob
){
4858 assert( (pRhs
->flags
& MEM_Zero
)==0 || pRhs
->n
==0 );
4859 getVarint32NR(&aKey1
[idx1
], serial_type
);
4860 testcase( serial_type
==12 );
4861 if( serial_type
<12 || (serial_type
& 0x01) ){
4864 int nStr
= (serial_type
- 12) / 2;
4865 testcase( (d1
+nStr
)==(unsigned)nKey1
);
4866 testcase( (d1
+nStr
+1)==(unsigned)nKey1
);
4867 if( (d1
+nStr
) > (unsigned)nKey1
){
4868 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
4869 return 0; /* Corruption */
4870 }else if( pRhs
->flags
& MEM_Zero
){
4871 if( !isAllZero((const char*)&aKey1
[d1
],nStr
) ){
4874 rc
= nStr
- pRhs
->u
.nZero
;
4877 int nCmp
= MIN(nStr
, pRhs
->n
);
4878 rc
= memcmp(&aKey1
[d1
], pRhs
->z
, nCmp
);
4879 if( rc
==0 ) rc
= nStr
- pRhs
->n
;
4886 serial_type
= aKey1
[idx1
];
4889 || (serial_type
==7 && serialGet7(&aKey1
[d1
], &mem1
)!=0)
4898 int sortFlags
= pPKey2
->pKeyInfo
->aSortFlags
[i
];
4900 if( (sortFlags
& KEYINFO_ORDER_BIGNULL
)==0
4901 || ((sortFlags
& KEYINFO_ORDER_DESC
)
4902 !=(serial_type
==0 || (pRhs
->flags
&MEM_Null
)))
4907 assert( vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, rc
) );
4908 assert( mem1
.szMalloc
==0 ); /* See comment below */
4913 if( i
==pPKey2
->nField
) break;
4915 d1
+= sqlite3VdbeSerialTypeLen(serial_type
);
4916 if( d1
>(unsigned)nKey1
) break;
4917 idx1
+= sqlite3VarintLen(serial_type
);
4918 if( idx1
>=(unsigned)szHdr1
){
4919 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
4920 return 0; /* Corrupt index */
4924 /* No memory allocation is ever used on mem1. Prove this using
4925 ** the following assert(). If the assert() fails, it indicates a
4926 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */
4927 assert( mem1
.szMalloc
==0 );
4929 /* rc==0 here means that one or both of the keys ran out of fields and
4930 ** all the fields up to that point were equal. Return the default_rc
4933 || vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, pPKey2
->default_rc
)
4934 || pPKey2
->pKeyInfo
->db
->mallocFailed
4937 return pPKey2
->default_rc
;
4939 int sqlite3VdbeRecordCompare(
4940 int nKey1
, const void *pKey1
, /* Left key */
4941 UnpackedRecord
*pPKey2
/* Right key */
4943 return sqlite3VdbeRecordCompareWithSkip(nKey1
, pKey1
, pPKey2
, 0);
4948 ** This function is an optimized version of sqlite3VdbeRecordCompare()
4949 ** that (a) the first field of pPKey2 is an integer, and (b) the
4950 ** size-of-header varint at the start of (pKey1/nKey1) fits in a single
4951 ** byte (i.e. is less than 128).
4953 ** To avoid concerns about buffer overreads, this routine is only used
4954 ** on schemas where the maximum valid header size is 63 bytes or less.
4956 static int vdbeRecordCompareInt(
4957 int nKey1
, const void *pKey1
, /* Left key */
4958 UnpackedRecord
*pPKey2
/* Right key */
4960 const u8
*aKey
= &((const u8
*)pKey1
)[*(const u8
*)pKey1
& 0x3F];
4961 int serial_type
= ((const u8
*)pKey1
)[1];
4968 vdbeAssertFieldCountWithinLimits(nKey1
, pKey1
, pPKey2
->pKeyInfo
);
4969 assert( (*(u8
*)pKey1
)<=0x3F || CORRUPT_DB
);
4970 switch( serial_type
){
4971 case 1: { /* 1-byte signed integer */
4972 lhs
= ONE_BYTE_INT(aKey
);
4976 case 2: { /* 2-byte signed integer */
4977 lhs
= TWO_BYTE_INT(aKey
);
4981 case 3: { /* 3-byte signed integer */
4982 lhs
= THREE_BYTE_INT(aKey
);
4986 case 4: { /* 4-byte signed integer */
4987 y
= FOUR_BYTE_UINT(aKey
);
4988 lhs
= (i64
)*(int*)&y
;
4992 case 5: { /* 6-byte signed integer */
4993 lhs
= FOUR_BYTE_UINT(aKey
+2) + (((i64
)1)<<32)*TWO_BYTE_INT(aKey
);
4997 case 6: { /* 8-byte signed integer */
4998 x
= FOUR_BYTE_UINT(aKey
);
4999 x
= (x
<<32) | FOUR_BYTE_UINT(aKey
+4);
5011 /* This case could be removed without changing the results of running
5012 ** this code. Including it causes gcc to generate a faster switch
5013 ** statement (since the range of switch targets now starts at zero and
5014 ** is contiguous) but does not cause any duplicate code to be generated
5015 ** (as gcc is clever enough to combine the two like cases). Other
5016 ** compilers might be similar. */
5018 return sqlite3VdbeRecordCompare(nKey1
, pKey1
, pPKey2
);
5021 return sqlite3VdbeRecordCompare(nKey1
, pKey1
, pPKey2
);
5024 assert( pPKey2
->u
.i
== pPKey2
->aMem
[0].u
.i
);
5030 }else if( pPKey2
->nField
>1 ){
5031 /* The first fields of the two keys are equal. Compare the trailing
5033 res
= sqlite3VdbeRecordCompareWithSkip(nKey1
, pKey1
, pPKey2
, 1);
5035 /* The first fields of the two keys are equal and there are no trailing
5036 ** fields. Return pPKey2->default_rc in this case. */
5037 res
= pPKey2
->default_rc
;
5041 assert( vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, res
) );
5046 ** This function is an optimized version of sqlite3VdbeRecordCompare()
5047 ** that (a) the first field of pPKey2 is a string, that (b) the first field
5048 ** uses the collation sequence BINARY and (c) that the size-of-header varint
5049 ** at the start of (pKey1/nKey1) fits in a single byte.
5051 static int vdbeRecordCompareString(
5052 int nKey1
, const void *pKey1
, /* Left key */
5053 UnpackedRecord
*pPKey2
/* Right key */
5055 const u8
*aKey1
= (const u8
*)pKey1
;
5059 assert( pPKey2
->aMem
[0].flags
& MEM_Str
);
5060 assert( pPKey2
->aMem
[0].n
== pPKey2
->n
);
5061 assert( pPKey2
->aMem
[0].z
== pPKey2
->u
.z
);
5062 vdbeAssertFieldCountWithinLimits(nKey1
, pKey1
, pPKey2
->pKeyInfo
);
5063 serial_type
= (signed char)(aKey1
[1]);
5066 if( serial_type
<12 ){
5067 if( serial_type
<0 ){
5068 sqlite3GetVarint32(&aKey1
[1], (u32
*)&serial_type
);
5069 if( serial_type
>=12 ) goto vrcs_restart
;
5070 assert( CORRUPT_DB
);
5072 res
= pPKey2
->r1
; /* (pKey1/nKey1) is a number or a null */
5073 }else if( !(serial_type
& 0x01) ){
5074 res
= pPKey2
->r2
; /* (pKey1/nKey1) is a blob */
5078 int szHdr
= aKey1
[0];
5080 nStr
= (serial_type
-12) / 2;
5081 if( (szHdr
+ nStr
) > nKey1
){
5082 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
5083 return 0; /* Corruption */
5085 nCmp
= MIN( pPKey2
->n
, nStr
);
5086 res
= memcmp(&aKey1
[szHdr
], pPKey2
->u
.z
, nCmp
);
5093 res
= nStr
- pPKey2
->n
;
5095 if( pPKey2
->nField
>1 ){
5096 res
= sqlite3VdbeRecordCompareWithSkip(nKey1
, pKey1
, pPKey2
, 1);
5098 res
= pPKey2
->default_rc
;
5109 assert( vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, res
)
5111 || pPKey2
->pKeyInfo
->db
->mallocFailed
5117 ** Return a pointer to an sqlite3VdbeRecordCompare() compatible function
5118 ** suitable for comparing serialized records to the unpacked record passed
5119 ** as the only argument.
5121 RecordCompare
sqlite3VdbeFindCompare(UnpackedRecord
*p
){
5122 /* varintRecordCompareInt() and varintRecordCompareString() both assume
5123 ** that the size-of-header varint that occurs at the start of each record
5124 ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt()
5125 ** also assumes that it is safe to overread a buffer by at least the
5126 ** maximum possible legal header size plus 8 bytes. Because there is
5127 ** guaranteed to be at least 74 (but not 136) bytes of padding following each
5128 ** buffer passed to varintRecordCompareInt() this makes it convenient to
5129 ** limit the size of the header to 64 bytes in cases where the first field
5132 ** The easiest way to enforce this limit is to consider only records with
5133 ** 13 fields or less. If the first field is an integer, the maximum legal
5134 ** header size is (12*5 + 1 + 1) bytes. */
5135 if( p
->pKeyInfo
->nAllField
<=13 ){
5136 int flags
= p
->aMem
[0].flags
;
5137 if( p
->pKeyInfo
->aSortFlags
[0] ){
5138 if( p
->pKeyInfo
->aSortFlags
[0] & KEYINFO_ORDER_BIGNULL
){
5139 return sqlite3VdbeRecordCompare
;
5147 if( (flags
& MEM_Int
) ){
5148 p
->u
.i
= p
->aMem
[0].u
.i
;
5149 return vdbeRecordCompareInt
;
5151 testcase( flags
& MEM_Real
);
5152 testcase( flags
& MEM_Null
);
5153 testcase( flags
& MEM_Blob
);
5154 if( (flags
& (MEM_Real
|MEM_IntReal
|MEM_Null
|MEM_Blob
))==0
5155 && p
->pKeyInfo
->aColl
[0]==0
5157 assert( flags
& MEM_Str
);
5158 p
->u
.z
= p
->aMem
[0].z
;
5159 p
->n
= p
->aMem
[0].n
;
5160 return vdbeRecordCompareString
;
5164 return sqlite3VdbeRecordCompare
;
5168 ** pCur points at an index entry created using the OP_MakeRecord opcode.
5169 ** Read the rowid (the last field in the record) and store it in *rowid.
5170 ** Return SQLITE_OK if everything works, or an error code otherwise.
5172 ** pCur might be pointing to text obtained from a corrupt database file.
5173 ** So the content cannot be trusted. Do appropriate checks on the content.
5175 int sqlite3VdbeIdxRowid(sqlite3
*db
, BtCursor
*pCur
, i64
*rowid
){
5178 u32 szHdr
; /* Size of the header */
5179 u32 typeRowid
; /* Serial type of the rowid */
5180 u32 lenRowid
; /* Size of the rowid */
5183 /* Get the size of the index entry. Only indices entries of less
5184 ** than 2GiB are support - anything large must be database corruption.
5185 ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so
5186 ** this code can safely assume that nCellKey is 32-bits
5188 assert( sqlite3BtreeCursorIsValid(pCur
) );
5189 nCellKey
= sqlite3BtreePayloadSize(pCur
);
5190 assert( (nCellKey
& SQLITE_MAX_U32
)==(u64
)nCellKey
);
5192 /* Read in the complete content of the index entry */
5193 sqlite3VdbeMemInit(&m
, db
, 0);
5194 rc
= sqlite3VdbeMemFromBtreeZeroOffset(pCur
, (u32
)nCellKey
, &m
);
5199 /* The index entry must begin with a header size */
5200 getVarint32NR((u8
*)m
.z
, szHdr
);
5201 testcase( szHdr
==3 );
5202 testcase( szHdr
==(u32
)m
.n
);
5203 testcase( szHdr
>0x7fffffff );
5205 if( unlikely(szHdr
<3 || szHdr
>(unsigned)m
.n
) ){
5206 goto idx_rowid_corruption
;
5209 /* The last field of the index should be an integer - the ROWID.
5210 ** Verify that the last entry really is an integer. */
5211 getVarint32NR((u8
*)&m
.z
[szHdr
-1], typeRowid
);
5212 testcase( typeRowid
==1 );
5213 testcase( typeRowid
==2 );
5214 testcase( typeRowid
==3 );
5215 testcase( typeRowid
==4 );
5216 testcase( typeRowid
==5 );
5217 testcase( typeRowid
==6 );
5218 testcase( typeRowid
==8 );
5219 testcase( typeRowid
==9 );
5220 if( unlikely(typeRowid
<1 || typeRowid
>9 || typeRowid
==7) ){
5221 goto idx_rowid_corruption
;
5223 lenRowid
= sqlite3SmallTypeSizes
[typeRowid
];
5224 testcase( (u32
)m
.n
==szHdr
+lenRowid
);
5225 if( unlikely((u32
)m
.n
<szHdr
+lenRowid
) ){
5226 goto idx_rowid_corruption
;
5229 /* Fetch the integer off the end of the index record */
5230 sqlite3VdbeSerialGet((u8
*)&m
.z
[m
.n
-lenRowid
], typeRowid
, &v
);
5232 sqlite3VdbeMemReleaseMalloc(&m
);
5235 /* Jump here if database corruption is detected after m has been
5236 ** allocated. Free the m object and return SQLITE_CORRUPT. */
5237 idx_rowid_corruption
:
5238 testcase( m
.szMalloc
!=0 );
5239 sqlite3VdbeMemReleaseMalloc(&m
);
5240 return SQLITE_CORRUPT_BKPT
;
5244 ** Compare the key of the index entry that cursor pC is pointing to against
5245 ** the key string in pUnpacked. Write into *pRes a number
5246 ** that is negative, zero, or positive if pC is less than, equal to,
5247 ** or greater than pUnpacked. Return SQLITE_OK on success.
5249 ** pUnpacked is either created without a rowid or is truncated so that it
5250 ** omits the rowid at the end. The rowid at the end of the index entry
5251 ** is ignored as well. Hence, this routine only compares the prefixes
5252 ** of the keys prior to the final rowid, not the entire key.
5254 int sqlite3VdbeIdxKeyCompare(
5255 sqlite3
*db
, /* Database connection */
5256 VdbeCursor
*pC
, /* The cursor to compare against */
5257 UnpackedRecord
*pUnpacked
, /* Unpacked version of key */
5258 int *res
/* Write the comparison result here */
5265 assert( pC
->eCurType
==CURTYPE_BTREE
);
5266 pCur
= pC
->uc
.pCursor
;
5267 assert( sqlite3BtreeCursorIsValid(pCur
) );
5268 nCellKey
= sqlite3BtreePayloadSize(pCur
);
5269 /* nCellKey will always be between 0 and 0xffffffff because of the way
5270 ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
5271 if( nCellKey
<=0 || nCellKey
>0x7fffffff ){
5273 return SQLITE_CORRUPT_BKPT
;
5275 sqlite3VdbeMemInit(&m
, db
, 0);
5276 rc
= sqlite3VdbeMemFromBtreeZeroOffset(pCur
, (u32
)nCellKey
, &m
);
5280 *res
= sqlite3VdbeRecordCompareWithSkip(m
.n
, m
.z
, pUnpacked
, 0);
5281 sqlite3VdbeMemReleaseMalloc(&m
);
5286 ** This routine sets the value to be returned by subsequent calls to
5287 ** sqlite3_changes() on the database handle 'db'.
5289 void sqlite3VdbeSetChanges(sqlite3
*db
, i64 nChange
){
5290 assert( sqlite3_mutex_held(db
->mutex
) );
5291 db
->nChange
= nChange
;
5292 db
->nTotalChange
+= nChange
;
5296 ** Set a flag in the vdbe to update the change counter when it is finalised
5299 void sqlite3VdbeCountChanges(Vdbe
*v
){
5304 ** Mark every prepared statement associated with a database connection
5307 ** An expired statement means that recompilation of the statement is
5308 ** recommend. Statements expire when things happen that make their
5309 ** programs obsolete. Removing user-defined functions or collating
5310 ** sequences, or changing an authorization function are the types of
5311 ** things that make prepared statements obsolete.
5313 ** If iCode is 1, then expiration is advisory. The statement should
5314 ** be reprepared before being restarted, but if it is already running
5315 ** it is allowed to run to completion.
5317 ** Internally, this function just sets the Vdbe.expired flag on all
5318 ** prepared statements. The flag is set to 1 for an immediate expiration
5319 ** and set to 2 for an advisory expiration.
5321 void sqlite3ExpirePreparedStatements(sqlite3
*db
, int iCode
){
5323 for(p
= db
->pVdbe
; p
; p
=p
->pVNext
){
5324 p
->expired
= iCode
+1;
5329 ** Return the database associated with the Vdbe.
5331 sqlite3
*sqlite3VdbeDb(Vdbe
*v
){
5336 ** Return the SQLITE_PREPARE flags for a Vdbe.
5338 u8
sqlite3VdbePrepareFlags(Vdbe
*v
){
5339 return v
->prepFlags
;
5343 ** Return a pointer to an sqlite3_value structure containing the value bound
5344 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
5345 ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_*
5346 ** constants) to the value before returning it.
5348 ** The returned value must be freed by the caller using sqlite3ValueFree().
5350 sqlite3_value
*sqlite3VdbeGetBoundValue(Vdbe
*v
, int iVar
, u8 aff
){
5353 Mem
*pMem
= &v
->aVar
[iVar
-1];
5354 assert( (v
->db
->flags
& SQLITE_EnableQPSG
)==0
5355 || (v
->db
->mDbFlags
& DBFLAG_InternalFunc
)!=0 );
5356 if( 0==(pMem
->flags
& MEM_Null
) ){
5357 sqlite3_value
*pRet
= sqlite3ValueNew(v
->db
);
5359 sqlite3VdbeMemCopy((Mem
*)pRet
, pMem
);
5360 sqlite3ValueApplyAffinity(pRet
, aff
, SQLITE_UTF8
);
5369 ** Configure SQL variable iVar so that binding a new value to it signals
5370 ** to sqlite3_reoptimize() that re-preparing the statement may result
5371 ** in a better query plan.
5373 void sqlite3VdbeSetVarmask(Vdbe
*v
, int iVar
){
5375 assert( (v
->db
->flags
& SQLITE_EnableQPSG
)==0
5376 || (v
->db
->mDbFlags
& DBFLAG_InternalFunc
)!=0 );
5378 v
->expmask
|= 0x80000000;
5380 v
->expmask
|= ((u32
)1 << (iVar
-1));
5385 ** Cause a function to throw an error if it was call from OP_PureFunc
5386 ** rather than OP_Function.
5388 ** OP_PureFunc means that the function must be deterministic, and should
5389 ** throw an error if it is given inputs that would make it non-deterministic.
5390 ** This routine is invoked by date/time functions that use non-deterministic
5391 ** features such as 'now'.
5393 int sqlite3NotPureFunc(sqlite3_context
*pCtx
){
5395 #ifdef SQLITE_ENABLE_STAT4
5396 if( pCtx
->pVdbe
==0 ) return 1;
5398 pOp
= pCtx
->pVdbe
->aOp
+ pCtx
->iOp
;
5399 if( pOp
->opcode
==OP_PureFunc
){
5400 const char *zContext
;
5402 if( pOp
->p5
& NC_IsCheck
){
5403 zContext
= "a CHECK constraint";
5404 }else if( pOp
->p5
& NC_GenCol
){
5405 zContext
= "a generated column";
5407 zContext
= "an index";
5409 zMsg
= sqlite3_mprintf("non-deterministic use of %s() in %s",
5410 pCtx
->pFunc
->zName
, zContext
);
5411 sqlite3_result_error(pCtx
, zMsg
, -1);
5418 #if defined(SQLITE_ENABLE_CURSOR_HINTS) && defined(SQLITE_DEBUG)
5420 ** This Walker callback is used to help verify that calls to
5421 ** sqlite3BtreeCursorHint() with opcode BTREE_HINT_RANGE have
5422 ** byte-code register values correctly initialized.
5424 int sqlite3CursorRangeHintExprCheck(Walker
*pWalker
, Expr
*pExpr
){
5425 if( pExpr
->op
==TK_REGISTER
){
5426 assert( (pWalker
->u
.aMem
[pExpr
->iTable
].flags
& MEM_Undefined
)==0 );
5428 return WRC_Continue
;
5430 #endif /* SQLITE_ENABLE_CURSOR_HINTS && SQLITE_DEBUG */
5432 #ifndef SQLITE_OMIT_VIRTUALTABLE
5434 ** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored
5435 ** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored
5436 ** in memory obtained from sqlite3DbMalloc).
5438 void sqlite3VtabImportErrmsg(Vdbe
*p
, sqlite3_vtab
*pVtab
){
5439 if( pVtab
->zErrMsg
){
5440 sqlite3
*db
= p
->db
;
5441 sqlite3DbFree(db
, p
->zErrMsg
);
5442 p
->zErrMsg
= sqlite3DbStrDup(db
, pVtab
->zErrMsg
);
5443 sqlite3_free(pVtab
->zErrMsg
);
5447 #endif /* SQLITE_OMIT_VIRTUALTABLE */
5449 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
5452 ** If the second argument is not NULL, release any allocations associated
5453 ** with the memory cells in the p->aMem[] array. Also free the UnpackedRecord
5454 ** structure itself, using sqlite3DbFree().
5456 ** This function is used to free UnpackedRecord structures allocated by
5457 ** the vdbeUnpackRecord() function found in vdbeapi.c.
5459 static void vdbeFreeUnpacked(sqlite3
*db
, int nField
, UnpackedRecord
*p
){
5463 for(i
=0; i
<nField
; i
++){
5464 Mem
*pMem
= &p
->aMem
[i
];
5465 if( pMem
->zMalloc
) sqlite3VdbeMemReleaseMalloc(pMem
);
5467 sqlite3DbNNFreeNN(db
, p
);
5470 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
5472 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
5474 ** Invoke the pre-update hook. If this is an UPDATE or DELETE pre-update call,
5475 ** then cursor passed as the second argument should point to the row about
5476 ** to be update or deleted. If the application calls sqlite3_preupdate_old(),
5477 ** the required value will be read from the row the cursor points to.
5479 void sqlite3VdbePreUpdateHook(
5480 Vdbe
*v
, /* Vdbe pre-update hook is invoked by */
5481 VdbeCursor
*pCsr
, /* Cursor to grab old.* values from */
5482 int op
, /* SQLITE_INSERT, UPDATE or DELETE */
5483 const char *zDb
, /* Database name */
5484 Table
*pTab
, /* Modified table */
5485 i64 iKey1
, /* Initial key value */
5486 int iReg
, /* Register for new.* record */
5489 sqlite3
*db
= v
->db
;
5491 PreUpdate preupdate
;
5492 const char *zTbl
= pTab
->zName
;
5493 static const u8 fakeSortOrder
= 0;
5496 if( pTab
->tabFlags
& TF_WithoutRowid
){
5497 nRealCol
= sqlite3PrimaryKeyIndex(pTab
)->nColumn
;
5498 }else if( pTab
->tabFlags
& TF_HasVirtual
){
5499 nRealCol
= pTab
->nNVCol
;
5501 nRealCol
= pTab
->nCol
;
5505 assert( db
->pPreUpdate
==0 );
5506 memset(&preupdate
, 0, sizeof(PreUpdate
));
5507 if( HasRowid(pTab
)==0 ){
5509 preupdate
.pPk
= sqlite3PrimaryKeyIndex(pTab
);
5511 if( op
==SQLITE_UPDATE
){
5512 iKey2
= v
->aMem
[iReg
].u
.i
;
5519 assert( pCsr
->eCurType
==CURTYPE_BTREE
);
5520 assert( pCsr
->nField
==nRealCol
5521 || (pCsr
->nField
==nRealCol
+1 && op
==SQLITE_DELETE
&& iReg
==-1)
5525 preupdate
.pCsr
= pCsr
;
5527 preupdate
.iNewReg
= iReg
;
5528 preupdate
.keyinfo
.db
= db
;
5529 preupdate
.keyinfo
.enc
= ENC(db
);
5530 preupdate
.keyinfo
.nKeyField
= pTab
->nCol
;
5531 preupdate
.keyinfo
.aSortFlags
= (u8
*)&fakeSortOrder
;
5532 preupdate
.iKey1
= iKey1
;
5533 preupdate
.iKey2
= iKey2
;
5534 preupdate
.pTab
= pTab
;
5535 preupdate
.iBlobWrite
= iBlobWrite
;
5537 db
->pPreUpdate
= &preupdate
;
5538 db
->xPreUpdateCallback(db
->pPreUpdateArg
, db
, op
, zDb
, zTbl
, iKey1
, iKey2
);
5540 sqlite3DbFree(db
, preupdate
.aRecord
);
5541 vdbeFreeUnpacked(db
, preupdate
.keyinfo
.nKeyField
+1, preupdate
.pUnpacked
);
5542 vdbeFreeUnpacked(db
, preupdate
.keyinfo
.nKeyField
+1, preupdate
.pNewUnpacked
);
5543 if( preupdate
.aNew
){
5545 for(i
=0; i
<pCsr
->nField
; i
++){
5546 sqlite3VdbeMemRelease(&preupdate
.aNew
[i
]);
5548 sqlite3DbNNFreeNN(db
, preupdate
.aNew
);
5550 if( preupdate
.apDflt
){
5552 for(i
=0; i
<pTab
->nCol
; i
++){
5553 sqlite3ValueFree(preupdate
.apDflt
[i
]);
5555 sqlite3DbFree(db
, preupdate
.apDflt
);
5558 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */