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"
19 ** Create a new virtual database engine.
21 Vdbe
*sqlite3VdbeCreate(Parse
*pParse
){
22 sqlite3
*db
= pParse
->db
;
24 p
= sqlite3DbMallocZero(db
, sizeof(Vdbe
) );
33 p
->magic
= VDBE_MAGIC_INIT
;
35 assert( pParse
->aLabel
==0 );
36 assert( pParse
->nLabel
==0 );
37 assert( pParse
->nOpAlloc
==0 );
38 assert( pParse
->szOpAlloc
==0 );
43 ** Change the error string stored in Vdbe.zErrMsg
45 void sqlite3VdbeError(Vdbe
*p
, const char *zFormat
, ...){
47 sqlite3DbFree(p
->db
, p
->zErrMsg
);
48 va_start(ap
, zFormat
);
49 p
->zErrMsg
= sqlite3VMPrintf(p
->db
, zFormat
, ap
);
54 ** Remember the SQL string for a prepared statement.
56 void sqlite3VdbeSetSql(Vdbe
*p
, const char *z
, int n
, int isPrepareV2
){
57 assert( isPrepareV2
==1 || isPrepareV2
==0 );
59 #if defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_ENABLE_SQLLOG)
60 if( !isPrepareV2
) return;
63 p
->zSql
= sqlite3DbStrNDup(p
->db
, z
, n
);
64 p
->isPrepareV2
= (u8
)isPrepareV2
;
68 ** Swap all content between two VDBE structures.
70 void sqlite3VdbeSwap(Vdbe
*pA
, Vdbe
*pB
){
73 assert( pA
->db
==pB
->db
);
78 pA
->pNext
= pB
->pNext
;
81 pA
->pPrev
= pB
->pPrev
;
86 pB
->isPrepareV2
= pA
->isPrepareV2
;
90 ** Resize the Vdbe.aOp array so that it is at least nOp elements larger
91 ** than its current size. nOp is guaranteed to be less than or equal
92 ** to 1024/sizeof(Op).
94 ** If an out-of-memory error occurs while resizing the array, return
95 ** SQLITE_NOMEM. In this case Vdbe.aOp and Parse.nOpAlloc remain
96 ** unchanged (this is so that any opcodes already allocated can be
97 ** correctly deallocated along with the rest of the Vdbe).
99 static int growOpArray(Vdbe
*v
, int nOp
){
101 Parse
*p
= v
->pParse
;
103 /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
104 ** more frequent reallocs and hence provide more opportunities for
105 ** simulated OOM faults. SQLITE_TEST_REALLOC_STRESS is generally used
106 ** during testing only. With SQLITE_TEST_REALLOC_STRESS grow the op array
107 ** by the minimum* amount required until the size reaches 512. Normal
108 ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
109 ** size of the op array or add 1KB of space, whichever is smaller. */
110 #ifdef SQLITE_TEST_REALLOC_STRESS
111 int nNew
= (p
->nOpAlloc
>=512 ? p
->nOpAlloc
*2 : p
->nOpAlloc
+nOp
);
113 int nNew
= (p
->nOpAlloc
? p
->nOpAlloc
*2 : (int)(1024/sizeof(Op
)));
114 UNUSED_PARAMETER(nOp
);
117 assert( nOp
<=(1024/sizeof(Op
)) );
118 assert( nNew
>=(p
->nOpAlloc
+nOp
) );
119 pNew
= sqlite3DbRealloc(p
->db
, v
->aOp
, nNew
*sizeof(Op
));
121 p
->szOpAlloc
= sqlite3DbMallocSize(p
->db
, pNew
);
122 p
->nOpAlloc
= p
->szOpAlloc
/sizeof(Op
);
125 return (pNew
? SQLITE_OK
: SQLITE_NOMEM_BKPT
);
129 /* This routine is just a convenient place to set a breakpoint that will
130 ** fire after each opcode is inserted and displayed using
131 ** "PRAGMA vdbe_addoptrace=on".
133 static void test_addop_breakpoint(void){
140 ** Add a new instruction to the list of instructions current in the
141 ** VDBE. Return the address of the new instruction.
145 ** p Pointer to the VDBE
147 ** op The opcode for this instruction
149 ** p1, p2, p3 Operands
151 ** Use the sqlite3VdbeResolveLabel() function to fix an address and
152 ** the sqlite3VdbeChangeP4() function to change the value of the P4
155 static SQLITE_NOINLINE
int growOp3(Vdbe
*p
, int op
, int p1
, int p2
, int p3
){
156 assert( p
->pParse
->nOpAlloc
<=p
->nOp
);
157 if( growOpArray(p
, 1) ) return 1;
158 assert( p
->pParse
->nOpAlloc
>p
->nOp
);
159 return sqlite3VdbeAddOp3(p
, op
, p1
, p2
, p3
);
161 int sqlite3VdbeAddOp3(Vdbe
*p
, int op
, int p1
, int p2
, int p3
){
166 assert( p
->magic
==VDBE_MAGIC_INIT
);
167 assert( op
>=0 && op
<0xff );
168 if( p
->pParse
->nOpAlloc
<=i
){
169 return growOp3(p
, op
, p1
, p2
, p3
);
173 pOp
->opcode
= (u8
)op
;
179 pOp
->p4type
= P4_NOTUSED
;
180 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
184 if( p
->db
->flags
& SQLITE_VdbeAddopTrace
){
186 Parse
*pParse
= p
->pParse
;
187 for(jj
=kk
=0; jj
<SQLITE_N_COLCACHE
; jj
++){
188 struct yColCache
*x
= pParse
->aColCache
+ jj
;
189 if( x
->iLevel
>pParse
->iCacheLevel
|| x
->iReg
==0 ) continue;
190 printf(" r[%d]={%d:%d}", x
->iReg
, x
->iTable
, x
->iColumn
);
193 if( kk
) printf("\n");
194 sqlite3VdbePrintOp(0, i
, &p
->aOp
[i
]);
195 test_addop_breakpoint();
202 #ifdef SQLITE_VDBE_COVERAGE
207 int sqlite3VdbeAddOp0(Vdbe
*p
, int op
){
208 return sqlite3VdbeAddOp3(p
, op
, 0, 0, 0);
210 int sqlite3VdbeAddOp1(Vdbe
*p
, int op
, int p1
){
211 return sqlite3VdbeAddOp3(p
, op
, p1
, 0, 0);
213 int sqlite3VdbeAddOp2(Vdbe
*p
, int op
, int p1
, int p2
){
214 return sqlite3VdbeAddOp3(p
, op
, p1
, p2
, 0);
217 /* Generate code for an unconditional jump to instruction iDest
219 int sqlite3VdbeGoto(Vdbe
*p
, int iDest
){
220 return sqlite3VdbeAddOp3(p
, OP_Goto
, 0, iDest
, 0);
223 /* Generate code to cause the string zStr to be loaded into
226 int sqlite3VdbeLoadString(Vdbe
*p
, int iDest
, const char *zStr
){
227 return sqlite3VdbeAddOp4(p
, OP_String8
, 0, iDest
, 0, zStr
, 0);
231 ** Generate code that initializes multiple registers to string or integer
232 ** constants. The registers begin with iDest and increase consecutively.
233 ** One register is initialized for each characgter in zTypes[]. For each
234 ** "s" character in zTypes[], the register is a string if the argument is
235 ** not NULL, or OP_Null if the value is a null pointer. For each "i" character
236 ** in zTypes[], the register is initialized to an integer.
238 void sqlite3VdbeMultiLoad(Vdbe
*p
, int iDest
, const char *zTypes
, ...){
242 va_start(ap
, zTypes
);
243 for(i
=0; (c
= zTypes
[i
])!=0; i
++){
245 const char *z
= va_arg(ap
, const char*);
246 sqlite3VdbeAddOp4(p
, z
==0 ? OP_Null
: OP_String8
, 0, iDest
++, 0, z
, 0);
249 sqlite3VdbeAddOp2(p
, OP_Integer
, va_arg(ap
, int), iDest
++);
256 ** Add an opcode that includes the p4 value as a pointer.
258 int sqlite3VdbeAddOp4(
259 Vdbe
*p
, /* Add the opcode to this VM */
260 int op
, /* The new opcode */
261 int p1
, /* The P1 operand */
262 int p2
, /* The P2 operand */
263 int p3
, /* The P3 operand */
264 const char *zP4
, /* The P4 operand */
265 int p4type
/* P4 operand type */
267 int addr
= sqlite3VdbeAddOp3(p
, op
, p1
, p2
, p3
);
268 sqlite3VdbeChangeP4(p
, addr
, zP4
, p4type
);
273 ** Add an opcode that includes the p4 value with a P4_INT64 or
276 int sqlite3VdbeAddOp4Dup8(
277 Vdbe
*p
, /* Add the opcode to this VM */
278 int op
, /* The new opcode */
279 int p1
, /* The P1 operand */
280 int p2
, /* The P2 operand */
281 int p3
, /* The P3 operand */
282 const u8
*zP4
, /* The P4 operand */
283 int p4type
/* P4 operand type */
285 char *p4copy
= sqlite3DbMallocRawNN(sqlite3VdbeDb(p
), 8);
286 if( p4copy
) memcpy(p4copy
, zP4
, 8);
287 return sqlite3VdbeAddOp4(p
, op
, p1
, p2
, p3
, p4copy
, p4type
);
291 ** Add an OP_ParseSchema opcode. This routine is broken out from
292 ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
293 ** as having been used.
295 ** The zWhere string must have been obtained from sqlite3_malloc().
296 ** This routine will take ownership of the allocated memory.
298 void sqlite3VdbeAddParseSchemaOp(Vdbe
*p
, int iDb
, char *zWhere
){
300 sqlite3VdbeAddOp4(p
, OP_ParseSchema
, iDb
, 0, 0, zWhere
, P4_DYNAMIC
);
301 for(j
=0; j
<p
->db
->nDb
; j
++) sqlite3VdbeUsesBtree(p
, j
);
305 ** Add an opcode that includes the p4 value as an integer.
307 int sqlite3VdbeAddOp4Int(
308 Vdbe
*p
, /* Add the opcode to this VM */
309 int op
, /* The new opcode */
310 int p1
, /* The P1 operand */
311 int p2
, /* The P2 operand */
312 int p3
, /* The P3 operand */
313 int p4
/* The P4 operand as an integer */
315 int addr
= sqlite3VdbeAddOp3(p
, op
, p1
, p2
, p3
);
316 sqlite3VdbeChangeP4(p
, addr
, SQLITE_INT_TO_PTR(p4
), P4_INT32
);
320 /* Insert the end of a co-routine
322 void sqlite3VdbeEndCoroutine(Vdbe
*v
, int regYield
){
323 sqlite3VdbeAddOp1(v
, OP_EndCoroutine
, regYield
);
325 /* Clear the temporary register cache, thereby ensuring that each
326 ** co-routine has its own independent set of registers, because co-routines
327 ** might expect their registers to be preserved across an OP_Yield, and
328 ** that could cause problems if two or more co-routines are using the same
329 ** temporary register.
331 v
->pParse
->nTempReg
= 0;
332 v
->pParse
->nRangeReg
= 0;
336 ** Create a new symbolic label for an instruction that has yet to be
337 ** coded. The symbolic label is really just a negative number. The
338 ** label can be used as the P2 value of an operation. Later, when
339 ** the label is resolved to a specific address, the VDBE will scan
340 ** through its operation list and change all values of P2 which match
341 ** the label into the resolved address.
343 ** The VDBE knows that a P2 value is a label because labels are
344 ** always negative and P2 values are suppose to be non-negative.
345 ** Hence, a negative P2 value is a label that has yet to be resolved.
347 ** Zero is returned if a malloc() fails.
349 int sqlite3VdbeMakeLabel(Vdbe
*v
){
350 Parse
*p
= v
->pParse
;
352 assert( v
->magic
==VDBE_MAGIC_INIT
);
353 if( (i
& (i
-1))==0 ){
354 p
->aLabel
= sqlite3DbReallocOrFree(p
->db
, p
->aLabel
,
355 (i
*2+1)*sizeof(p
->aLabel
[0]));
364 ** Resolve label "x" to be the address of the next instruction to
365 ** be inserted. The parameter "x" must have been obtained from
366 ** a prior call to sqlite3VdbeMakeLabel().
368 void sqlite3VdbeResolveLabel(Vdbe
*v
, int x
){
369 Parse
*p
= v
->pParse
;
371 assert( v
->magic
==VDBE_MAGIC_INIT
);
372 assert( j
<p
->nLabel
);
375 p
->aLabel
[j
] = v
->nOp
;
377 p
->iFixedOp
= v
->nOp
- 1;
381 ** Mark the VDBE as one that can only be run one time.
383 void sqlite3VdbeRunOnlyOnce(Vdbe
*p
){
388 ** Mark the VDBE as one that can only be run multiple times.
390 void sqlite3VdbeReusable(Vdbe
*p
){
394 #ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */
397 ** The following type and function are used to iterate through all opcodes
398 ** in a Vdbe main program and each of the sub-programs (triggers) it may
399 ** invoke directly or indirectly. It should be used as follows:
404 ** memset(&sIter, 0, sizeof(sIter));
405 ** sIter.v = v; // v is of type Vdbe*
406 ** while( (pOp = opIterNext(&sIter)) ){
407 ** // Do something with pOp
409 ** sqlite3DbFree(v->db, sIter.apSub);
412 typedef struct VdbeOpIter VdbeOpIter
;
414 Vdbe
*v
; /* Vdbe to iterate through the opcodes of */
415 SubProgram
**apSub
; /* Array of subprograms */
416 int nSub
; /* Number of entries in apSub */
417 int iAddr
; /* Address of next instruction to return */
418 int iSub
; /* 0 = main program, 1 = first sub-program etc. */
420 static Op
*opIterNext(VdbeOpIter
*p
){
426 if( p
->iSub
<=p
->nSub
){
432 aOp
= p
->apSub
[p
->iSub
-1]->aOp
;
433 nOp
= p
->apSub
[p
->iSub
-1]->nOp
;
435 assert( p
->iAddr
<nOp
);
437 pRet
= &aOp
[p
->iAddr
];
444 if( pRet
->p4type
==P4_SUBPROGRAM
){
445 int nByte
= (p
->nSub
+1)*sizeof(SubProgram
*);
447 for(j
=0; j
<p
->nSub
; j
++){
448 if( p
->apSub
[j
]==pRet
->p4
.pProgram
) break;
451 p
->apSub
= sqlite3DbReallocOrFree(v
->db
, p
->apSub
, nByte
);
455 p
->apSub
[p
->nSub
++] = pRet
->p4
.pProgram
;
465 ** Check if the program stored in the VM associated with pParse may
466 ** throw an ABORT exception (causing the statement, but not entire transaction
467 ** to be rolled back). This condition is true if the main program or any
468 ** sub-programs contains any of the following:
470 ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
471 ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
475 ** * OP_FkCounter with P2==0 (immediate foreign key constraint)
476 ** * OP_CreateTable and OP_InitCoroutine (for CREATE TABLE AS SELECT ...)
478 ** Then check that the value of Parse.mayAbort is true if an
479 ** ABORT may be thrown, or false otherwise. Return true if it does
480 ** match, or false otherwise. This function is intended to be used as
481 ** part of an assert statement in the compiler. Similar to:
483 ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
485 int sqlite3VdbeAssertMayAbort(Vdbe
*v
, int mayAbort
){
487 int hasFkCounter
= 0;
488 int hasCreateTable
= 0;
489 int hasInitCoroutine
= 0;
492 memset(&sIter
, 0, sizeof(sIter
));
495 while( (pOp
= opIterNext(&sIter
))!=0 ){
496 int opcode
= pOp
->opcode
;
497 if( opcode
==OP_Destroy
|| opcode
==OP_VUpdate
|| opcode
==OP_VRename
498 || ((opcode
==OP_Halt
|| opcode
==OP_HaltIfNull
)
499 && ((pOp
->p1
&0xff)==SQLITE_CONSTRAINT
&& pOp
->p2
==OE_Abort
))
504 if( opcode
==OP_CreateTable
) hasCreateTable
= 1;
505 if( opcode
==OP_InitCoroutine
) hasInitCoroutine
= 1;
506 #ifndef SQLITE_OMIT_FOREIGN_KEY
507 if( opcode
==OP_FkCounter
&& pOp
->p1
==0 && pOp
->p2
==1 ){
512 sqlite3DbFree(v
->db
, sIter
.apSub
);
514 /* Return true if hasAbort==mayAbort. Or if a malloc failure occurred.
515 ** If malloc failed, then the while() loop above may not have iterated
516 ** through all opcodes and hasAbort may be set incorrectly. Return
517 ** true for this case to prevent the assert() in the callers frame
519 return ( v
->db
->mallocFailed
|| hasAbort
==mayAbort
|| hasFkCounter
520 || (hasCreateTable
&& hasInitCoroutine
) );
522 #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */
525 ** This routine is called after all opcodes have been inserted. It loops
526 ** through all the opcodes and fixes up some details.
528 ** (1) For each jump instruction with a negative P2 value (a label)
529 ** resolve the P2 value to an actual address.
531 ** (2) Compute the maximum number of arguments used by any SQL function
532 ** and store that value in *pMaxFuncArgs.
534 ** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately
535 ** indicate what the prepared statement actually does.
537 ** (4) Initialize the p4.xAdvance pointer on opcodes that use it.
539 ** (5) Reclaim the memory allocated for storing labels.
541 ** This routine will only function correctly if the mkopcodeh.tcl generator
542 ** script numbers the opcodes correctly. Changes to this routine must be
543 ** coordinated with changes to mkopcodeh.tcl.
545 static void resolveP2Values(Vdbe
*p
, int *pMaxFuncArgs
){
546 int nMaxArgs
= *pMaxFuncArgs
;
548 Parse
*pParse
= p
->pParse
;
549 int *aLabel
= pParse
->aLabel
;
552 pOp
= &p
->aOp
[p
->nOp
-1];
555 /* Only JUMP opcodes and the short list of special opcodes in the switch
556 ** below need to be considered. The mkopcodeh.tcl generator script groups
557 ** all these opcodes together near the front of the opcode list. Skip
558 ** any opcode that does not need processing by virtual of the fact that
559 ** it is larger than SQLITE_MX_JUMP_OPCODE, as a performance optimization.
561 if( pOp
->opcode
<=SQLITE_MX_JUMP_OPCODE
){
562 /* NOTE: Be sure to update mkopcodeh.tcl when adding or removing
563 ** cases from this switch! */
564 switch( pOp
->opcode
){
565 case OP_Transaction
: {
566 if( pOp
->p2
!=0 ) p
->readOnly
= 0;
574 #ifndef SQLITE_OMIT_WAL
578 case OP_JournalMode
: {
583 #ifndef SQLITE_OMIT_VIRTUALTABLE
585 if( pOp
->p2
>nMaxArgs
) nMaxArgs
= pOp
->p2
;
590 assert( (pOp
- p
->aOp
) >= 3 );
591 assert( pOp
[-1].opcode
==OP_Integer
);
593 if( n
>nMaxArgs
) nMaxArgs
= n
;
599 case OP_SorterNext
: {
600 pOp
->p4
.xAdvance
= sqlite3BtreeNext
;
601 pOp
->p4type
= P4_ADVANCE
;
605 case OP_PrevIfOpen
: {
606 pOp
->p4
.xAdvance
= sqlite3BtreePrevious
;
607 pOp
->p4type
= P4_ADVANCE
;
611 if( (sqlite3OpcodeProperty
[pOp
->opcode
] & OPFLG_JUMP
)!=0 && pOp
->p2
<0 ){
612 assert( ADDR(pOp
->p2
)<pParse
->nLabel
);
613 pOp
->p2
= aLabel
[ADDR(pOp
->p2
)];
616 if( pOp
==p
->aOp
) break;
619 sqlite3DbFree(p
->db
, pParse
->aLabel
);
622 *pMaxFuncArgs
= nMaxArgs
;
623 assert( p
->bIsReader
!=0 || DbMaskAllZero(p
->btreeMask
) );
627 ** Return the address of the next instruction to be inserted.
629 int sqlite3VdbeCurrentAddr(Vdbe
*p
){
630 assert( p
->magic
==VDBE_MAGIC_INIT
);
635 ** Verify that at least N opcode slots are available in p without
636 ** having to malloc for more space (except when compiled using
637 ** SQLITE_TEST_REALLOC_STRESS). This interface is used during testing
638 ** to verify that certain calls to sqlite3VdbeAddOpList() can never
639 ** fail due to a OOM fault and hence that the return value from
640 ** sqlite3VdbeAddOpList() will always be non-NULL.
642 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
643 void sqlite3VdbeVerifyNoMallocRequired(Vdbe
*p
, int N
){
644 assert( p
->nOp
+ N
<= p
->pParse
->nOpAlloc
);
649 ** This function returns a pointer to the array of opcodes associated with
650 ** the Vdbe passed as the first argument. It is the callers responsibility
651 ** to arrange for the returned array to be eventually freed using the
652 ** vdbeFreeOpArray() function.
654 ** Before returning, *pnOp is set to the number of entries in the returned
655 ** array. Also, *pnMaxArg is set to the larger of its current value and
656 ** the number of entries in the Vdbe.apArg[] array required to execute the
659 VdbeOp
*sqlite3VdbeTakeOpArray(Vdbe
*p
, int *pnOp
, int *pnMaxArg
){
660 VdbeOp
*aOp
= p
->aOp
;
661 assert( aOp
&& !p
->db
->mallocFailed
);
663 /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
664 assert( DbMaskAllZero(p
->btreeMask
) );
666 resolveP2Values(p
, pnMaxArg
);
673 ** Add a whole list of operations to the operation stack. Return a
674 ** pointer to the first operation inserted.
676 ** Non-zero P2 arguments to jump instructions are automatically adjusted
677 ** so that the jump target is relative to the first operation inserted.
679 VdbeOp
*sqlite3VdbeAddOpList(
680 Vdbe
*p
, /* Add opcodes to the prepared statement */
681 int nOp
, /* Number of opcodes to add */
682 VdbeOpList
const *aOp
, /* The opcodes to be added */
683 int iLineno
/* Source-file line number of first opcode */
686 VdbeOp
*pOut
, *pFirst
;
688 assert( p
->magic
==VDBE_MAGIC_INIT
);
689 if( p
->nOp
+ nOp
> p
->pParse
->nOpAlloc
&& growOpArray(p
, nOp
) ){
692 pFirst
= pOut
= &p
->aOp
[p
->nOp
];
693 for(i
=0; i
<nOp
; i
++, aOp
++, pOut
++){
694 pOut
->opcode
= aOp
->opcode
;
697 assert( aOp
->p2
>=0 );
698 if( (sqlite3OpcodeProperty
[aOp
->opcode
] & OPFLG_JUMP
)!=0 && aOp
->p2
>0 ){
702 pOut
->p4type
= P4_NOTUSED
;
705 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
708 #ifdef SQLITE_VDBE_COVERAGE
709 pOut
->iSrcLine
= iLineno
+i
;
714 if( p
->db
->flags
& SQLITE_VdbeAddopTrace
){
715 sqlite3VdbePrintOp(0, i
+p
->nOp
, &p
->aOp
[i
+p
->nOp
]);
723 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS)
725 ** Add an entry to the array of counters managed by sqlite3_stmt_scanstatus().
727 void sqlite3VdbeScanStatus(
728 Vdbe
*p
, /* VM to add scanstatus() to */
729 int addrExplain
, /* Address of OP_Explain (or 0) */
730 int addrLoop
, /* Address of loop counter */
731 int addrVisit
, /* Address of rows visited counter */
732 LogEst nEst
, /* Estimated number of output rows */
733 const char *zName
/* Name of table or index being scanned */
735 int nByte
= (p
->nScan
+1) * sizeof(ScanStatus
);
737 aNew
= (ScanStatus
*)sqlite3DbRealloc(p
->db
, p
->aScan
, nByte
);
739 ScanStatus
*pNew
= &aNew
[p
->nScan
++];
740 pNew
->addrExplain
= addrExplain
;
741 pNew
->addrLoop
= addrLoop
;
742 pNew
->addrVisit
= addrVisit
;
744 pNew
->zName
= sqlite3DbStrDup(p
->db
, zName
);
752 ** Change the value of the opcode, or P1, P2, P3, or P5 operands
753 ** for a specific instruction.
755 void sqlite3VdbeChangeOpcode(Vdbe
*p
, u32 addr
, u8 iNewOpcode
){
756 sqlite3VdbeGetOp(p
,addr
)->opcode
= iNewOpcode
;
758 void sqlite3VdbeChangeP1(Vdbe
*p
, u32 addr
, int val
){
759 sqlite3VdbeGetOp(p
,addr
)->p1
= val
;
761 void sqlite3VdbeChangeP2(Vdbe
*p
, u32 addr
, int val
){
762 sqlite3VdbeGetOp(p
,addr
)->p2
= val
;
764 void sqlite3VdbeChangeP3(Vdbe
*p
, u32 addr
, int val
){
765 sqlite3VdbeGetOp(p
,addr
)->p3
= val
;
767 void sqlite3VdbeChangeP5(Vdbe
*p
, u8 p5
){
768 if( !p
->db
->mallocFailed
) p
->aOp
[p
->nOp
-1].p5
= p5
;
772 ** Change the P2 operand of instruction addr so that it points to
773 ** the address of the next instruction to be coded.
775 void sqlite3VdbeJumpHere(Vdbe
*p
, int addr
){
776 p
->pParse
->iFixedOp
= p
->nOp
- 1;
777 sqlite3VdbeChangeP2(p
, addr
, p
->nOp
);
782 ** If the input FuncDef structure is ephemeral, then free it. If
783 ** the FuncDef is not ephermal, then do nothing.
785 static void freeEphemeralFunction(sqlite3
*db
, FuncDef
*pDef
){
786 if( (pDef
->funcFlags
& SQLITE_FUNC_EPHEM
)!=0 ){
787 sqlite3DbFree(db
, pDef
);
791 static void vdbeFreeOpArray(sqlite3
*, Op
*, int);
794 ** Delete a P4 value if necessary.
796 static SQLITE_NOINLINE
void freeP4Mem(sqlite3
*db
, Mem
*p
){
797 if( p
->szMalloc
) sqlite3DbFree(db
, p
->zMalloc
);
798 sqlite3DbFree(db
, p
);
800 static SQLITE_NOINLINE
void freeP4FuncCtx(sqlite3
*db
, sqlite3_context
*p
){
801 freeEphemeralFunction(db
, p
->pFunc
);
802 sqlite3DbFree(db
, p
);
804 static void freeP4(sqlite3
*db
, int p4type
, void *p4
){
808 freeP4FuncCtx(db
, (sqlite3_context
*)p4
);
815 sqlite3DbFree(db
, p4
);
819 if( db
->pnBytesFreed
==0 ) sqlite3KeyInfoUnref((KeyInfo
*)p4
);
822 #ifdef SQLITE_ENABLE_CURSOR_HINTS
824 sqlite3ExprDelete(db
, (Expr
*)p4
);
829 if( db
->pnBytesFreed
==0 ) sqlite3_free(p4
);
833 freeEphemeralFunction(db
, (FuncDef
*)p4
);
837 if( db
->pnBytesFreed
==0 ){
838 sqlite3ValueFree((sqlite3_value
*)p4
);
840 freeP4Mem(db
, (Mem
*)p4
);
845 if( db
->pnBytesFreed
==0 ) sqlite3VtabUnlock((VTable
*)p4
);
852 ** Free the space allocated for aOp and any p4 values allocated for the
853 ** opcodes contained within. If aOp is not NULL it is assumed to contain
856 static void vdbeFreeOpArray(sqlite3
*db
, Op
*aOp
, int nOp
){
859 for(pOp
=aOp
; pOp
<&aOp
[nOp
]; pOp
++){
860 if( pOp
->p4type
) freeP4(db
, pOp
->p4type
, pOp
->p4
.p
);
861 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
862 sqlite3DbFree(db
, pOp
->zComment
);
866 sqlite3DbFree(db
, aOp
);
870 ** Link the SubProgram object passed as the second argument into the linked
871 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
872 ** objects when the VM is no longer required.
874 void sqlite3VdbeLinkSubProgram(Vdbe
*pVdbe
, SubProgram
*p
){
875 p
->pNext
= pVdbe
->pProgram
;
880 ** Change the opcode at addr into OP_Noop
882 int sqlite3VdbeChangeToNoop(Vdbe
*p
, int addr
){
884 if( p
->db
->mallocFailed
) return 0;
885 assert( addr
>=0 && addr
<p
->nOp
);
887 freeP4(p
->db
, pOp
->p4type
, pOp
->p4
.p
);
888 pOp
->p4type
= P4_NOTUSED
;
890 pOp
->opcode
= OP_Noop
;
895 ** If the last opcode is "op" and it is not a jump destination,
896 ** then remove it. Return true if and only if an opcode was removed.
898 int sqlite3VdbeDeletePriorOpcode(Vdbe
*p
, u8 op
){
899 if( (p
->nOp
-1)>(p
->pParse
->iFixedOp
) && p
->aOp
[p
->nOp
-1].opcode
==op
){
900 return sqlite3VdbeChangeToNoop(p
, p
->nOp
-1);
907 ** Change the value of the P4 operand for a specific instruction.
908 ** This routine is useful when a large program is loaded from a
909 ** static array using sqlite3VdbeAddOpList but we want to make a
910 ** few minor changes to the program.
912 ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
913 ** the string is made into memory obtained from sqlite3_malloc().
914 ** A value of n==0 means copy bytes of zP4 up to and including the
915 ** first null byte. If n>0 then copy n+1 bytes of zP4.
917 ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
918 ** to a string or structure that is guaranteed to exist for the lifetime of
919 ** the Vdbe. In these cases we can just copy the pointer.
921 ** If addr<0 then change P4 on the most recently inserted instruction.
923 static void SQLITE_NOINLINE
vdbeChangeP4Full(
930 freeP4(p
->db
, pOp
->p4type
, pOp
->p4
.p
);
935 sqlite3VdbeChangeP4(p
, (int)(pOp
- p
->aOp
), zP4
, n
);
937 if( n
==0 ) n
= sqlite3Strlen30(zP4
);
938 pOp
->p4
.z
= sqlite3DbStrNDup(p
->db
, zP4
, n
);
939 pOp
->p4type
= P4_DYNAMIC
;
942 void sqlite3VdbeChangeP4(Vdbe
*p
, int addr
, const char *zP4
, int n
){
947 assert( p
->magic
==VDBE_MAGIC_INIT
);
948 assert( p
->aOp
!=0 || db
->mallocFailed
);
949 if( db
->mallocFailed
){
950 if( n
!=P4_VTAB
) freeP4(db
, n
, (void*)*(char**)&zP4
);
954 assert( addr
<p
->nOp
);
959 if( n
>=0 || pOp
->p4type
){
960 vdbeChangeP4Full(p
, pOp
, zP4
, n
);
964 /* Note: this cast is safe, because the origin data point was an int
965 ** that was cast to a (const char *). */
966 pOp
->p4
.i
= SQLITE_PTR_TO_INT(zP4
);
967 pOp
->p4type
= P4_INT32
;
970 pOp
->p4
.p
= (void*)zP4
;
971 pOp
->p4type
= (signed char)n
;
972 if( n
==P4_VTAB
) sqlite3VtabLock((VTable
*)zP4
);
977 ** Set the P4 on the most recently added opcode to the KeyInfo for the
980 void sqlite3VdbeSetP4KeyInfo(Parse
*pParse
, Index
*pIdx
){
981 Vdbe
*v
= pParse
->pVdbe
;
984 sqlite3VdbeChangeP4(v
, -1, (char*)sqlite3KeyInfoOfIndex(pParse
, pIdx
),
988 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
990 ** Change the comment on the most recently coded instruction. Or
991 ** insert a No-op and add the comment to that new instruction. This
992 ** makes the code easier to read during debugging. None of this happens
993 ** in a production build.
995 static void vdbeVComment(Vdbe
*p
, const char *zFormat
, va_list ap
){
996 assert( p
->nOp
>0 || p
->aOp
==0 );
997 assert( p
->aOp
==0 || p
->aOp
[p
->nOp
-1].zComment
==0 || p
->db
->mallocFailed
);
1000 sqlite3DbFree(p
->db
, p
->aOp
[p
->nOp
-1].zComment
);
1001 p
->aOp
[p
->nOp
-1].zComment
= sqlite3VMPrintf(p
->db
, zFormat
, ap
);
1004 void sqlite3VdbeComment(Vdbe
*p
, const char *zFormat
, ...){
1007 va_start(ap
, zFormat
);
1008 vdbeVComment(p
, zFormat
, ap
);
1012 void sqlite3VdbeNoopComment(Vdbe
*p
, const char *zFormat
, ...){
1015 sqlite3VdbeAddOp0(p
, OP_Noop
);
1016 va_start(ap
, zFormat
);
1017 vdbeVComment(p
, zFormat
, ap
);
1023 #ifdef SQLITE_VDBE_COVERAGE
1025 ** Set the value if the iSrcLine field for the previously coded instruction.
1027 void sqlite3VdbeSetLineNumber(Vdbe
*v
, int iLine
){
1028 sqlite3VdbeGetOp(v
,-1)->iSrcLine
= iLine
;
1030 #endif /* SQLITE_VDBE_COVERAGE */
1033 ** Return the opcode for a given address. If the address is -1, then
1034 ** return the most recently inserted opcode.
1036 ** If a memory allocation error has occurred prior to the calling of this
1037 ** routine, then a pointer to a dummy VdbeOp will be returned. That opcode
1038 ** is readable but not writable, though it is cast to a writable value.
1039 ** The return of a dummy opcode allows the call to continue functioning
1040 ** after an OOM fault without having to check to see if the return from
1041 ** this routine is a valid pointer. But because the dummy.opcode is 0,
1042 ** dummy will never be written to. This is verified by code inspection and
1043 ** by running with Valgrind.
1045 VdbeOp
*sqlite3VdbeGetOp(Vdbe
*p
, int addr
){
1046 /* C89 specifies that the constant "dummy" will be initialized to all
1047 ** zeros, which is correct. MSVC generates a warning, nevertheless. */
1048 static VdbeOp dummy
; /* Ignore the MSVC warning about no initializer */
1049 assert( p
->magic
==VDBE_MAGIC_INIT
);
1053 assert( (addr
>=0 && addr
<p
->nOp
) || p
->db
->mallocFailed
);
1054 if( p
->db
->mallocFailed
){
1055 return (VdbeOp
*)&dummy
;
1057 return &p
->aOp
[addr
];
1061 #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS)
1063 ** Return an integer value for one of the parameters to the opcode pOp
1064 ** determined by character c.
1066 static int translateP(char c
, const Op
*pOp
){
1067 if( c
=='1' ) return pOp
->p1
;
1068 if( c
=='2' ) return pOp
->p2
;
1069 if( c
=='3' ) return pOp
->p3
;
1070 if( c
=='4' ) return pOp
->p4
.i
;
1075 ** Compute a string for the "comment" field of a VDBE opcode listing.
1077 ** The Synopsis: field in comments in the vdbe.c source file gets converted
1078 ** to an extra string that is appended to the sqlite3OpcodeName(). In the
1079 ** absence of other comments, this synopsis becomes the comment on the opcode.
1080 ** Some translation occurs:
1083 ** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1
1084 ** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0
1085 ** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x
1087 static int displayComment(
1088 const Op
*pOp
, /* The opcode to be commented */
1089 const char *zP4
, /* Previously obtained value for P4 */
1090 char *zTemp
, /* Write result here */
1091 int nTemp
/* Space available in zTemp[] */
1093 const char *zOpName
;
1094 const char *zSynopsis
;
1097 zOpName
= sqlite3OpcodeName(pOp
->opcode
);
1098 nOpName
= sqlite3Strlen30(zOpName
);
1099 if( zOpName
[nOpName
+1] ){
1102 zSynopsis
= zOpName
+= nOpName
+ 1;
1103 for(ii
=jj
=0; jj
<nTemp
-1 && (c
= zSynopsis
[ii
])!=0; ii
++){
1105 c
= zSynopsis
[++ii
];
1107 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "%s", zP4
);
1109 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "%s", pOp
->zComment
);
1112 int v1
= translateP(c
, pOp
);
1114 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "%d", v1
);
1115 if( strncmp(zSynopsis
+ii
+1, "@P", 2)==0 ){
1117 jj
+= sqlite3Strlen30(zTemp
+jj
);
1118 v2
= translateP(zSynopsis
[ii
], pOp
);
1119 if( strncmp(zSynopsis
+ii
+1,"+1",2)==0 ){
1124 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "..%d", v1
+v2
-1);
1126 }else if( strncmp(zSynopsis
+ii
+1, "..P3", 4)==0 && pOp
->p3
==0 ){
1130 jj
+= sqlite3Strlen30(zTemp
+jj
);
1135 if( !seenCom
&& jj
<nTemp
-5 && pOp
->zComment
){
1136 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "; %s", pOp
->zComment
);
1137 jj
+= sqlite3Strlen30(zTemp
+jj
);
1139 if( jj
<nTemp
) zTemp
[jj
] = 0;
1140 }else if( pOp
->zComment
){
1141 sqlite3_snprintf(nTemp
, zTemp
, "%s", pOp
->zComment
);
1142 jj
= sqlite3Strlen30(zTemp
);
1149 #endif /* SQLITE_DEBUG */
1151 #if VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS)
1153 ** Translate the P4.pExpr value for an OP_CursorHint opcode into text
1154 ** that can be displayed in the P4 column of EXPLAIN output.
1156 static void displayP4Expr(StrAccum
*p
, Expr
*pExpr
){
1157 const char *zOp
= 0;
1158 switch( pExpr
->op
){
1160 sqlite3XPrintf(p
, "%Q", pExpr
->u
.zToken
);
1163 sqlite3XPrintf(p
, "%d", pExpr
->u
.iValue
);
1166 sqlite3XPrintf(p
, "NULL");
1169 sqlite3XPrintf(p
, "r[%d]", pExpr
->iTable
);
1173 if( pExpr
->iColumn
<0 ){
1174 sqlite3XPrintf(p
, "rowid");
1176 sqlite3XPrintf(p
, "c%d", (int)pExpr
->iColumn
);
1180 case TK_LT
: zOp
= "LT"; break;
1181 case TK_LE
: zOp
= "LE"; break;
1182 case TK_GT
: zOp
= "GT"; break;
1183 case TK_GE
: zOp
= "GE"; break;
1184 case TK_NE
: zOp
= "NE"; break;
1185 case TK_EQ
: zOp
= "EQ"; break;
1186 case TK_IS
: zOp
= "IS"; break;
1187 case TK_ISNOT
: zOp
= "ISNOT"; break;
1188 case TK_AND
: zOp
= "AND"; break;
1189 case TK_OR
: zOp
= "OR"; break;
1190 case TK_PLUS
: zOp
= "ADD"; break;
1191 case TK_STAR
: zOp
= "MUL"; break;
1192 case TK_MINUS
: zOp
= "SUB"; break;
1193 case TK_REM
: zOp
= "REM"; break;
1194 case TK_BITAND
: zOp
= "BITAND"; break;
1195 case TK_BITOR
: zOp
= "BITOR"; break;
1196 case TK_SLASH
: zOp
= "DIV"; break;
1197 case TK_LSHIFT
: zOp
= "LSHIFT"; break;
1198 case TK_RSHIFT
: zOp
= "RSHIFT"; break;
1199 case TK_CONCAT
: zOp
= "CONCAT"; break;
1200 case TK_UMINUS
: zOp
= "MINUS"; break;
1201 case TK_UPLUS
: zOp
= "PLUS"; break;
1202 case TK_BITNOT
: zOp
= "BITNOT"; break;
1203 case TK_NOT
: zOp
= "NOT"; break;
1204 case TK_ISNULL
: zOp
= "ISNULL"; break;
1205 case TK_NOTNULL
: zOp
= "NOTNULL"; break;
1208 sqlite3XPrintf(p
, "%s", "expr");
1213 sqlite3XPrintf(p
, "%s(", zOp
);
1214 displayP4Expr(p
, pExpr
->pLeft
);
1215 if( pExpr
->pRight
){
1216 sqlite3StrAccumAppend(p
, ",", 1);
1217 displayP4Expr(p
, pExpr
->pRight
);
1219 sqlite3StrAccumAppend(p
, ")", 1);
1222 #endif /* VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) */
1227 ** Compute a string that describes the P4 parameter for an opcode.
1228 ** Use zTemp for any required temporary buffer space.
1230 static char *displayP4(Op
*pOp
, char *zTemp
, int nTemp
){
1233 assert( nTemp
>=20 );
1234 sqlite3StrAccumInit(&x
, 0, zTemp
, nTemp
, 0);
1235 switch( pOp
->p4type
){
1238 KeyInfo
*pKeyInfo
= pOp
->p4
.pKeyInfo
;
1239 assert( pKeyInfo
->aSortOrder
!=0 );
1240 sqlite3XPrintf(&x
, "k(%d", pKeyInfo
->nField
);
1241 for(j
=0; j
<pKeyInfo
->nField
; j
++){
1242 CollSeq
*pColl
= pKeyInfo
->aColl
[j
];
1243 const char *zColl
= pColl
? pColl
->zName
: "";
1244 if( strcmp(zColl
, "BINARY")==0 ) zColl
= "B";
1245 sqlite3XPrintf(&x
, ",%s%s", pKeyInfo
->aSortOrder
[j
] ? "-" : "", zColl
);
1247 sqlite3StrAccumAppend(&x
, ")", 1);
1250 #ifdef SQLITE_ENABLE_CURSOR_HINTS
1252 displayP4Expr(&x
, pOp
->p4
.pExpr
);
1257 CollSeq
*pColl
= pOp
->p4
.pColl
;
1258 sqlite3XPrintf(&x
, "(%.20s)", pColl
->zName
);
1262 FuncDef
*pDef
= pOp
->p4
.pFunc
;
1263 sqlite3XPrintf(&x
, "%s(%d)", pDef
->zName
, pDef
->nArg
);
1268 FuncDef
*pDef
= pOp
->p4
.pCtx
->pFunc
;
1269 sqlite3XPrintf(&x
, "%s(%d)", pDef
->zName
, pDef
->nArg
);
1274 sqlite3XPrintf(&x
, "%lld", *pOp
->p4
.pI64
);
1278 sqlite3XPrintf(&x
, "%d", pOp
->p4
.i
);
1282 sqlite3XPrintf(&x
, "%.16g", *pOp
->p4
.pReal
);
1286 Mem
*pMem
= pOp
->p4
.pMem
;
1287 if( pMem
->flags
& MEM_Str
){
1289 }else if( pMem
->flags
& MEM_Int
){
1290 sqlite3XPrintf(&x
, "%lld", pMem
->u
.i
);
1291 }else if( pMem
->flags
& MEM_Real
){
1292 sqlite3XPrintf(&x
, "%.16g", pMem
->u
.r
);
1293 }else if( pMem
->flags
& MEM_Null
){
1296 assert( pMem
->flags
& MEM_Blob
);
1301 #ifndef SQLITE_OMIT_VIRTUALTABLE
1303 sqlite3_vtab
*pVtab
= pOp
->p4
.pVtab
->pVtab
;
1304 sqlite3XPrintf(&x
, "vtab:%p", pVtab
);
1310 int *ai
= pOp
->p4
.ai
;
1311 int n
= ai
[0]; /* The first element of an INTARRAY is always the
1312 ** count of the number of elements to follow */
1314 sqlite3XPrintf(&x
, ",%d", ai
[i
]);
1317 sqlite3StrAccumAppend(&x
, "]", 1);
1320 case P4_SUBPROGRAM
: {
1321 sqlite3XPrintf(&x
, "program");
1329 sqlite3XPrintf(&x
, "%s", pOp
->p4
.pTab
->zName
);
1340 sqlite3StrAccumFinish(&x
);
1344 #endif /* VDBE_DISPLAY_P4 */
1347 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
1349 ** The prepared statements need to know in advance the complete set of
1350 ** attached databases that will be use. A mask of these databases
1351 ** is maintained in p->btreeMask. The p->lockMask value is the subset of
1352 ** p->btreeMask of databases that will require a lock.
1354 void sqlite3VdbeUsesBtree(Vdbe
*p
, int i
){
1355 assert( i
>=0 && i
<p
->db
->nDb
&& i
<(int)sizeof(yDbMask
)*8 );
1356 assert( i
<(int)sizeof(p
->btreeMask
)*8 );
1357 DbMaskSet(p
->btreeMask
, i
);
1358 if( i
!=1 && sqlite3BtreeSharable(p
->db
->aDb
[i
].pBt
) ){
1359 DbMaskSet(p
->lockMask
, i
);
1363 #if !defined(SQLITE_OMIT_SHARED_CACHE)
1365 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
1366 ** this routine obtains the mutex associated with each BtShared structure
1367 ** that may be accessed by the VM passed as an argument. In doing so it also
1368 ** sets the BtShared.db member of each of the BtShared structures, ensuring
1369 ** that the correct busy-handler callback is invoked if required.
1371 ** If SQLite is not threadsafe but does support shared-cache mode, then
1372 ** sqlite3BtreeEnter() is invoked to set the BtShared.db variables
1373 ** of all of BtShared structures accessible via the database handle
1374 ** associated with the VM.
1376 ** If SQLite is not threadsafe and does not support shared-cache mode, this
1377 ** function is a no-op.
1379 ** The p->btreeMask field is a bitmask of all btrees that the prepared
1380 ** statement p will ever use. Let N be the number of bits in p->btreeMask
1381 ** corresponding to btrees that use shared cache. Then the runtime of
1382 ** this routine is N*N. But as N is rarely more than 1, this should not
1385 void sqlite3VdbeEnter(Vdbe
*p
){
1390 if( DbMaskAllZero(p
->lockMask
) ) return; /* The common case */
1394 for(i
=0; i
<nDb
; i
++){
1395 if( i
!=1 && DbMaskTest(p
->lockMask
,i
) && ALWAYS(aDb
[i
].pBt
!=0) ){
1396 sqlite3BtreeEnter(aDb
[i
].pBt
);
1402 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
1404 ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter().
1406 static SQLITE_NOINLINE
void vdbeLeave(Vdbe
*p
){
1414 for(i
=0; i
<nDb
; i
++){
1415 if( i
!=1 && DbMaskTest(p
->lockMask
,i
) && ALWAYS(aDb
[i
].pBt
!=0) ){
1416 sqlite3BtreeLeave(aDb
[i
].pBt
);
1420 void sqlite3VdbeLeave(Vdbe
*p
){
1421 if( DbMaskAllZero(p
->lockMask
) ) return; /* The common case */
1426 #if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
1428 ** Print a single opcode. This routine is used for debugging only.
1430 void sqlite3VdbePrintOp(FILE *pOut
, int pc
, Op
*pOp
){
1434 static const char *zFormat1
= "%4d %-13s %4d %4d %4d %-13s %.2X %s\n";
1435 if( pOut
==0 ) pOut
= stdout
;
1436 zP4
= displayP4(pOp
, zPtr
, sizeof(zPtr
));
1437 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1438 displayComment(pOp
, zP4
, zCom
, sizeof(zCom
));
1442 /* NB: The sqlite3OpcodeName() function is implemented by code created
1443 ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the
1444 ** information from the vdbe.c source text */
1445 fprintf(pOut
, zFormat1
, pc
,
1446 sqlite3OpcodeName(pOp
->opcode
), pOp
->p1
, pOp
->p2
, pOp
->p3
, zP4
, pOp
->p5
,
1454 ** Release an array of N Mem elements
1456 static void releaseMemArray(Mem
*p
, int N
){
1459 sqlite3
*db
= p
->db
;
1460 if( db
->pnBytesFreed
){
1462 if( p
->szMalloc
) sqlite3DbFree(db
, p
->zMalloc
);
1463 }while( (++p
)<pEnd
);
1467 assert( (&p
[1])==pEnd
|| p
[0].db
==p
[1].db
);
1468 assert( sqlite3VdbeCheckMemInvariants(p
) );
1470 /* This block is really an inlined version of sqlite3VdbeMemRelease()
1471 ** that takes advantage of the fact that the memory cell value is
1472 ** being set to NULL after releasing any dynamic resources.
1474 ** The justification for duplicating code is that according to
1475 ** callgrind, this causes a certain test case to hit the CPU 4.7
1476 ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
1477 ** sqlite3MemRelease() were called from here. With -O2, this jumps
1478 ** to 6.6 percent. The test case is inserting 1000 rows into a table
1479 ** with no indexes using a single prepared INSERT statement, bind()
1480 ** and reset(). Inserts are grouped into a transaction.
1482 testcase( p
->flags
& MEM_Agg
);
1483 testcase( p
->flags
& MEM_Dyn
);
1484 testcase( p
->flags
& MEM_Frame
);
1485 testcase( p
->flags
& MEM_RowSet
);
1486 if( p
->flags
&(MEM_Agg
|MEM_Dyn
|MEM_Frame
|MEM_RowSet
) ){
1487 sqlite3VdbeMemRelease(p
);
1488 }else if( p
->szMalloc
){
1489 sqlite3DbFree(db
, p
->zMalloc
);
1493 p
->flags
= MEM_Undefined
;
1494 }while( (++p
)<pEnd
);
1499 ** Delete a VdbeFrame object and its contents. VdbeFrame objects are
1500 ** allocated by the OP_Program opcode in sqlite3VdbeExec().
1502 void sqlite3VdbeFrameDelete(VdbeFrame
*p
){
1504 Mem
*aMem
= VdbeFrameMem(p
);
1505 VdbeCursor
**apCsr
= (VdbeCursor
**)&aMem
[p
->nChildMem
];
1506 for(i
=0; i
<p
->nChildCsr
; i
++){
1507 sqlite3VdbeFreeCursor(p
->v
, apCsr
[i
]);
1509 releaseMemArray(aMem
, p
->nChildMem
);
1510 sqlite3VdbeDeleteAuxData(p
->v
->db
, &p
->pAuxData
, -1, 0);
1511 sqlite3DbFree(p
->v
->db
, p
);
1514 #ifndef SQLITE_OMIT_EXPLAIN
1516 ** Give a listing of the program in the virtual machine.
1518 ** The interface is the same as sqlite3VdbeExec(). But instead of
1519 ** running the code, it invokes the callback once for each instruction.
1520 ** This feature is used to implement "EXPLAIN".
1522 ** When p->explain==1, each instruction is listed. When
1523 ** p->explain==2, only OP_Explain instructions are listed and these
1524 ** are shown in a different format. p->explain==2 is used to implement
1525 ** EXPLAIN QUERY PLAN.
1527 ** When p->explain==1, first the main program is listed, then each of
1528 ** the trigger subprograms are listed one by one.
1530 int sqlite3VdbeList(
1531 Vdbe
*p
/* The VDBE */
1533 int nRow
; /* Stop when row count reaches this */
1534 int nSub
= 0; /* Number of sub-vdbes seen so far */
1535 SubProgram
**apSub
= 0; /* Array of sub-vdbes */
1536 Mem
*pSub
= 0; /* Memory cell hold array of subprogs */
1537 sqlite3
*db
= p
->db
; /* The database connection */
1538 int i
; /* Loop counter */
1539 int rc
= SQLITE_OK
; /* Return code */
1540 Mem
*pMem
= &p
->aMem
[1]; /* First Mem of result set */
1542 assert( p
->explain
);
1543 assert( p
->magic
==VDBE_MAGIC_RUN
);
1544 assert( p
->rc
==SQLITE_OK
|| p
->rc
==SQLITE_BUSY
|| p
->rc
==SQLITE_NOMEM
);
1546 /* Even though this opcode does not use dynamic strings for
1547 ** the result, result columns may become dynamic if the user calls
1548 ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
1550 releaseMemArray(pMem
, 8);
1553 if( p
->rc
==SQLITE_NOMEM_BKPT
){
1554 /* This happens if a malloc() inside a call to sqlite3_column_text() or
1555 ** sqlite3_column_text16() failed. */
1556 sqlite3OomFault(db
);
1557 return SQLITE_ERROR
;
1560 /* When the number of output rows reaches nRow, that means the
1561 ** listing has finished and sqlite3_step() should return SQLITE_DONE.
1562 ** nRow is the sum of the number of rows in the main program, plus
1563 ** the sum of the number of rows in all trigger subprograms encountered
1564 ** so far. The nRow value will increase as new trigger subprograms are
1565 ** encountered, but p->pc will eventually catch up to nRow.
1568 if( p
->explain
==1 ){
1569 /* The first 8 memory cells are used for the result set. So we will
1570 ** commandeer the 9th cell to use as storage for an array of pointers
1571 ** to trigger subprograms. The VDBE is guaranteed to have at least 9
1573 assert( p
->nMem
>9 );
1575 if( pSub
->flags
&MEM_Blob
){
1576 /* On the first call to sqlite3_step(), pSub will hold a NULL. It is
1577 ** initialized to a BLOB by the P4_SUBPROGRAM processing logic below */
1578 nSub
= pSub
->n
/sizeof(Vdbe
*);
1579 apSub
= (SubProgram
**)pSub
->z
;
1581 for(i
=0; i
<nSub
; i
++){
1582 nRow
+= apSub
[i
]->nOp
;
1588 }while( i
<nRow
&& p
->explain
==2 && p
->aOp
[i
].opcode
!=OP_Explain
);
1592 }else if( db
->u1
.isInterrupted
){
1593 p
->rc
= SQLITE_INTERRUPT
;
1595 sqlite3VdbeError(p
, sqlite3ErrStr(p
->rc
));
1600 /* The output line number is small enough that we are still in the
1604 /* We are currently listing subprograms. Figure out which one and
1605 ** pick up the appropriate opcode. */
1608 for(j
=0; i
>=apSub
[j
]->nOp
; j
++){
1611 pOp
= &apSub
[j
]->aOp
[i
];
1613 if( p
->explain
==1 ){
1614 pMem
->flags
= MEM_Int
;
1615 pMem
->u
.i
= i
; /* Program counter */
1618 pMem
->flags
= MEM_Static
|MEM_Str
|MEM_Term
;
1619 pMem
->z
= (char*)sqlite3OpcodeName(pOp
->opcode
); /* Opcode */
1620 assert( pMem
->z
!=0 );
1621 pMem
->n
= sqlite3Strlen30(pMem
->z
);
1622 pMem
->enc
= SQLITE_UTF8
;
1625 /* When an OP_Program opcode is encounter (the only opcode that has
1626 ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms
1627 ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
1628 ** has not already been seen.
1630 if( pOp
->p4type
==P4_SUBPROGRAM
){
1631 int nByte
= (nSub
+1)*sizeof(SubProgram
*);
1633 for(j
=0; j
<nSub
; j
++){
1634 if( apSub
[j
]==pOp
->p4
.pProgram
) break;
1636 if( j
==nSub
&& SQLITE_OK
==sqlite3VdbeMemGrow(pSub
, nByte
, nSub
!=0) ){
1637 apSub
= (SubProgram
**)pSub
->z
;
1638 apSub
[nSub
++] = pOp
->p4
.pProgram
;
1639 pSub
->flags
|= MEM_Blob
;
1640 pSub
->n
= nSub
*sizeof(SubProgram
*);
1645 pMem
->flags
= MEM_Int
;
1646 pMem
->u
.i
= pOp
->p1
; /* P1 */
1649 pMem
->flags
= MEM_Int
;
1650 pMem
->u
.i
= pOp
->p2
; /* P2 */
1653 pMem
->flags
= MEM_Int
;
1654 pMem
->u
.i
= pOp
->p3
; /* P3 */
1657 if( sqlite3VdbeMemClearAndResize(pMem
, 100) ){ /* P4 */
1658 assert( p
->db
->mallocFailed
);
1659 return SQLITE_ERROR
;
1661 pMem
->flags
= MEM_Str
|MEM_Term
;
1662 zP4
= displayP4(pOp
, pMem
->z
, pMem
->szMalloc
);
1664 sqlite3VdbeMemSetStr(pMem
, zP4
, -1, SQLITE_UTF8
, 0);
1666 assert( pMem
->z
!=0 );
1667 pMem
->n
= sqlite3Strlen30(pMem
->z
);
1668 pMem
->enc
= SQLITE_UTF8
;
1672 if( p
->explain
==1 ){
1673 if( sqlite3VdbeMemClearAndResize(pMem
, 4) ){
1674 assert( p
->db
->mallocFailed
);
1675 return SQLITE_ERROR
;
1677 pMem
->flags
= MEM_Str
|MEM_Term
;
1679 sqlite3_snprintf(3, pMem
->z
, "%.2x", pOp
->p5
); /* P5 */
1680 pMem
->enc
= SQLITE_UTF8
;
1683 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1684 if( sqlite3VdbeMemClearAndResize(pMem
, 500) ){
1685 assert( p
->db
->mallocFailed
);
1686 return SQLITE_ERROR
;
1688 pMem
->flags
= MEM_Str
|MEM_Term
;
1689 pMem
->n
= displayComment(pOp
, zP4
, pMem
->z
, 500);
1690 pMem
->enc
= SQLITE_UTF8
;
1692 pMem
->flags
= MEM_Null
; /* Comment */
1696 p
->nResColumn
= 8 - 4*(p
->explain
-1);
1697 p
->pResultSet
= &p
->aMem
[1];
1703 #endif /* SQLITE_OMIT_EXPLAIN */
1707 ** Print the SQL that was used to generate a VDBE program.
1709 void sqlite3VdbePrintSql(Vdbe
*p
){
1713 }else if( p
->nOp
>=1 ){
1714 const VdbeOp
*pOp
= &p
->aOp
[0];
1715 if( pOp
->opcode
==OP_Init
&& pOp
->p4
.z
!=0 ){
1717 while( sqlite3Isspace(*z
) ) z
++;
1720 if( z
) printf("SQL: [%s]\n", z
);
1724 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
1726 ** Print an IOTRACE message showing SQL content.
1728 void sqlite3VdbeIOTraceSql(Vdbe
*p
){
1731 if( sqlite3IoTrace
==0 ) return;
1734 if( pOp
->opcode
==OP_Init
&& pOp
->p4
.z
!=0 ){
1737 sqlite3_snprintf(sizeof(z
), z
, "%s", pOp
->p4
.z
);
1738 for(i
=0; sqlite3Isspace(z
[i
]); i
++){}
1739 for(j
=0; z
[i
]; i
++){
1740 if( sqlite3Isspace(z
[i
]) ){
1749 sqlite3IoTrace("SQL %s\n", z
);
1752 #endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */
1754 /* An instance of this object describes bulk memory available for use
1755 ** by subcomponents of a prepared statement. Space is allocated out
1756 ** of a ReusableSpace object by the allocSpace() routine below.
1758 struct ReusableSpace
{
1759 u8
*pSpace
; /* Available memory */
1760 int nFree
; /* Bytes of available memory */
1761 int nNeeded
; /* Total bytes that could not be allocated */
1764 /* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf
1765 ** from the ReusableSpace object. Return a pointer to the allocated
1766 ** memory on success. If insufficient memory is available in the
1767 ** ReusableSpace object, increase the ReusableSpace.nNeeded
1768 ** value by the amount needed and return NULL.
1770 ** If pBuf is not initially NULL, that means that the memory has already
1771 ** been allocated by a prior call to this routine, so just return a copy
1772 ** of pBuf and leave ReusableSpace unchanged.
1774 ** This allocator is employed to repurpose unused slots at the end of the
1775 ** opcode array of prepared state for other memory needs of the prepared
1778 static void *allocSpace(
1779 struct ReusableSpace
*p
, /* Bulk memory available for allocation */
1780 void *pBuf
, /* Pointer to a prior allocation */
1781 int nByte
/* Bytes of memory needed */
1783 assert( EIGHT_BYTE_ALIGNMENT(p
->pSpace
) );
1785 nByte
= ROUND8(nByte
);
1786 if( nByte
<= p
->nFree
){
1788 pBuf
= &p
->pSpace
[p
->nFree
];
1790 p
->nNeeded
+= nByte
;
1793 assert( EIGHT_BYTE_ALIGNMENT(pBuf
) );
1798 ** Rewind the VDBE back to the beginning in preparation for
1801 void sqlite3VdbeRewind(Vdbe
*p
){
1802 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
1806 assert( p
->magic
==VDBE_MAGIC_INIT
);
1808 /* There should be at least one opcode.
1812 /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */
1813 p
->magic
= VDBE_MAGIC_RUN
;
1816 for(i
=0; i
<p
->nMem
; i
++){
1817 assert( p
->aMem
[i
].db
==p
->db
);
1822 p
->errorAction
= OE_Abort
;
1825 p
->minWriteFileFormat
= 255;
1827 p
->nFkConstraint
= 0;
1829 for(i
=0; i
<p
->nOp
; i
++){
1831 p
->aOp
[i
].cycles
= 0;
1837 ** Prepare a virtual machine for execution for the first time after
1838 ** creating the virtual machine. This involves things such
1839 ** as allocating registers and initializing the program counter.
1840 ** After the VDBE has be prepped, it can be executed by one or more
1841 ** calls to sqlite3VdbeExec().
1843 ** This function may be called exactly once on each virtual machine.
1844 ** After this routine is called the VM has been "packaged" and is ready
1845 ** to run. After this routine is called, further calls to
1846 ** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects
1847 ** the Vdbe from the Parse object that helped generate it so that the
1848 ** the Vdbe becomes an independent entity and the Parse object can be
1851 ** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back
1852 ** to its initial state after it has been run.
1854 void sqlite3VdbeMakeReady(
1855 Vdbe
*p
, /* The VDBE */
1856 Parse
*pParse
/* Parsing context */
1858 sqlite3
*db
; /* The database connection */
1859 int nVar
; /* Number of parameters */
1860 int nMem
; /* Number of VM memory registers */
1861 int nCursor
; /* Number of cursors required */
1862 int nArg
; /* Number of arguments in subprograms */
1863 int nOnce
; /* Number of OP_Once instructions */
1864 int n
; /* Loop counter */
1865 struct ReusableSpace x
; /* Reusable bulk memory */
1869 assert( pParse
!=0 );
1870 assert( p
->magic
==VDBE_MAGIC_INIT
);
1871 assert( pParse
==p
->pParse
);
1873 assert( db
->mallocFailed
==0 );
1874 nVar
= pParse
->nVar
;
1875 nMem
= pParse
->nMem
;
1876 nCursor
= pParse
->nTab
;
1877 nArg
= pParse
->nMaxArg
;
1878 nOnce
= pParse
->nOnce
;
1879 if( nOnce
==0 ) nOnce
= 1; /* Ensure at least one byte in p->aOnceFlag[] */
1881 /* Each cursor uses a memory cell. The first cursor (cursor 0) can
1882 ** use aMem[0] which is not otherwise used by the VDBE program. Allocate
1883 ** space at the end of aMem[] for cursors 1 and greater.
1884 ** See also: allocateCursor().
1887 if( nCursor
==0 && nMem
>0 ) nMem
++; /* Space for aMem[0] even if not used */
1889 /* Figure out how much reusable memory is available at the end of the
1890 ** opcode array. This extra memory will be reallocated for other elements
1891 ** of the prepared statement.
1893 n
= ROUND8(sizeof(Op
)*p
->nOp
); /* Bytes of opcode memory used */
1894 x
.pSpace
= &((u8
*)p
->aOp
)[n
]; /* Unused opcode memory */
1895 assert( EIGHT_BYTE_ALIGNMENT(x
.pSpace
) );
1896 x
.nFree
= ROUNDDOWN8(pParse
->szOpAlloc
- n
); /* Bytes of unused memory */
1897 assert( x
.nFree
>=0 );
1899 memset(x
.pSpace
, 0, x
.nFree
);
1900 assert( EIGHT_BYTE_ALIGNMENT(&x
.pSpace
[x
.nFree
]) );
1903 resolveP2Values(p
, &nArg
);
1904 p
->usesStmtJournal
= (u8
)(pParse
->isMultiWrite
&& pParse
->mayAbort
);
1905 if( pParse
->explain
&& nMem
<10 ){
1910 /* Memory for registers, parameters, cursor, etc, is allocated in one or two
1911 ** passes. On the first pass, we try to reuse unused memory at the
1912 ** end of the opcode array. If we are unable to satisfy all memory
1913 ** requirements by reusing the opcode array tail, then the second
1914 ** pass will fill in the remainder using a fresh memory allocation.
1916 ** This two-pass approach that reuses as much memory as possible from
1917 ** the leftover memory at the end of the opcode array. This can significantly
1918 ** reduce the amount of memory held by a prepared statement.
1922 p
->aMem
= allocSpace(&x
, p
->aMem
, nMem
*sizeof(Mem
));
1923 p
->aVar
= allocSpace(&x
, p
->aVar
, nVar
*sizeof(Mem
));
1924 p
->apArg
= allocSpace(&x
, p
->apArg
, nArg
*sizeof(Mem
*));
1925 p
->apCsr
= allocSpace(&x
, p
->apCsr
, nCursor
*sizeof(VdbeCursor
*));
1926 p
->aOnceFlag
= allocSpace(&x
, p
->aOnceFlag
, nOnce
);
1927 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
1928 p
->anExec
= allocSpace(&x
, p
->anExec
, p
->nOp
*sizeof(i64
));
1930 if( x
.nNeeded
==0 ) break;
1931 x
.pSpace
= p
->pFree
= sqlite3DbMallocZero(db
, x
.nNeeded
);
1932 x
.nFree
= x
.nNeeded
;
1933 }while( !db
->mallocFailed
);
1935 p
->nCursor
= nCursor
;
1936 p
->nOnceFlag
= nOnce
;
1938 p
->nVar
= (ynVar
)nVar
;
1939 for(n
=0; n
<nVar
; n
++){
1940 p
->aVar
[n
].flags
= MEM_Null
;
1944 p
->nzVar
= pParse
->nzVar
;
1945 p
->azVar
= pParse
->azVar
;
1950 for(n
=0; n
<nMem
; n
++){
1951 p
->aMem
[n
].flags
= MEM_Undefined
;
1955 p
->explain
= pParse
->explain
;
1956 sqlite3VdbeRewind(p
);
1960 ** Close a VDBE cursor and release all the resources that cursor
1963 void sqlite3VdbeFreeCursor(Vdbe
*p
, VdbeCursor
*pCx
){
1967 assert( pCx
->pBt
==0 || pCx
->eCurType
==CURTYPE_BTREE
);
1968 switch( pCx
->eCurType
){
1969 case CURTYPE_SORTER
: {
1970 sqlite3VdbeSorterClose(p
->db
, pCx
);
1973 case CURTYPE_BTREE
: {
1975 sqlite3BtreeClose(pCx
->pBt
);
1976 /* The pCx->pCursor will be close automatically, if it exists, by
1977 ** the call above. */
1979 assert( pCx
->uc
.pCursor
!=0 );
1980 sqlite3BtreeCloseCursor(pCx
->uc
.pCursor
);
1984 #ifndef SQLITE_OMIT_VIRTUALTABLE
1985 case CURTYPE_VTAB
: {
1986 sqlite3_vtab_cursor
*pVCur
= pCx
->uc
.pVCur
;
1987 const sqlite3_module
*pModule
= pVCur
->pVtab
->pModule
;
1988 assert( pVCur
->pVtab
->nRef
>0 );
1989 pVCur
->pVtab
->nRef
--;
1990 pModule
->xClose(pVCur
);
1998 ** Close all cursors in the current frame.
2000 static void closeCursorsInFrame(Vdbe
*p
){
2003 for(i
=0; i
<p
->nCursor
; i
++){
2004 VdbeCursor
*pC
= p
->apCsr
[i
];
2006 sqlite3VdbeFreeCursor(p
, pC
);
2014 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
2015 ** is used, for example, when a trigger sub-program is halted to restore
2016 ** control to the main program.
2018 int sqlite3VdbeFrameRestore(VdbeFrame
*pFrame
){
2019 Vdbe
*v
= pFrame
->v
;
2020 closeCursorsInFrame(v
);
2021 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
2022 v
->anExec
= pFrame
->anExec
;
2024 v
->aOnceFlag
= pFrame
->aOnceFlag
;
2025 v
->nOnceFlag
= pFrame
->nOnceFlag
;
2026 v
->aOp
= pFrame
->aOp
;
2027 v
->nOp
= pFrame
->nOp
;
2028 v
->aMem
= pFrame
->aMem
;
2029 v
->nMem
= pFrame
->nMem
;
2030 v
->apCsr
= pFrame
->apCsr
;
2031 v
->nCursor
= pFrame
->nCursor
;
2032 v
->db
->lastRowid
= pFrame
->lastRowid
;
2033 v
->nChange
= pFrame
->nChange
;
2034 v
->db
->nChange
= pFrame
->nDbChange
;
2035 sqlite3VdbeDeleteAuxData(v
->db
, &v
->pAuxData
, -1, 0);
2036 v
->pAuxData
= pFrame
->pAuxData
;
2037 pFrame
->pAuxData
= 0;
2042 ** Close all cursors.
2044 ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory
2045 ** cell array. This is necessary as the memory cell array may contain
2046 ** pointers to VdbeFrame objects, which may in turn contain pointers to
2049 static void closeAllCursors(Vdbe
*p
){
2052 for(pFrame
=p
->pFrame
; pFrame
->pParent
; pFrame
=pFrame
->pParent
);
2053 sqlite3VdbeFrameRestore(pFrame
);
2057 assert( p
->nFrame
==0 );
2058 closeCursorsInFrame(p
);
2060 releaseMemArray(p
->aMem
, p
->nMem
);
2062 while( p
->pDelFrame
){
2063 VdbeFrame
*pDel
= p
->pDelFrame
;
2064 p
->pDelFrame
= pDel
->pParent
;
2065 sqlite3VdbeFrameDelete(pDel
);
2068 /* Delete any auxdata allocations made by the VM */
2069 if( p
->pAuxData
) sqlite3VdbeDeleteAuxData(p
->db
, &p
->pAuxData
, -1, 0);
2070 assert( p
->pAuxData
==0 );
2074 ** Clean up the VM after a single run.
2076 static void Cleanup(Vdbe
*p
){
2077 sqlite3
*db
= p
->db
;
2080 /* Execute assert() statements to ensure that the Vdbe.apCsr[] and
2081 ** Vdbe.aMem[] arrays have already been cleaned up. */
2083 if( p
->apCsr
) for(i
=0; i
<p
->nCursor
; i
++) assert( p
->apCsr
[i
]==0 );
2085 for(i
=0; i
<p
->nMem
; i
++) assert( p
->aMem
[i
].flags
==MEM_Undefined
);
2089 sqlite3DbFree(db
, p
->zErrMsg
);
2095 ** Set the number of result columns that will be returned by this SQL
2096 ** statement. This is now set at compile time, rather than during
2097 ** execution of the vdbe program so that sqlite3_column_count() can
2098 ** be called on an SQL statement before sqlite3_step().
2100 void sqlite3VdbeSetNumCols(Vdbe
*p
, int nResColumn
){
2103 sqlite3
*db
= p
->db
;
2105 releaseMemArray(p
->aColName
, p
->nResColumn
*COLNAME_N
);
2106 sqlite3DbFree(db
, p
->aColName
);
2107 n
= nResColumn
*COLNAME_N
;
2108 p
->nResColumn
= (u16
)nResColumn
;
2109 p
->aColName
= pColName
= (Mem
*)sqlite3DbMallocZero(db
, sizeof(Mem
)*n
);
2110 if( p
->aColName
==0 ) return;
2112 pColName
->flags
= MEM_Null
;
2113 pColName
->db
= p
->db
;
2119 ** Set the name of the idx'th column to be returned by the SQL statement.
2120 ** zName must be a pointer to a nul terminated string.
2122 ** This call must be made after a call to sqlite3VdbeSetNumCols().
2124 ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
2125 ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
2126 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
2128 int sqlite3VdbeSetColName(
2129 Vdbe
*p
, /* Vdbe being configured */
2130 int idx
, /* Index of column zName applies to */
2131 int var
, /* One of the COLNAME_* constants */
2132 const char *zName
, /* Pointer to buffer containing name */
2133 void (*xDel
)(void*) /* Memory management strategy for zName */
2137 assert( idx
<p
->nResColumn
);
2138 assert( var
<COLNAME_N
);
2139 if( p
->db
->mallocFailed
){
2140 assert( !zName
|| xDel
!=SQLITE_DYNAMIC
);
2141 return SQLITE_NOMEM_BKPT
;
2143 assert( p
->aColName
!=0 );
2144 pColName
= &(p
->aColName
[idx
+var
*p
->nResColumn
]);
2145 rc
= sqlite3VdbeMemSetStr(pColName
, zName
, -1, SQLITE_UTF8
, xDel
);
2146 assert( rc
!=0 || !zName
|| (pColName
->flags
&MEM_Term
)!=0 );
2151 ** A read or write transaction may or may not be active on database handle
2152 ** db. If a transaction is active, commit it. If there is a
2153 ** write-transaction spanning more than one database file, this routine
2154 ** takes care of the master journal trickery.
2156 static int vdbeCommit(sqlite3
*db
, Vdbe
*p
){
2158 int nTrans
= 0; /* Number of databases with an active write-transaction
2159 ** that are candidates for a two-phase commit using a
2160 ** master-journal */
2162 int needXcommit
= 0;
2164 #ifdef SQLITE_OMIT_VIRTUALTABLE
2165 /* With this option, sqlite3VtabSync() is defined to be simply
2166 ** SQLITE_OK so p is not used.
2168 UNUSED_PARAMETER(p
);
2171 /* Before doing anything else, call the xSync() callback for any
2172 ** virtual module tables written in this transaction. This has to
2173 ** be done before determining whether a master journal file is
2174 ** required, as an xSync() callback may add an attached database
2175 ** to the transaction.
2177 rc
= sqlite3VtabSync(db
, p
);
2179 /* This loop determines (a) if the commit hook should be invoked and
2180 ** (b) how many database files have open write transactions, not
2181 ** including the temp database. (b) is important because if more than
2182 ** one database file has an open write transaction, a master journal
2183 ** file is required for an atomic commit.
2185 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2186 Btree
*pBt
= db
->aDb
[i
].pBt
;
2187 if( sqlite3BtreeIsInTrans(pBt
) ){
2188 /* Whether or not a database might need a master journal depends upon
2189 ** its journal mode (among other things). This matrix determines which
2190 ** journal modes use a master journal and which do not */
2191 static const u8 aMJNeeded
[] = {
2199 Pager
*pPager
; /* Pager associated with pBt */
2201 sqlite3BtreeEnter(pBt
);
2202 pPager
= sqlite3BtreePager(pBt
);
2203 if( db
->aDb
[i
].safety_level
!=PAGER_SYNCHRONOUS_OFF
2204 && aMJNeeded
[sqlite3PagerGetJournalMode(pPager
)]
2209 rc
= sqlite3PagerExclusiveLock(pPager
);
2210 sqlite3BtreeLeave(pBt
);
2213 if( rc
!=SQLITE_OK
){
2217 /* If there are any write-transactions at all, invoke the commit hook */
2218 if( needXcommit
&& db
->xCommitCallback
){
2219 rc
= db
->xCommitCallback(db
->pCommitArg
);
2221 return SQLITE_CONSTRAINT_COMMITHOOK
;
2225 /* The simple case - no more than one database file (not counting the
2226 ** TEMP database) has a transaction active. There is no need for the
2229 ** If the return value of sqlite3BtreeGetFilename() is a zero length
2230 ** string, it means the main database is :memory: or a temp file. In
2231 ** that case we do not support atomic multi-file commits, so use the
2232 ** simple case then too.
2234 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db
->aDb
[0].pBt
))
2237 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2238 Btree
*pBt
= db
->aDb
[i
].pBt
;
2240 rc
= sqlite3BtreeCommitPhaseOne(pBt
, 0);
2244 /* Do the commit only if all databases successfully complete phase 1.
2245 ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
2246 ** IO error while deleting or truncating a journal file. It is unlikely,
2247 ** but could happen. In this case abandon processing and return the error.
2249 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2250 Btree
*pBt
= db
->aDb
[i
].pBt
;
2252 rc
= sqlite3BtreeCommitPhaseTwo(pBt
, 0);
2255 if( rc
==SQLITE_OK
){
2256 sqlite3VtabCommit(db
);
2260 /* The complex case - There is a multi-file write-transaction active.
2261 ** This requires a master journal file to ensure the transaction is
2262 ** committed atomically.
2264 #ifndef SQLITE_OMIT_DISKIO
2266 sqlite3_vfs
*pVfs
= db
->pVfs
;
2267 char *zMaster
= 0; /* File-name for the master journal */
2268 char const *zMainFile
= sqlite3BtreeGetFilename(db
->aDb
[0].pBt
);
2269 sqlite3_file
*pMaster
= 0;
2275 /* Select a master journal file name */
2276 nMainFile
= sqlite3Strlen30(zMainFile
);
2277 zMaster
= sqlite3MPrintf(db
, "%s-mjXXXXXX9XXz", zMainFile
);
2278 if( zMaster
==0 ) return SQLITE_NOMEM_BKPT
;
2282 if( retryCount
>100 ){
2283 sqlite3_log(SQLITE_FULL
, "MJ delete: %s", zMaster
);
2284 sqlite3OsDelete(pVfs
, zMaster
, 0);
2286 }else if( retryCount
==1 ){
2287 sqlite3_log(SQLITE_FULL
, "MJ collide: %s", zMaster
);
2291 sqlite3_randomness(sizeof(iRandom
), &iRandom
);
2292 sqlite3_snprintf(13, &zMaster
[nMainFile
], "-mj%06X9%02X",
2293 (iRandom
>>8)&0xffffff, iRandom
&0xff);
2294 /* The antipenultimate character of the master journal name must
2295 ** be "9" to avoid name collisions when using 8+3 filenames. */
2296 assert( zMaster
[sqlite3Strlen30(zMaster
)-3]=='9' );
2297 sqlite3FileSuffix3(zMainFile
, zMaster
);
2298 rc
= sqlite3OsAccess(pVfs
, zMaster
, SQLITE_ACCESS_EXISTS
, &res
);
2299 }while( rc
==SQLITE_OK
&& res
);
2300 if( rc
==SQLITE_OK
){
2301 /* Open the master journal. */
2302 rc
= sqlite3OsOpenMalloc(pVfs
, zMaster
, &pMaster
,
2303 SQLITE_OPEN_READWRITE
|SQLITE_OPEN_CREATE
|
2304 SQLITE_OPEN_EXCLUSIVE
|SQLITE_OPEN_MASTER_JOURNAL
, 0
2307 if( rc
!=SQLITE_OK
){
2308 sqlite3DbFree(db
, zMaster
);
2312 /* Write the name of each database file in the transaction into the new
2313 ** master journal file. If an error occurs at this point close
2314 ** and delete the master journal file. All the individual journal files
2315 ** still have 'null' as the master journal pointer, so they will roll
2316 ** back independently if a failure occurs.
2318 for(i
=0; i
<db
->nDb
; i
++){
2319 Btree
*pBt
= db
->aDb
[i
].pBt
;
2320 if( sqlite3BtreeIsInTrans(pBt
) ){
2321 char const *zFile
= sqlite3BtreeGetJournalname(pBt
);
2323 continue; /* Ignore TEMP and :memory: databases */
2325 assert( zFile
[0]!=0 );
2326 rc
= sqlite3OsWrite(pMaster
, zFile
, sqlite3Strlen30(zFile
)+1, offset
);
2327 offset
+= sqlite3Strlen30(zFile
)+1;
2328 if( rc
!=SQLITE_OK
){
2329 sqlite3OsCloseFree(pMaster
);
2330 sqlite3OsDelete(pVfs
, zMaster
, 0);
2331 sqlite3DbFree(db
, zMaster
);
2337 /* Sync the master journal file. If the IOCAP_SEQUENTIAL device
2338 ** flag is set this is not required.
2340 if( 0==(sqlite3OsDeviceCharacteristics(pMaster
)&SQLITE_IOCAP_SEQUENTIAL
)
2341 && SQLITE_OK
!=(rc
= sqlite3OsSync(pMaster
, SQLITE_SYNC_NORMAL
))
2343 sqlite3OsCloseFree(pMaster
);
2344 sqlite3OsDelete(pVfs
, zMaster
, 0);
2345 sqlite3DbFree(db
, zMaster
);
2349 /* Sync all the db files involved in the transaction. The same call
2350 ** sets the master journal pointer in each individual journal. If
2351 ** an error occurs here, do not delete the master journal file.
2353 ** If the error occurs during the first call to
2354 ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
2355 ** master journal file will be orphaned. But we cannot delete it,
2356 ** in case the master journal file name was written into the journal
2357 ** file before the failure occurred.
2359 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2360 Btree
*pBt
= db
->aDb
[i
].pBt
;
2362 rc
= sqlite3BtreeCommitPhaseOne(pBt
, zMaster
);
2365 sqlite3OsCloseFree(pMaster
);
2366 assert( rc
!=SQLITE_BUSY
);
2367 if( rc
!=SQLITE_OK
){
2368 sqlite3DbFree(db
, zMaster
);
2372 /* Delete the master journal file. This commits the transaction. After
2373 ** doing this the directory is synced again before any individual
2374 ** transaction files are deleted.
2376 rc
= sqlite3OsDelete(pVfs
, zMaster
, 1);
2377 sqlite3DbFree(db
, zMaster
);
2383 /* All files and directories have already been synced, so the following
2384 ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
2385 ** deleting or truncating journals. If something goes wrong while
2386 ** this is happening we don't really care. The integrity of the
2387 ** transaction is already guaranteed, but some stray 'cold' journals
2388 ** may be lying around. Returning an error code won't help matters.
2390 disable_simulated_io_errors();
2391 sqlite3BeginBenignMalloc();
2392 for(i
=0; i
<db
->nDb
; i
++){
2393 Btree
*pBt
= db
->aDb
[i
].pBt
;
2395 sqlite3BtreeCommitPhaseTwo(pBt
, 1);
2398 sqlite3EndBenignMalloc();
2399 enable_simulated_io_errors();
2401 sqlite3VtabCommit(db
);
2409 ** This routine checks that the sqlite3.nVdbeActive count variable
2410 ** matches the number of vdbe's in the list sqlite3.pVdbe that are
2411 ** currently active. An assertion fails if the two counts do not match.
2412 ** This is an internal self-check only - it is not an essential processing
2415 ** This is a no-op if NDEBUG is defined.
2418 static void checkActiveVdbeCnt(sqlite3
*db
){
2425 if( sqlite3_stmt_busy((sqlite3_stmt
*)p
) ){
2427 if( p
->readOnly
==0 ) nWrite
++;
2428 if( p
->bIsReader
) nRead
++;
2432 assert( cnt
==db
->nVdbeActive
);
2433 assert( nWrite
==db
->nVdbeWrite
);
2434 assert( nRead
==db
->nVdbeRead
);
2437 #define checkActiveVdbeCnt(x)
2441 ** If the Vdbe passed as the first argument opened a statement-transaction,
2442 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
2443 ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
2444 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
2445 ** statement transaction is committed.
2447 ** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned.
2448 ** Otherwise SQLITE_OK.
2450 int sqlite3VdbeCloseStatement(Vdbe
*p
, int eOp
){
2451 sqlite3
*const db
= p
->db
;
2454 /* If p->iStatement is greater than zero, then this Vdbe opened a
2455 ** statement transaction that should be closed here. The only exception
2456 ** is that an IO error may have occurred, causing an emergency rollback.
2457 ** In this case (db->nStatement==0), and there is nothing to do.
2459 if( db
->nStatement
&& p
->iStatement
){
2461 const int iSavepoint
= p
->iStatement
-1;
2463 assert( eOp
==SAVEPOINT_ROLLBACK
|| eOp
==SAVEPOINT_RELEASE
);
2464 assert( db
->nStatement
>0 );
2465 assert( p
->iStatement
==(db
->nStatement
+db
->nSavepoint
) );
2467 for(i
=0; i
<db
->nDb
; i
++){
2468 int rc2
= SQLITE_OK
;
2469 Btree
*pBt
= db
->aDb
[i
].pBt
;
2471 if( eOp
==SAVEPOINT_ROLLBACK
){
2472 rc2
= sqlite3BtreeSavepoint(pBt
, SAVEPOINT_ROLLBACK
, iSavepoint
);
2474 if( rc2
==SQLITE_OK
){
2475 rc2
= sqlite3BtreeSavepoint(pBt
, SAVEPOINT_RELEASE
, iSavepoint
);
2477 if( rc
==SQLITE_OK
){
2485 if( rc
==SQLITE_OK
){
2486 if( eOp
==SAVEPOINT_ROLLBACK
){
2487 rc
= sqlite3VtabSavepoint(db
, SAVEPOINT_ROLLBACK
, iSavepoint
);
2489 if( rc
==SQLITE_OK
){
2490 rc
= sqlite3VtabSavepoint(db
, SAVEPOINT_RELEASE
, iSavepoint
);
2494 /* If the statement transaction is being rolled back, also restore the
2495 ** database handles deferred constraint counter to the value it had when
2496 ** the statement transaction was opened. */
2497 if( eOp
==SAVEPOINT_ROLLBACK
){
2498 db
->nDeferredCons
= p
->nStmtDefCons
;
2499 db
->nDeferredImmCons
= p
->nStmtDefImmCons
;
2506 ** This function is called when a transaction opened by the database
2507 ** handle associated with the VM passed as an argument is about to be
2508 ** committed. If there are outstanding deferred foreign key constraint
2509 ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
2511 ** If there are outstanding FK violations and this function returns
2512 ** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY
2513 ** and write an error message to it. Then return SQLITE_ERROR.
2515 #ifndef SQLITE_OMIT_FOREIGN_KEY
2516 int sqlite3VdbeCheckFk(Vdbe
*p
, int deferred
){
2517 sqlite3
*db
= p
->db
;
2518 if( (deferred
&& (db
->nDeferredCons
+db
->nDeferredImmCons
)>0)
2519 || (!deferred
&& p
->nFkConstraint
>0)
2521 p
->rc
= SQLITE_CONSTRAINT_FOREIGNKEY
;
2522 p
->errorAction
= OE_Abort
;
2523 sqlite3VdbeError(p
, "FOREIGN KEY constraint failed");
2524 return SQLITE_ERROR
;
2531 ** This routine is called the when a VDBE tries to halt. If the VDBE
2532 ** has made changes and is in autocommit mode, then commit those
2533 ** changes. If a rollback is needed, then do the rollback.
2535 ** This routine is the only way to move the state of a VM from
2536 ** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to
2537 ** call this on a VM that is in the SQLITE_MAGIC_HALT state.
2539 ** Return an error code. If the commit could not complete because of
2540 ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it
2541 ** means the close did not happen and needs to be repeated.
2543 int sqlite3VdbeHalt(Vdbe
*p
){
2544 int rc
; /* Used to store transient return codes */
2545 sqlite3
*db
= p
->db
;
2547 /* This function contains the logic that determines if a statement or
2548 ** transaction will be committed or rolled back as a result of the
2549 ** execution of this virtual machine.
2551 ** If any of the following errors occur:
2558 ** Then the internal cache might have been left in an inconsistent
2559 ** state. We need to rollback the statement transaction, if there is
2560 ** one, or the complete transaction if there is no statement transaction.
2563 if( db
->mallocFailed
){
2564 p
->rc
= SQLITE_NOMEM_BKPT
;
2566 if( p
->aOnceFlag
) memset(p
->aOnceFlag
, 0, p
->nOnceFlag
);
2568 if( p
->magic
!=VDBE_MAGIC_RUN
){
2571 checkActiveVdbeCnt(db
);
2573 /* No commit or rollback needed if the program never started or if the
2574 ** SQL statement does not read or write a database file. */
2575 if( p
->pc
>=0 && p
->bIsReader
){
2576 int mrc
; /* Primary error code from p->rc */
2577 int eStatementOp
= 0;
2578 int isSpecialError
; /* Set to true if a 'special' error */
2580 /* Lock all btrees used by the statement */
2581 sqlite3VdbeEnter(p
);
2583 /* Check for one of the special errors */
2585 isSpecialError
= mrc
==SQLITE_NOMEM
|| mrc
==SQLITE_IOERR
2586 || mrc
==SQLITE_INTERRUPT
|| mrc
==SQLITE_FULL
;
2587 if( isSpecialError
){
2588 /* If the query was read-only and the error code is SQLITE_INTERRUPT,
2589 ** no rollback is necessary. Otherwise, at least a savepoint
2590 ** transaction must be rolled back to restore the database to a
2591 ** consistent state.
2593 ** Even if the statement is read-only, it is important to perform
2594 ** a statement or transaction rollback operation. If the error
2595 ** occurred while writing to the journal, sub-journal or database
2596 ** file as part of an effort to free up cache space (see function
2597 ** pagerStress() in pager.c), the rollback is required to restore
2598 ** the pager to a consistent state.
2600 if( !p
->readOnly
|| mrc
!=SQLITE_INTERRUPT
){
2601 if( (mrc
==SQLITE_NOMEM
|| mrc
==SQLITE_FULL
) && p
->usesStmtJournal
){
2602 eStatementOp
= SAVEPOINT_ROLLBACK
;
2604 /* We are forced to roll back the active transaction. Before doing
2605 ** so, abort any other statements this handle currently has active.
2607 sqlite3RollbackAll(db
, SQLITE_ABORT_ROLLBACK
);
2608 sqlite3CloseSavepoints(db
);
2615 /* Check for immediate foreign key violations. */
2616 if( p
->rc
==SQLITE_OK
){
2617 sqlite3VdbeCheckFk(p
, 0);
2620 /* If the auto-commit flag is set and this is the only active writer
2621 ** VM, then we do either a commit or rollback of the current transaction.
2623 ** Note: This block also runs if one of the special errors handled
2624 ** above has occurred.
2626 if( !sqlite3VtabInSync(db
)
2628 && db
->nVdbeWrite
==(p
->readOnly
==0)
2630 if( p
->rc
==SQLITE_OK
|| (p
->errorAction
==OE_Fail
&& !isSpecialError
) ){
2631 rc
= sqlite3VdbeCheckFk(p
, 1);
2632 if( rc
!=SQLITE_OK
){
2633 if( NEVER(p
->readOnly
) ){
2634 sqlite3VdbeLeave(p
);
2635 return SQLITE_ERROR
;
2637 rc
= SQLITE_CONSTRAINT_FOREIGNKEY
;
2639 /* The auto-commit flag is true, the vdbe program was successful
2640 ** or hit an 'OR FAIL' constraint and there are no deferred foreign
2641 ** key constraints to hold up the transaction. This means a commit
2643 rc
= vdbeCommit(db
, p
);
2645 if( rc
==SQLITE_BUSY
&& p
->readOnly
){
2646 sqlite3VdbeLeave(p
);
2648 }else if( rc
!=SQLITE_OK
){
2650 sqlite3RollbackAll(db
, SQLITE_OK
);
2653 db
->nDeferredCons
= 0;
2654 db
->nDeferredImmCons
= 0;
2655 db
->flags
&= ~SQLITE_DeferFKs
;
2656 sqlite3CommitInternalChanges(db
);
2659 sqlite3RollbackAll(db
, SQLITE_OK
);
2663 }else if( eStatementOp
==0 ){
2664 if( p
->rc
==SQLITE_OK
|| p
->errorAction
==OE_Fail
){
2665 eStatementOp
= SAVEPOINT_RELEASE
;
2666 }else if( p
->errorAction
==OE_Abort
){
2667 eStatementOp
= SAVEPOINT_ROLLBACK
;
2669 sqlite3RollbackAll(db
, SQLITE_ABORT_ROLLBACK
);
2670 sqlite3CloseSavepoints(db
);
2676 /* If eStatementOp is non-zero, then a statement transaction needs to
2677 ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to
2678 ** do so. If this operation returns an error, and the current statement
2679 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
2680 ** current statement error code.
2683 rc
= sqlite3VdbeCloseStatement(p
, eStatementOp
);
2685 if( p
->rc
==SQLITE_OK
|| (p
->rc
&0xff)==SQLITE_CONSTRAINT
){
2687 sqlite3DbFree(db
, p
->zErrMsg
);
2690 sqlite3RollbackAll(db
, SQLITE_ABORT_ROLLBACK
);
2691 sqlite3CloseSavepoints(db
);
2697 /* If this was an INSERT, UPDATE or DELETE and no statement transaction
2698 ** has been rolled back, update the database connection change-counter.
2700 if( p
->changeCntOn
){
2701 if( eStatementOp
!=SAVEPOINT_ROLLBACK
){
2702 sqlite3VdbeSetChanges(db
, p
->nChange
);
2704 sqlite3VdbeSetChanges(db
, 0);
2709 /* Release the locks */
2710 sqlite3VdbeLeave(p
);
2713 /* We have successfully halted and closed the VM. Record this fact. */
2716 if( !p
->readOnly
) db
->nVdbeWrite
--;
2717 if( p
->bIsReader
) db
->nVdbeRead
--;
2718 assert( db
->nVdbeActive
>=db
->nVdbeRead
);
2719 assert( db
->nVdbeRead
>=db
->nVdbeWrite
);
2720 assert( db
->nVdbeWrite
>=0 );
2722 p
->magic
= VDBE_MAGIC_HALT
;
2723 checkActiveVdbeCnt(db
);
2724 if( db
->mallocFailed
){
2725 p
->rc
= SQLITE_NOMEM_BKPT
;
2728 /* If the auto-commit flag is set to true, then any locks that were held
2729 ** by connection db have now been released. Call sqlite3ConnectionUnlocked()
2730 ** to invoke any required unlock-notify callbacks.
2732 if( db
->autoCommit
){
2733 sqlite3ConnectionUnlocked(db
);
2736 assert( db
->nVdbeActive
>0 || db
->autoCommit
==0 || db
->nStatement
==0 );
2737 return (p
->rc
==SQLITE_BUSY
? SQLITE_BUSY
: SQLITE_OK
);
2742 ** Each VDBE holds the result of the most recent sqlite3_step() call
2743 ** in p->rc. This routine sets that result back to SQLITE_OK.
2745 void sqlite3VdbeResetStepResult(Vdbe
*p
){
2750 ** Copy the error code and error message belonging to the VDBE passed
2751 ** as the first argument to its database handle (so that they will be
2752 ** returned by calls to sqlite3_errcode() and sqlite3_errmsg()).
2754 ** This function does not clear the VDBE error code or message, just
2755 ** copies them to the database handle.
2757 int sqlite3VdbeTransferError(Vdbe
*p
){
2758 sqlite3
*db
= p
->db
;
2761 db
->bBenignMalloc
++;
2762 sqlite3BeginBenignMalloc();
2763 if( db
->pErr
==0 ) db
->pErr
= sqlite3ValueNew(db
);
2764 sqlite3ValueSetStr(db
->pErr
, -1, p
->zErrMsg
, SQLITE_UTF8
, SQLITE_TRANSIENT
);
2765 sqlite3EndBenignMalloc();
2766 db
->bBenignMalloc
--;
2769 sqlite3Error(db
, rc
);
2774 #ifdef SQLITE_ENABLE_SQLLOG
2776 ** If an SQLITE_CONFIG_SQLLOG hook is registered and the VM has been run,
2779 static void vdbeInvokeSqllog(Vdbe
*v
){
2780 if( sqlite3GlobalConfig
.xSqllog
&& v
->rc
==SQLITE_OK
&& v
->zSql
&& v
->pc
>=0 ){
2781 char *zExpanded
= sqlite3VdbeExpandSql(v
, v
->zSql
);
2782 assert( v
->db
->init
.busy
==0 );
2784 sqlite3GlobalConfig
.xSqllog(
2785 sqlite3GlobalConfig
.pSqllogArg
, v
->db
, zExpanded
, 1
2787 sqlite3DbFree(v
->db
, zExpanded
);
2792 # define vdbeInvokeSqllog(x)
2796 ** Clean up a VDBE after execution but do not delete the VDBE just yet.
2797 ** Write any error messages into *pzErrMsg. Return the result code.
2799 ** After this routine is run, the VDBE should be ready to be executed
2802 ** To look at it another way, this routine resets the state of the
2803 ** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to
2806 int sqlite3VdbeReset(Vdbe
*p
){
2810 /* If the VM did not run to completion or if it encountered an
2811 ** error, then it might not have been halted properly. So halt
2816 /* If the VDBE has be run even partially, then transfer the error code
2817 ** and error message from the VDBE into the main database structure. But
2818 ** if the VDBE has just been set to run but has not actually executed any
2819 ** instructions yet, leave the main database error information unchanged.
2822 vdbeInvokeSqllog(p
);
2823 sqlite3VdbeTransferError(p
);
2824 sqlite3DbFree(db
, p
->zErrMsg
);
2826 if( p
->runOnlyOnce
) p
->expired
= 1;
2827 }else if( p
->rc
&& p
->expired
){
2828 /* The expired flag was set on the VDBE before the first call
2829 ** to sqlite3_step(). For consistency (since sqlite3_step() was
2830 ** called), set the database error in this case as well.
2832 sqlite3ErrorWithMsg(db
, p
->rc
, p
->zErrMsg
? "%s" : 0, p
->zErrMsg
);
2833 sqlite3DbFree(db
, p
->zErrMsg
);
2837 /* Reclaim all memory used by the VDBE
2841 /* Save profiling information from this VDBE run.
2845 FILE *out
= fopen("vdbe_profile.out", "a");
2848 fprintf(out
, "---- ");
2849 for(i
=0; i
<p
->nOp
; i
++){
2850 fprintf(out
, "%02x", p
->aOp
[i
].opcode
);
2855 fprintf(out
, "-- ");
2856 for(i
=0; (c
= p
->zSql
[i
])!=0; i
++){
2857 if( pc
=='\n' ) fprintf(out
, "-- ");
2861 if( pc
!='\n' ) fprintf(out
, "\n");
2863 for(i
=0; i
<p
->nOp
; i
++){
2865 sqlite3_snprintf(sizeof(zHdr
), zHdr
, "%6u %12llu %8llu ",
2868 p
->aOp
[i
].cnt
>0 ? p
->aOp
[i
].cycles
/p
->aOp
[i
].cnt
: 0
2870 fprintf(out
, "%s", zHdr
);
2871 sqlite3VdbePrintOp(out
, i
, &p
->aOp
[i
]);
2877 p
->iCurrentTime
= 0;
2878 p
->magic
= VDBE_MAGIC_INIT
;
2879 return p
->rc
& db
->errMask
;
2883 ** Clean up and delete a VDBE after execution. Return an integer which is
2884 ** the result code. Write any error message text into *pzErrMsg.
2886 int sqlite3VdbeFinalize(Vdbe
*p
){
2888 if( p
->magic
==VDBE_MAGIC_RUN
|| p
->magic
==VDBE_MAGIC_HALT
){
2889 rc
= sqlite3VdbeReset(p
);
2890 assert( (rc
& p
->db
->errMask
)==rc
);
2892 sqlite3VdbeDelete(p
);
2897 ** If parameter iOp is less than zero, then invoke the destructor for
2898 ** all auxiliary data pointers currently cached by the VM passed as
2899 ** the first argument.
2901 ** Or, if iOp is greater than or equal to zero, then the destructor is
2902 ** only invoked for those auxiliary data pointers created by the user
2903 ** function invoked by the OP_Function opcode at instruction iOp of
2904 ** VM pVdbe, and only then if:
2906 ** * the associated function parameter is the 32nd or later (counting
2907 ** from left to right), or
2909 ** * the corresponding bit in argument mask is clear (where the first
2910 ** function parameter corresponds to bit 0 etc.).
2912 void sqlite3VdbeDeleteAuxData(sqlite3
*db
, AuxData
**pp
, int iOp
, int mask
){
2914 AuxData
*pAux
= *pp
;
2916 || (pAux
->iOp
==iOp
&& (pAux
->iArg
>31 || !(mask
& MASKBIT32(pAux
->iArg
))))
2918 testcase( pAux
->iArg
==31 );
2919 if( pAux
->xDelete
){
2920 pAux
->xDelete(pAux
->pAux
);
2923 sqlite3DbFree(db
, pAux
);
2931 ** Free all memory associated with the Vdbe passed as the second argument,
2932 ** except for object itself, which is preserved.
2934 ** The difference between this function and sqlite3VdbeDelete() is that
2935 ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
2936 ** the database connection and frees the object itself.
2938 void sqlite3VdbeClearObject(sqlite3
*db
, Vdbe
*p
){
2939 SubProgram
*pSub
, *pNext
;
2941 assert( p
->db
==0 || p
->db
==db
);
2942 releaseMemArray(p
->aVar
, p
->nVar
);
2943 releaseMemArray(p
->aColName
, p
->nResColumn
*COLNAME_N
);
2944 for(pSub
=p
->pProgram
; pSub
; pSub
=pNext
){
2945 pNext
= pSub
->pNext
;
2946 vdbeFreeOpArray(db
, pSub
->aOp
, pSub
->nOp
);
2947 sqlite3DbFree(db
, pSub
);
2949 for(i
=p
->nzVar
-1; i
>=0; i
--) sqlite3DbFree(db
, p
->azVar
[i
]);
2950 sqlite3DbFree(db
, p
->azVar
);
2951 vdbeFreeOpArray(db
, p
->aOp
, p
->nOp
);
2952 sqlite3DbFree(db
, p
->aColName
);
2953 sqlite3DbFree(db
, p
->zSql
);
2954 sqlite3DbFree(db
, p
->pFree
);
2955 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
2956 for(i
=0; i
<p
->nScan
; i
++){
2957 sqlite3DbFree(db
, p
->aScan
[i
].zName
);
2959 sqlite3DbFree(db
, p
->aScan
);
2964 ** Delete an entire VDBE.
2966 void sqlite3VdbeDelete(Vdbe
*p
){
2969 if( NEVER(p
==0) ) return;
2971 assert( sqlite3_mutex_held(db
->mutex
) );
2972 sqlite3VdbeClearObject(db
, p
);
2974 p
->pPrev
->pNext
= p
->pNext
;
2976 assert( db
->pVdbe
==p
);
2977 db
->pVdbe
= p
->pNext
;
2980 p
->pNext
->pPrev
= p
->pPrev
;
2982 p
->magic
= VDBE_MAGIC_DEAD
;
2984 sqlite3DbFree(db
, p
);
2988 ** The cursor "p" has a pending seek operation that has not yet been
2989 ** carried out. Seek the cursor now. If an error occurs, return
2990 ** the appropriate error code.
2992 static int SQLITE_NOINLINE
handleDeferredMoveto(VdbeCursor
*p
){
2995 extern int sqlite3_search_count
;
2997 assert( p
->deferredMoveto
);
2998 assert( p
->isTable
);
2999 assert( p
->eCurType
==CURTYPE_BTREE
);
3000 rc
= sqlite3BtreeMovetoUnpacked(p
->uc
.pCursor
, 0, p
->movetoTarget
, 0, &res
);
3002 if( res
!=0 ) return SQLITE_CORRUPT_BKPT
;
3004 sqlite3_search_count
++;
3006 p
->deferredMoveto
= 0;
3007 p
->cacheStatus
= CACHE_STALE
;
3012 ** Something has moved cursor "p" out of place. Maybe the row it was
3013 ** pointed to was deleted out from under it. Or maybe the btree was
3014 ** rebalanced. Whatever the cause, try to restore "p" to the place it
3015 ** is supposed to be pointing. If the row was deleted out from under the
3016 ** cursor, set the cursor to point to a NULL row.
3018 static int SQLITE_NOINLINE
handleMovedCursor(VdbeCursor
*p
){
3019 int isDifferentRow
, rc
;
3020 assert( p
->eCurType
==CURTYPE_BTREE
);
3021 assert( p
->uc
.pCursor
!=0 );
3022 assert( sqlite3BtreeCursorHasMoved(p
->uc
.pCursor
) );
3023 rc
= sqlite3BtreeCursorRestore(p
->uc
.pCursor
, &isDifferentRow
);
3024 p
->cacheStatus
= CACHE_STALE
;
3025 if( isDifferentRow
) p
->nullRow
= 1;
3030 ** Check to ensure that the cursor is valid. Restore the cursor
3031 ** if need be. Return any I/O error from the restore operation.
3033 int sqlite3VdbeCursorRestore(VdbeCursor
*p
){
3034 assert( p
->eCurType
==CURTYPE_BTREE
);
3035 if( sqlite3BtreeCursorHasMoved(p
->uc
.pCursor
) ){
3036 return handleMovedCursor(p
);
3042 ** Make sure the cursor p is ready to read or write the row to which it
3043 ** was last positioned. Return an error code if an OOM fault or I/O error
3044 ** prevents us from positioning the cursor to its correct position.
3046 ** If a MoveTo operation is pending on the given cursor, then do that
3047 ** MoveTo now. If no move is pending, check to see if the row has been
3048 ** deleted out from under the cursor and if it has, mark the row as
3051 ** If the cursor is already pointing to the correct row and that row has
3052 ** not been deleted out from under the cursor, then this routine is a no-op.
3054 int sqlite3VdbeCursorMoveto(VdbeCursor
**pp
, int *piCol
){
3055 VdbeCursor
*p
= *pp
;
3056 if( p
->eCurType
==CURTYPE_BTREE
){
3057 if( p
->deferredMoveto
){
3059 if( p
->aAltMap
&& (iMap
= p
->aAltMap
[1+*piCol
])>0 ){
3060 *pp
= p
->pAltCursor
;
3064 return handleDeferredMoveto(p
);
3066 if( sqlite3BtreeCursorHasMoved(p
->uc
.pCursor
) ){
3067 return handleMovedCursor(p
);
3074 ** The following functions:
3076 ** sqlite3VdbeSerialType()
3077 ** sqlite3VdbeSerialTypeLen()
3078 ** sqlite3VdbeSerialLen()
3079 ** sqlite3VdbeSerialPut()
3080 ** sqlite3VdbeSerialGet()
3082 ** encapsulate the code that serializes values for storage in SQLite
3083 ** data and index records. Each serialized value consists of a
3084 ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
3085 ** integer, stored as a varint.
3087 ** In an SQLite index record, the serial type is stored directly before
3088 ** the blob of data that it corresponds to. In a table record, all serial
3089 ** types are stored at the start of the record, and the blobs of data at
3090 ** the end. Hence these functions allow the caller to handle the
3091 ** serial-type and data blob separately.
3093 ** The following table describes the various storage classes for data:
3095 ** serial type bytes of data type
3096 ** -------------- --------------- ---------------
3098 ** 1 1 signed integer
3099 ** 2 2 signed integer
3100 ** 3 3 signed integer
3101 ** 4 4 signed integer
3102 ** 5 6 signed integer
3103 ** 6 8 signed integer
3105 ** 8 0 Integer constant 0
3106 ** 9 0 Integer constant 1
3107 ** 10,11 reserved for expansion
3108 ** N>=12 and even (N-12)/2 BLOB
3109 ** N>=13 and odd (N-13)/2 text
3111 ** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions
3112 ** of SQLite will not understand those serial types.
3116 ** Return the serial-type for the value stored in pMem.
3118 u32
sqlite3VdbeSerialType(Mem
*pMem
, int file_format
, u32
*pLen
){
3119 int flags
= pMem
->flags
;
3123 if( flags
&MEM_Null
){
3127 if( flags
&MEM_Int
){
3128 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
3129 # define MAX_6BYTE ((((i64)0x00008000)<<32)-1)
3138 if( (i
&1)==i
&& file_format
>=4 ){
3146 if( u
<=32767 ){ *pLen
= 2; return 2; }
3147 if( u
<=8388607 ){ *pLen
= 3; return 3; }
3148 if( u
<=2147483647 ){ *pLen
= 4; return 4; }
3149 if( u
<=MAX_6BYTE
){ *pLen
= 6; return 5; }
3153 if( flags
&MEM_Real
){
3157 assert( pMem
->db
->mallocFailed
|| flags
&(MEM_Str
|MEM_Blob
) );
3158 assert( pMem
->n
>=0 );
3160 if( flags
& MEM_Zero
){
3164 return ((n
*2) + 12 + ((flags
&MEM_Str
)!=0));
3168 ** The sizes for serial types less than 128
3170 static const u8 sqlite3SmallTypeSizes
[] = {
3171 /* 0 1 2 3 4 5 6 7 8 9 */
3172 /* 0 */ 0, 1, 2, 3, 4, 6, 8, 8, 0, 0,
3173 /* 10 */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3,
3174 /* 20 */ 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
3175 /* 30 */ 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,
3176 /* 40 */ 14, 14, 15, 15, 16, 16, 17, 17, 18, 18,
3177 /* 50 */ 19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
3178 /* 60 */ 24, 24, 25, 25, 26, 26, 27, 27, 28, 28,
3179 /* 70 */ 29, 29, 30, 30, 31, 31, 32, 32, 33, 33,
3180 /* 80 */ 34, 34, 35, 35, 36, 36, 37, 37, 38, 38,
3181 /* 90 */ 39, 39, 40, 40, 41, 41, 42, 42, 43, 43,
3182 /* 100 */ 44, 44, 45, 45, 46, 46, 47, 47, 48, 48,
3183 /* 110 */ 49, 49, 50, 50, 51, 51, 52, 52, 53, 53,
3184 /* 120 */ 54, 54, 55, 55, 56, 56, 57, 57
3188 ** Return the length of the data corresponding to the supplied serial-type.
3190 u32
sqlite3VdbeSerialTypeLen(u32 serial_type
){
3191 if( serial_type
>=128 ){
3192 return (serial_type
-12)/2;
3194 assert( serial_type
<12
3195 || sqlite3SmallTypeSizes
[serial_type
]==(serial_type
- 12)/2 );
3196 return sqlite3SmallTypeSizes
[serial_type
];
3199 u8
sqlite3VdbeOneByteSerialTypeLen(u8 serial_type
){
3200 assert( serial_type
<128 );
3201 return sqlite3SmallTypeSizes
[serial_type
];
3205 ** If we are on an architecture with mixed-endian floating
3206 ** points (ex: ARM7) then swap the lower 4 bytes with the
3207 ** upper 4 bytes. Return the result.
3209 ** For most architectures, this is a no-op.
3211 ** (later): It is reported to me that the mixed-endian problem
3212 ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
3213 ** that early versions of GCC stored the two words of a 64-bit
3214 ** float in the wrong order. And that error has been propagated
3215 ** ever since. The blame is not necessarily with GCC, though.
3216 ** GCC might have just copying the problem from a prior compiler.
3217 ** I am also told that newer versions of GCC that follow a different
3218 ** ABI get the byte order right.
3220 ** Developers using SQLite on an ARM7 should compile and run their
3221 ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
3222 ** enabled, some asserts below will ensure that the byte order of
3223 ** floating point values is correct.
3225 ** (2007-08-30) Frank van Vugt has studied this problem closely
3226 ** and has send his findings to the SQLite developers. Frank
3227 ** writes that some Linux kernels offer floating point hardware
3228 ** emulation that uses only 32-bit mantissas instead of a full
3229 ** 48-bits as required by the IEEE standard. (This is the
3230 ** CONFIG_FPE_FASTFPE option.) On such systems, floating point
3231 ** byte swapping becomes very complicated. To avoid problems,
3232 ** the necessary byte swapping is carried out using a 64-bit integer
3233 ** rather than a 64-bit float. Frank assures us that the code here
3234 ** works for him. We, the developers, have no way to independently
3235 ** verify this, but Frank seems to know what he is talking about
3238 #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
3239 static u64
floatSwap(u64 in
){
3252 # define swapMixedEndianFloat(X) X = floatSwap(X)
3254 # define swapMixedEndianFloat(X)
3258 ** Write the serialized data blob for the value stored in pMem into
3259 ** buf. It is assumed that the caller has allocated sufficient space.
3260 ** Return the number of bytes written.
3262 ** nBuf is the amount of space left in buf[]. The caller is responsible
3263 ** for allocating enough space to buf[] to hold the entire field, exclusive
3264 ** of the pMem->u.nZero bytes for a MEM_Zero value.
3266 ** Return the number of bytes actually written into buf[]. The number
3267 ** of bytes in the zero-filled tail is included in the return value only
3268 ** if those bytes were zeroed in buf[].
3270 u32
sqlite3VdbeSerialPut(u8
*buf
, Mem
*pMem
, u32 serial_type
){
3273 /* Integer and Real */
3274 if( serial_type
<=7 && serial_type
>0 ){
3277 if( serial_type
==7 ){
3278 assert( sizeof(v
)==sizeof(pMem
->u
.r
) );
3279 memcpy(&v
, &pMem
->u
.r
, sizeof(v
));
3280 swapMixedEndianFloat(v
);
3284 len
= i
= sqlite3SmallTypeSizes
[serial_type
];
3287 buf
[--i
] = (u8
)(v
&0xFF);
3293 /* String or blob */
3294 if( serial_type
>=12 ){
3295 assert( pMem
->n
+ ((pMem
->flags
& MEM_Zero
)?pMem
->u
.nZero
:0)
3296 == (int)sqlite3VdbeSerialTypeLen(serial_type
) );
3298 if( len
>0 ) memcpy(buf
, pMem
->z
, len
);
3302 /* NULL or constants 0 or 1 */
3306 /* Input "x" is a sequence of unsigned characters that represent a
3307 ** big-endian integer. Return the equivalent native integer
3309 #define ONE_BYTE_INT(x) ((i8)(x)[0])
3310 #define TWO_BYTE_INT(x) (256*(i8)((x)[0])|(x)[1])
3311 #define THREE_BYTE_INT(x) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2])
3312 #define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
3313 #define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
3316 ** Deserialize the data blob pointed to by buf as serial type serial_type
3317 ** and store the result in pMem. Return the number of bytes read.
3319 ** This function is implemented as two separate routines for performance.
3320 ** The few cases that require local variables are broken out into a separate
3321 ** routine so that in most cases the overhead of moving the stack pointer
3324 static u32 SQLITE_NOINLINE
serialGet(
3325 const unsigned char *buf
, /* Buffer to deserialize from */
3326 u32 serial_type
, /* Serial type to deserialize */
3327 Mem
*pMem
/* Memory cell to write value into */
3329 u64 x
= FOUR_BYTE_UINT(buf
);
3330 u32 y
= FOUR_BYTE_UINT(buf
+4);
3332 if( serial_type
==6 ){
3333 /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit
3334 ** twos-complement integer. */
3335 pMem
->u
.i
= *(i64
*)&x
;
3336 pMem
->flags
= MEM_Int
;
3337 testcase( pMem
->u
.i
<0 );
3339 /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit
3340 ** floating point number. */
3341 #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
3342 /* Verify that integers and floating point values use the same
3343 ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
3344 ** defined that 64-bit floating point values really are mixed
3347 static const u64 t1
= ((u64
)0x3ff00000)<<32;
3348 static const double r1
= 1.0;
3350 swapMixedEndianFloat(t2
);
3351 assert( sizeof(r1
)==sizeof(t2
) && memcmp(&r1
, &t2
, sizeof(r1
))==0 );
3353 assert( sizeof(x
)==8 && sizeof(pMem
->u
.r
)==8 );
3354 swapMixedEndianFloat(x
);
3355 memcpy(&pMem
->u
.r
, &x
, sizeof(x
));
3356 pMem
->flags
= sqlite3IsNaN(pMem
->u
.r
) ? MEM_Null
: MEM_Real
;
3360 u32
sqlite3VdbeSerialGet(
3361 const unsigned char *buf
, /* Buffer to deserialize from */
3362 u32 serial_type
, /* Serial type to deserialize */
3363 Mem
*pMem
/* Memory cell to write value into */
3365 switch( serial_type
){
3366 case 10: /* Reserved for future use */
3367 case 11: /* Reserved for future use */
3368 case 0: { /* Null */
3369 /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */
3370 pMem
->flags
= MEM_Null
;
3374 /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement
3376 pMem
->u
.i
= ONE_BYTE_INT(buf
);
3377 pMem
->flags
= MEM_Int
;
3378 testcase( pMem
->u
.i
<0 );
3381 case 2: { /* 2-byte signed integer */
3382 /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit
3383 ** twos-complement integer. */
3384 pMem
->u
.i
= TWO_BYTE_INT(buf
);
3385 pMem
->flags
= MEM_Int
;
3386 testcase( pMem
->u
.i
<0 );
3389 case 3: { /* 3-byte signed integer */
3390 /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit
3391 ** twos-complement integer. */
3392 pMem
->u
.i
= THREE_BYTE_INT(buf
);
3393 pMem
->flags
= MEM_Int
;
3394 testcase( pMem
->u
.i
<0 );
3397 case 4: { /* 4-byte signed integer */
3398 /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit
3399 ** twos-complement integer. */
3400 pMem
->u
.i
= FOUR_BYTE_INT(buf
);
3402 /* Work around a sign-extension bug in the HP compiler for HP/UX */
3403 if( buf
[0]&0x80 ) pMem
->u
.i
|= 0xffffffff80000000LL
;
3405 pMem
->flags
= MEM_Int
;
3406 testcase( pMem
->u
.i
<0 );
3409 case 5: { /* 6-byte signed integer */
3410 /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit
3411 ** twos-complement integer. */
3412 pMem
->u
.i
= FOUR_BYTE_UINT(buf
+2) + (((i64
)1)<<32)*TWO_BYTE_INT(buf
);
3413 pMem
->flags
= MEM_Int
;
3414 testcase( pMem
->u
.i
<0 );
3417 case 6: /* 8-byte signed integer */
3418 case 7: { /* IEEE floating point */
3419 /* These use local variables, so do them in a separate routine
3420 ** to avoid having to move the frame pointer in the common case */
3421 return serialGet(buf
,serial_type
,pMem
);
3423 case 8: /* Integer 0 */
3424 case 9: { /* Integer 1 */
3425 /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */
3426 /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */
3427 pMem
->u
.i
= serial_type
-8;
3428 pMem
->flags
= MEM_Int
;
3432 /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in
3434 ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and
3435 ** (N-13)/2 bytes in length. */
3436 static const u16 aFlag
[] = { MEM_Blob
|MEM_Ephem
, MEM_Str
|MEM_Ephem
};
3437 pMem
->z
= (char *)buf
;
3438 pMem
->n
= (serial_type
-12)/2;
3439 pMem
->flags
= aFlag
[serial_type
&1];
3446 ** This routine is used to allocate sufficient space for an UnpackedRecord
3447 ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
3448 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
3450 ** The space is either allocated using sqlite3DbMallocRaw() or from within
3451 ** the unaligned buffer passed via the second and third arguments (presumably
3452 ** stack space). If the former, then *ppFree is set to a pointer that should
3453 ** be eventually freed by the caller using sqlite3DbFree(). Or, if the
3454 ** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL
3455 ** before returning.
3457 ** If an OOM error occurs, NULL is returned.
3459 UnpackedRecord
*sqlite3VdbeAllocUnpackedRecord(
3460 KeyInfo
*pKeyInfo
, /* Description of the record */
3461 char *pSpace
, /* Unaligned space available */
3462 int szSpace
, /* Size of pSpace[] in bytes */
3463 char **ppFree
/* OUT: Caller should free this pointer */
3465 UnpackedRecord
*p
; /* Unpacked record to return */
3466 int nOff
; /* Increment pSpace by nOff to align it */
3467 int nByte
; /* Number of bytes required for *p */
3469 /* We want to shift the pointer pSpace up such that it is 8-byte aligned.
3470 ** Thus, we need to calculate a value, nOff, between 0 and 7, to shift
3471 ** it by. If pSpace is already 8-byte aligned, nOff should be zero.
3473 nOff
= (8 - (SQLITE_PTR_TO_INT(pSpace
) & 7)) & 7;
3474 nByte
= ROUND8(sizeof(UnpackedRecord
)) + sizeof(Mem
)*(pKeyInfo
->nField
+1);
3475 if( nByte
>szSpace
+nOff
){
3476 p
= (UnpackedRecord
*)sqlite3DbMallocRaw(pKeyInfo
->db
, nByte
);
3477 *ppFree
= (char *)p
;
3480 p
= (UnpackedRecord
*)&pSpace
[nOff
];
3484 p
->aMem
= (Mem
*)&((char*)p
)[ROUND8(sizeof(UnpackedRecord
))];
3485 assert( pKeyInfo
->aSortOrder
!=0 );
3486 p
->pKeyInfo
= pKeyInfo
;
3487 p
->nField
= pKeyInfo
->nField
+ 1;
3492 ** Given the nKey-byte encoding of a record in pKey[], populate the
3493 ** UnpackedRecord structure indicated by the fourth argument with the
3494 ** contents of the decoded record.
3496 void sqlite3VdbeRecordUnpack(
3497 KeyInfo
*pKeyInfo
, /* Information about the record format */
3498 int nKey
, /* Size of the binary record */
3499 const void *pKey
, /* The binary record */
3500 UnpackedRecord
*p
/* Populate this structure before returning. */
3502 const unsigned char *aKey
= (const unsigned char *)pKey
;
3504 u32 idx
; /* Offset in aKey[] to read from */
3505 u16 u
; /* Unsigned loop counter */
3507 Mem
*pMem
= p
->aMem
;
3510 assert( EIGHT_BYTE_ALIGNMENT(pMem
) );
3511 idx
= getVarint32(aKey
, szHdr
);
3514 while( idx
<szHdr
&& d
<=nKey
){
3517 idx
+= getVarint32(&aKey
[idx
], serial_type
);
3518 pMem
->enc
= pKeyInfo
->enc
;
3519 pMem
->db
= pKeyInfo
->db
;
3520 /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
3523 d
+= sqlite3VdbeSerialGet(&aKey
[d
], serial_type
, pMem
);
3525 if( (++u
)>=p
->nField
) break;
3527 assert( u
<=pKeyInfo
->nField
+ 1 );
3533 ** This function compares two index or table record keys in the same way
3534 ** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(),
3535 ** this function deserializes and compares values using the
3536 ** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
3537 ** in assert() statements to ensure that the optimized code in
3538 ** sqlite3VdbeRecordCompare() returns results with these two primitives.
3540 ** Return true if the result of comparison is equivalent to desiredResult.
3541 ** Return false if there is a disagreement.
3543 static int vdbeRecordCompareDebug(
3544 int nKey1
, const void *pKey1
, /* Left key */
3545 const UnpackedRecord
*pPKey2
, /* Right key */
3546 int desiredResult
/* Correct answer */
3548 u32 d1
; /* Offset into aKey[] of next data element */
3549 u32 idx1
; /* Offset into aKey[] of next header element */
3550 u32 szHdr1
; /* Number of bytes in header */
3553 const unsigned char *aKey1
= (const unsigned char *)pKey1
;
3557 pKeyInfo
= pPKey2
->pKeyInfo
;
3558 if( pKeyInfo
->db
==0 ) return 1;
3559 mem1
.enc
= pKeyInfo
->enc
;
3560 mem1
.db
= pKeyInfo
->db
;
3561 /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */
3562 VVA_ONLY( mem1
.szMalloc
= 0; ) /* Only needed by assert() statements */
3564 /* Compilers may complain that mem1.u.i is potentially uninitialized.
3565 ** We could initialize it, as shown here, to silence those complaints.
3566 ** But in fact, mem1.u.i will never actually be used uninitialized, and doing
3567 ** the unnecessary initialization has a measurable negative performance
3568 ** impact, since this routine is a very high runner. And so, we choose
3569 ** to ignore the compiler warnings and leave this variable uninitialized.
3571 /* mem1.u.i = 0; // not needed, here to silence compiler warning */
3573 idx1
= getVarint32(aKey1
, szHdr1
);
3574 if( szHdr1
>98307 ) return SQLITE_CORRUPT
;
3576 assert( pKeyInfo
->nField
+pKeyInfo
->nXField
>=pPKey2
->nField
|| CORRUPT_DB
);
3577 assert( pKeyInfo
->aSortOrder
!=0 );
3578 assert( pKeyInfo
->nField
>0 );
3579 assert( idx1
<=szHdr1
|| CORRUPT_DB
);
3583 /* Read the serial types for the next element in each key. */
3584 idx1
+= getVarint32( aKey1
+idx1
, serial_type1
);
3586 /* Verify that there is enough key space remaining to avoid
3587 ** a buffer overread. The "d1+serial_type1+2" subexpression will
3588 ** always be greater than or equal to the amount of required key space.
3589 ** Use that approximation to avoid the more expensive call to
3590 ** sqlite3VdbeSerialTypeLen() in the common case.
3592 if( d1
+serial_type1
+2>(u32
)nKey1
3593 && d1
+sqlite3VdbeSerialTypeLen(serial_type1
)>(u32
)nKey1
3598 /* Extract the values to be compared.
3600 d1
+= sqlite3VdbeSerialGet(&aKey1
[d1
], serial_type1
, &mem1
);
3602 /* Do the comparison
3604 rc
= sqlite3MemCompare(&mem1
, &pPKey2
->aMem
[i
], pKeyInfo
->aColl
[i
]);
3606 assert( mem1
.szMalloc
==0 ); /* See comment below */
3607 if( pKeyInfo
->aSortOrder
[i
] ){
3608 rc
= -rc
; /* Invert the result for DESC sort order. */
3610 goto debugCompareEnd
;
3613 }while( idx1
<szHdr1
&& i
<pPKey2
->nField
);
3615 /* No memory allocation is ever used on mem1. Prove this using
3616 ** the following assert(). If the assert() fails, it indicates a
3617 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).
3619 assert( mem1
.szMalloc
==0 );
3621 /* rc==0 here means that one of the keys ran out of fields and
3622 ** all the fields up to that point were equal. Return the default_rc
3624 rc
= pPKey2
->default_rc
;
3627 if( desiredResult
==0 && rc
==0 ) return 1;
3628 if( desiredResult
<0 && rc
<0 ) return 1;
3629 if( desiredResult
>0 && rc
>0 ) return 1;
3630 if( CORRUPT_DB
) return 1;
3631 if( pKeyInfo
->db
->mallocFailed
) return 1;
3638 ** Count the number of fields (a.k.a. columns) in the record given by
3639 ** pKey,nKey. The verify that this count is less than or equal to the
3640 ** limit given by pKeyInfo->nField + pKeyInfo->nXField.
3642 ** If this constraint is not satisfied, it means that the high-speed
3643 ** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will
3644 ** not work correctly. If this assert() ever fires, it probably means
3645 ** that the KeyInfo.nField or KeyInfo.nXField values were computed
3648 static void vdbeAssertFieldCountWithinLimits(
3649 int nKey
, const void *pKey
, /* The record to verify */
3650 const KeyInfo
*pKeyInfo
/* Compare size with this KeyInfo */
3656 const unsigned char *aKey
= (const unsigned char*)pKey
;
3658 if( CORRUPT_DB
) return;
3659 idx
= getVarint32(aKey
, szHdr
);
3661 assert( szHdr
<=(u32
)nKey
);
3663 idx
+= getVarint32(aKey
+idx
, notUsed
);
3666 assert( nField
<= pKeyInfo
->nField
+pKeyInfo
->nXField
);
3669 # define vdbeAssertFieldCountWithinLimits(A,B,C)
3673 ** Both *pMem1 and *pMem2 contain string values. Compare the two values
3674 ** using the collation sequence pColl. As usual, return a negative , zero
3675 ** or positive value if *pMem1 is less than, equal to or greater than
3676 ** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);".
3678 static int vdbeCompareMemString(
3681 const CollSeq
*pColl
,
3682 u8
*prcErr
/* If an OOM occurs, set to SQLITE_NOMEM */
3684 if( pMem1
->enc
==pColl
->enc
){
3685 /* The strings are already in the correct encoding. Call the
3686 ** comparison function directly */
3687 return pColl
->xCmp(pColl
->pUser
,pMem1
->n
,pMem1
->z
,pMem2
->n
,pMem2
->z
);
3690 const void *v1
, *v2
;
3694 sqlite3VdbeMemInit(&c1
, pMem1
->db
, MEM_Null
);
3695 sqlite3VdbeMemInit(&c2
, pMem1
->db
, MEM_Null
);
3696 sqlite3VdbeMemShallowCopy(&c1
, pMem1
, MEM_Ephem
);
3697 sqlite3VdbeMemShallowCopy(&c2
, pMem2
, MEM_Ephem
);
3698 v1
= sqlite3ValueText((sqlite3_value
*)&c1
, pColl
->enc
);
3699 n1
= v1
==0 ? 0 : c1
.n
;
3700 v2
= sqlite3ValueText((sqlite3_value
*)&c2
, pColl
->enc
);
3701 n2
= v2
==0 ? 0 : c2
.n
;
3702 rc
= pColl
->xCmp(pColl
->pUser
, n1
, v1
, n2
, v2
);
3703 if( (v1
==0 || v2
==0) && prcErr
) *prcErr
= SQLITE_NOMEM_BKPT
;
3704 sqlite3VdbeMemRelease(&c1
);
3705 sqlite3VdbeMemRelease(&c2
);
3711 ** Compare two blobs. Return negative, zero, or positive if the first
3712 ** is less than, equal to, or greater than the second, respectively.
3713 ** If one blob is a prefix of the other, then the shorter is the lessor.
3715 static SQLITE_NOINLINE
int sqlite3BlobCompare(const Mem
*pB1
, const Mem
*pB2
){
3716 int c
= memcmp(pB1
->z
, pB2
->z
, pB1
->n
>pB2
->n
? pB2
->n
: pB1
->n
);
3718 return pB1
->n
- pB2
->n
;
3722 ** Do a comparison between a 64-bit signed integer and a 64-bit floating-point
3723 ** number. Return negative, zero, or positive if the first (i64) is less than,
3724 ** equal to, or greater than the second (double).
3726 static int sqlite3IntFloatCompare(i64 i
, double r
){
3727 if( sizeof(LONGDOUBLE_TYPE
)>8 ){
3728 LONGDOUBLE_TYPE x
= (LONGDOUBLE_TYPE
)i
;
3729 if( x
<r
) return -1;
3730 if( x
>r
) return +1;
3735 if( r
<-9223372036854775808.0 ) return +1;
3736 if( r
>9223372036854775807.0 ) return -1;
3738 if( i
<y
) return -1;
3740 if( y
==SMALLEST_INT64
&& r
>0.0 ) return -1;
3744 if( s
<r
) return -1;
3745 if( s
>r
) return +1;
3751 ** Compare the values contained by the two memory cells, returning
3752 ** negative, zero or positive if pMem1 is less than, equal to, or greater
3753 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
3754 ** and reals) sorted numerically, followed by text ordered by the collating
3755 ** sequence pColl and finally blob's ordered by memcmp().
3757 ** Two NULL values are considered equal by this function.
3759 int sqlite3MemCompare(const Mem
*pMem1
, const Mem
*pMem2
, const CollSeq
*pColl
){
3765 combined_flags
= f1
|f2
;
3766 assert( (combined_flags
& MEM_RowSet
)==0 );
3768 /* If one value is NULL, it is less than the other. If both values
3769 ** are NULL, return 0.
3771 if( combined_flags
&MEM_Null
){
3772 return (f2
&MEM_Null
) - (f1
&MEM_Null
);
3775 /* At least one of the two values is a number
3777 if( combined_flags
&(MEM_Int
|MEM_Real
) ){
3778 if( (f1
& f2
& MEM_Int
)!=0 ){
3779 if( pMem1
->u
.i
< pMem2
->u
.i
) return -1;
3780 if( pMem1
->u
.i
> pMem2
->u
.i
) return +1;
3783 if( (f1
& f2
& MEM_Real
)!=0 ){
3784 if( pMem1
->u
.r
< pMem2
->u
.r
) return -1;
3785 if( pMem1
->u
.r
> pMem2
->u
.r
) return +1;
3788 if( (f1
&MEM_Int
)!=0 ){
3789 if( (f2
&MEM_Real
)!=0 ){
3790 return sqlite3IntFloatCompare(pMem1
->u
.i
, pMem2
->u
.r
);
3795 if( (f1
&MEM_Real
)!=0 ){
3796 if( (f2
&MEM_Int
)!=0 ){
3797 return -sqlite3IntFloatCompare(pMem2
->u
.i
, pMem1
->u
.r
);
3805 /* If one value is a string and the other is a blob, the string is less.
3806 ** If both are strings, compare using the collating functions.
3808 if( combined_flags
&MEM_Str
){
3809 if( (f1
& MEM_Str
)==0 ){
3812 if( (f2
& MEM_Str
)==0 ){
3816 assert( pMem1
->enc
==pMem2
->enc
|| pMem1
->db
->mallocFailed
);
3817 assert( pMem1
->enc
==SQLITE_UTF8
||
3818 pMem1
->enc
==SQLITE_UTF16LE
|| pMem1
->enc
==SQLITE_UTF16BE
);
3820 /* The collation sequence must be defined at this point, even if
3821 ** the user deletes the collation sequence after the vdbe program is
3822 ** compiled (this was not always the case).
3824 assert( !pColl
|| pColl
->xCmp
);
3827 return vdbeCompareMemString(pMem1
, pMem2
, pColl
, 0);
3829 /* If a NULL pointer was passed as the collate function, fall through
3830 ** to the blob case and use memcmp(). */
3833 /* Both values must be blobs. Compare using memcmp(). */
3834 return sqlite3BlobCompare(pMem1
, pMem2
);
3839 ** The first argument passed to this function is a serial-type that
3840 ** corresponds to an integer - all values between 1 and 9 inclusive
3841 ** except 7. The second points to a buffer containing an integer value
3842 ** serialized according to serial_type. This function deserializes
3843 ** and returns the value.
3845 static i64
vdbeRecordDecodeInt(u32 serial_type
, const u8
*aKey
){
3847 assert( CORRUPT_DB
|| (serial_type
>=1 && serial_type
<=9 && serial_type
!=7) );
3848 switch( serial_type
){
3851 testcase( aKey
[0]&0x80 );
3852 return ONE_BYTE_INT(aKey
);
3854 testcase( aKey
[0]&0x80 );
3855 return TWO_BYTE_INT(aKey
);
3857 testcase( aKey
[0]&0x80 );
3858 return THREE_BYTE_INT(aKey
);
3860 testcase( aKey
[0]&0x80 );
3861 y
= FOUR_BYTE_UINT(aKey
);
3862 return (i64
)*(int*)&y
;
3865 testcase( aKey
[0]&0x80 );
3866 return FOUR_BYTE_UINT(aKey
+2) + (((i64
)1)<<32)*TWO_BYTE_INT(aKey
);
3869 u64 x
= FOUR_BYTE_UINT(aKey
);
3870 testcase( aKey
[0]&0x80 );
3871 x
= (x
<<32) | FOUR_BYTE_UINT(aKey
+4);
3872 return (i64
)*(i64
*)&x
;
3876 return (serial_type
- 8);
3880 ** This function compares the two table rows or index records
3881 ** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero
3882 ** or positive integer if key1 is less than, equal to or
3883 ** greater than key2. The {nKey1, pKey1} key must be a blob
3884 ** created by the OP_MakeRecord opcode of the VDBE. The pPKey2
3885 ** key must be a parsed key such as obtained from
3886 ** sqlite3VdbeParseRecord.
3888 ** If argument bSkip is non-zero, it is assumed that the caller has already
3889 ** determined that the first fields of the keys are equal.
3891 ** Key1 and Key2 do not have to contain the same number of fields. If all
3892 ** fields that appear in both keys are equal, then pPKey2->default_rc is
3895 ** If database corruption is discovered, set pPKey2->errCode to
3896 ** SQLITE_CORRUPT and return 0. If an OOM error is encountered,
3897 ** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the
3898 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
3900 int sqlite3VdbeRecordCompareWithSkip(
3901 int nKey1
, const void *pKey1
, /* Left key */
3902 UnpackedRecord
*pPKey2
, /* Right key */
3903 int bSkip
/* If true, skip the first field */
3905 u32 d1
; /* Offset into aKey[] of next data element */
3906 int i
; /* Index of next field to compare */
3907 u32 szHdr1
; /* Size of record header in bytes */
3908 u32 idx1
; /* Offset of first type in header */
3909 int rc
= 0; /* Return value */
3910 Mem
*pRhs
= pPKey2
->aMem
; /* Next field of pPKey2 to compare */
3911 KeyInfo
*pKeyInfo
= pPKey2
->pKeyInfo
;
3912 const unsigned char *aKey1
= (const unsigned char *)pKey1
;
3915 /* If bSkip is true, then the caller has already determined that the first
3916 ** two elements in the keys are equal. Fix the various stack variables so
3917 ** that this routine begins comparing at the second field. */
3920 idx1
= 1 + getVarint32(&aKey1
[1], s1
);
3922 d1
= szHdr1
+ sqlite3VdbeSerialTypeLen(s1
);
3926 idx1
= getVarint32(aKey1
, szHdr1
);
3928 if( d1
>(unsigned)nKey1
){
3929 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
3930 return 0; /* Corruption */
3935 VVA_ONLY( mem1
.szMalloc
= 0; ) /* Only needed by assert() statements */
3936 assert( pPKey2
->pKeyInfo
->nField
+pPKey2
->pKeyInfo
->nXField
>=pPKey2
->nField
3938 assert( pPKey2
->pKeyInfo
->aSortOrder
!=0 );
3939 assert( pPKey2
->pKeyInfo
->nField
>0 );
3940 assert( idx1
<=szHdr1
|| CORRUPT_DB
);
3944 /* RHS is an integer */
3945 if( pRhs
->flags
& MEM_Int
){
3946 serial_type
= aKey1
[idx1
];
3947 testcase( serial_type
==12 );
3948 if( serial_type
>=10 ){
3950 }else if( serial_type
==0 ){
3952 }else if( serial_type
==7 ){
3953 sqlite3VdbeSerialGet(&aKey1
[d1
], serial_type
, &mem1
);
3954 rc
= -sqlite3IntFloatCompare(pRhs
->u
.i
, mem1
.u
.r
);
3956 i64 lhs
= vdbeRecordDecodeInt(serial_type
, &aKey1
[d1
]);
3957 i64 rhs
= pRhs
->u
.i
;
3960 }else if( lhs
>rhs
){
3967 else if( pRhs
->flags
& MEM_Real
){
3968 serial_type
= aKey1
[idx1
];
3969 if( serial_type
>=10 ){
3970 /* Serial types 12 or greater are strings and blobs (greater than
3971 ** numbers). Types 10 and 11 are currently "reserved for future
3972 ** use", so it doesn't really matter what the results of comparing
3973 ** them to numberic values are. */
3975 }else if( serial_type
==0 ){
3978 sqlite3VdbeSerialGet(&aKey1
[d1
], serial_type
, &mem1
);
3979 if( serial_type
==7 ){
3980 if( mem1
.u
.r
<pRhs
->u
.r
){
3982 }else if( mem1
.u
.r
>pRhs
->u
.r
){
3986 rc
= sqlite3IntFloatCompare(mem1
.u
.i
, pRhs
->u
.r
);
3991 /* RHS is a string */
3992 else if( pRhs
->flags
& MEM_Str
){
3993 getVarint32(&aKey1
[idx1
], serial_type
);
3994 testcase( serial_type
==12 );
3995 if( serial_type
<12 ){
3997 }else if( !(serial_type
& 0x01) ){
4000 mem1
.n
= (serial_type
- 12) / 2;
4001 testcase( (d1
+mem1
.n
)==(unsigned)nKey1
);
4002 testcase( (d1
+mem1
.n
+1)==(unsigned)nKey1
);
4003 if( (d1
+mem1
.n
) > (unsigned)nKey1
){
4004 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
4005 return 0; /* Corruption */
4006 }else if( pKeyInfo
->aColl
[i
] ){
4007 mem1
.enc
= pKeyInfo
->enc
;
4008 mem1
.db
= pKeyInfo
->db
;
4009 mem1
.flags
= MEM_Str
;
4010 mem1
.z
= (char*)&aKey1
[d1
];
4011 rc
= vdbeCompareMemString(
4012 &mem1
, pRhs
, pKeyInfo
->aColl
[i
], &pPKey2
->errCode
4015 int nCmp
= MIN(mem1
.n
, pRhs
->n
);
4016 rc
= memcmp(&aKey1
[d1
], pRhs
->z
, nCmp
);
4017 if( rc
==0 ) rc
= mem1
.n
- pRhs
->n
;
4023 else if( pRhs
->flags
& MEM_Blob
){
4024 getVarint32(&aKey1
[idx1
], serial_type
);
4025 testcase( serial_type
==12 );
4026 if( serial_type
<12 || (serial_type
& 0x01) ){
4029 int nStr
= (serial_type
- 12) / 2;
4030 testcase( (d1
+nStr
)==(unsigned)nKey1
);
4031 testcase( (d1
+nStr
+1)==(unsigned)nKey1
);
4032 if( (d1
+nStr
) > (unsigned)nKey1
){
4033 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
4034 return 0; /* Corruption */
4036 int nCmp
= MIN(nStr
, pRhs
->n
);
4037 rc
= memcmp(&aKey1
[d1
], pRhs
->z
, nCmp
);
4038 if( rc
==0 ) rc
= nStr
- pRhs
->n
;
4045 serial_type
= aKey1
[idx1
];
4046 rc
= (serial_type
!=0);
4050 if( pKeyInfo
->aSortOrder
[i
] ){
4053 assert( vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, rc
) );
4054 assert( mem1
.szMalloc
==0 ); /* See comment below */
4060 d1
+= sqlite3VdbeSerialTypeLen(serial_type
);
4061 idx1
+= sqlite3VarintLen(serial_type
);
4062 }while( idx1
<(unsigned)szHdr1
&& i
<pPKey2
->nField
&& d1
<=(unsigned)nKey1
);
4064 /* No memory allocation is ever used on mem1. Prove this using
4065 ** the following assert(). If the assert() fails, it indicates a
4066 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */
4067 assert( mem1
.szMalloc
==0 );
4069 /* rc==0 here means that one or both of the keys ran out of fields and
4070 ** all the fields up to that point were equal. Return the default_rc
4073 || vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, pPKey2
->default_rc
)
4074 || pKeyInfo
->db
->mallocFailed
4077 return pPKey2
->default_rc
;
4079 int sqlite3VdbeRecordCompare(
4080 int nKey1
, const void *pKey1
, /* Left key */
4081 UnpackedRecord
*pPKey2
/* Right key */
4083 return sqlite3VdbeRecordCompareWithSkip(nKey1
, pKey1
, pPKey2
, 0);
4088 ** This function is an optimized version of sqlite3VdbeRecordCompare()
4089 ** that (a) the first field of pPKey2 is an integer, and (b) the
4090 ** size-of-header varint at the start of (pKey1/nKey1) fits in a single
4091 ** byte (i.e. is less than 128).
4093 ** To avoid concerns about buffer overreads, this routine is only used
4094 ** on schemas where the maximum valid header size is 63 bytes or less.
4096 static int vdbeRecordCompareInt(
4097 int nKey1
, const void *pKey1
, /* Left key */
4098 UnpackedRecord
*pPKey2
/* Right key */
4100 const u8
*aKey
= &((const u8
*)pKey1
)[*(const u8
*)pKey1
& 0x3F];
4101 int serial_type
= ((const u8
*)pKey1
)[1];
4105 i64 v
= pPKey2
->aMem
[0].u
.i
;
4108 vdbeAssertFieldCountWithinLimits(nKey1
, pKey1
, pPKey2
->pKeyInfo
);
4109 assert( (*(u8
*)pKey1
)<=0x3F || CORRUPT_DB
);
4110 switch( serial_type
){
4111 case 1: { /* 1-byte signed integer */
4112 lhs
= ONE_BYTE_INT(aKey
);
4116 case 2: { /* 2-byte signed integer */
4117 lhs
= TWO_BYTE_INT(aKey
);
4121 case 3: { /* 3-byte signed integer */
4122 lhs
= THREE_BYTE_INT(aKey
);
4126 case 4: { /* 4-byte signed integer */
4127 y
= FOUR_BYTE_UINT(aKey
);
4128 lhs
= (i64
)*(int*)&y
;
4132 case 5: { /* 6-byte signed integer */
4133 lhs
= FOUR_BYTE_UINT(aKey
+2) + (((i64
)1)<<32)*TWO_BYTE_INT(aKey
);
4137 case 6: { /* 8-byte signed integer */
4138 x
= FOUR_BYTE_UINT(aKey
);
4139 x
= (x
<<32) | FOUR_BYTE_UINT(aKey
+4);
4151 /* This case could be removed without changing the results of running
4152 ** this code. Including it causes gcc to generate a faster switch
4153 ** statement (since the range of switch targets now starts at zero and
4154 ** is contiguous) but does not cause any duplicate code to be generated
4155 ** (as gcc is clever enough to combine the two like cases). Other
4156 ** compilers might be similar. */
4158 return sqlite3VdbeRecordCompare(nKey1
, pKey1
, pPKey2
);
4161 return sqlite3VdbeRecordCompare(nKey1
, pKey1
, pPKey2
);
4168 }else if( pPKey2
->nField
>1 ){
4169 /* The first fields of the two keys are equal. Compare the trailing
4171 res
= sqlite3VdbeRecordCompareWithSkip(nKey1
, pKey1
, pPKey2
, 1);
4173 /* The first fields of the two keys are equal and there are no trailing
4174 ** fields. Return pPKey2->default_rc in this case. */
4175 res
= pPKey2
->default_rc
;
4179 assert( vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, res
) );
4184 ** This function is an optimized version of sqlite3VdbeRecordCompare()
4185 ** that (a) the first field of pPKey2 is a string, that (b) the first field
4186 ** uses the collation sequence BINARY and (c) that the size-of-header varint
4187 ** at the start of (pKey1/nKey1) fits in a single byte.
4189 static int vdbeRecordCompareString(
4190 int nKey1
, const void *pKey1
, /* Left key */
4191 UnpackedRecord
*pPKey2
/* Right key */
4193 const u8
*aKey1
= (const u8
*)pKey1
;
4197 assert( pPKey2
->aMem
[0].flags
& MEM_Str
);
4198 vdbeAssertFieldCountWithinLimits(nKey1
, pKey1
, pPKey2
->pKeyInfo
);
4199 getVarint32(&aKey1
[1], serial_type
);
4200 if( serial_type
<12 ){
4201 res
= pPKey2
->r1
; /* (pKey1/nKey1) is a number or a null */
4202 }else if( !(serial_type
& 0x01) ){
4203 res
= pPKey2
->r2
; /* (pKey1/nKey1) is a blob */
4207 int szHdr
= aKey1
[0];
4209 nStr
= (serial_type
-12) / 2;
4210 if( (szHdr
+ nStr
) > nKey1
){
4211 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
4212 return 0; /* Corruption */
4214 nCmp
= MIN( pPKey2
->aMem
[0].n
, nStr
);
4215 res
= memcmp(&aKey1
[szHdr
], pPKey2
->aMem
[0].z
, nCmp
);
4218 res
= nStr
- pPKey2
->aMem
[0].n
;
4220 if( pPKey2
->nField
>1 ){
4221 res
= sqlite3VdbeRecordCompareWithSkip(nKey1
, pKey1
, pPKey2
, 1);
4223 res
= pPKey2
->default_rc
;
4238 assert( vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, res
)
4240 || pPKey2
->pKeyInfo
->db
->mallocFailed
4246 ** Return a pointer to an sqlite3VdbeRecordCompare() compatible function
4247 ** suitable for comparing serialized records to the unpacked record passed
4248 ** as the only argument.
4250 RecordCompare
sqlite3VdbeFindCompare(UnpackedRecord
*p
){
4251 /* varintRecordCompareInt() and varintRecordCompareString() both assume
4252 ** that the size-of-header varint that occurs at the start of each record
4253 ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt()
4254 ** also assumes that it is safe to overread a buffer by at least the
4255 ** maximum possible legal header size plus 8 bytes. Because there is
4256 ** guaranteed to be at least 74 (but not 136) bytes of padding following each
4257 ** buffer passed to varintRecordCompareInt() this makes it convenient to
4258 ** limit the size of the header to 64 bytes in cases where the first field
4261 ** The easiest way to enforce this limit is to consider only records with
4262 ** 13 fields or less. If the first field is an integer, the maximum legal
4263 ** header size is (12*5 + 1 + 1) bytes. */
4264 if( (p
->pKeyInfo
->nField
+ p
->pKeyInfo
->nXField
)<=13 ){
4265 int flags
= p
->aMem
[0].flags
;
4266 if( p
->pKeyInfo
->aSortOrder
[0] ){
4273 if( (flags
& MEM_Int
) ){
4274 return vdbeRecordCompareInt
;
4276 testcase( flags
& MEM_Real
);
4277 testcase( flags
& MEM_Null
);
4278 testcase( flags
& MEM_Blob
);
4279 if( (flags
& (MEM_Real
|MEM_Null
|MEM_Blob
))==0 && p
->pKeyInfo
->aColl
[0]==0 ){
4280 assert( flags
& MEM_Str
);
4281 return vdbeRecordCompareString
;
4285 return sqlite3VdbeRecordCompare
;
4289 ** pCur points at an index entry created using the OP_MakeRecord opcode.
4290 ** Read the rowid (the last field in the record) and store it in *rowid.
4291 ** Return SQLITE_OK if everything works, or an error code otherwise.
4293 ** pCur might be pointing to text obtained from a corrupt database file.
4294 ** So the content cannot be trusted. Do appropriate checks on the content.
4296 int sqlite3VdbeIdxRowid(sqlite3
*db
, BtCursor
*pCur
, i64
*rowid
){
4299 u32 szHdr
; /* Size of the header */
4300 u32 typeRowid
; /* Serial type of the rowid */
4301 u32 lenRowid
; /* Size of the rowid */
4304 /* Get the size of the index entry. Only indices entries of less
4305 ** than 2GiB are support - anything large must be database corruption.
4306 ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so
4307 ** this code can safely assume that nCellKey is 32-bits
4309 assert( sqlite3BtreeCursorIsValid(pCur
) );
4310 nCellKey
= sqlite3BtreePayloadSize(pCur
);
4311 assert( (nCellKey
& SQLITE_MAX_U32
)==(u64
)nCellKey
);
4313 /* Read in the complete content of the index entry */
4314 sqlite3VdbeMemInit(&m
, db
, 0);
4315 rc
= sqlite3VdbeMemFromBtree(pCur
, 0, (u32
)nCellKey
, 1, &m
);
4320 /* The index entry must begin with a header size */
4321 (void)getVarint32((u8
*)m
.z
, szHdr
);
4322 testcase( szHdr
==3 );
4323 testcase( szHdr
==m
.n
);
4324 if( unlikely(szHdr
<3 || (int)szHdr
>m
.n
) ){
4325 goto idx_rowid_corruption
;
4328 /* The last field of the index should be an integer - the ROWID.
4329 ** Verify that the last entry really is an integer. */
4330 (void)getVarint32((u8
*)&m
.z
[szHdr
-1], typeRowid
);
4331 testcase( typeRowid
==1 );
4332 testcase( typeRowid
==2 );
4333 testcase( typeRowid
==3 );
4334 testcase( typeRowid
==4 );
4335 testcase( typeRowid
==5 );
4336 testcase( typeRowid
==6 );
4337 testcase( typeRowid
==8 );
4338 testcase( typeRowid
==9 );
4339 if( unlikely(typeRowid
<1 || typeRowid
>9 || typeRowid
==7) ){
4340 goto idx_rowid_corruption
;
4342 lenRowid
= sqlite3SmallTypeSizes
[typeRowid
];
4343 testcase( (u32
)m
.n
==szHdr
+lenRowid
);
4344 if( unlikely((u32
)m
.n
<szHdr
+lenRowid
) ){
4345 goto idx_rowid_corruption
;
4348 /* Fetch the integer off the end of the index record */
4349 sqlite3VdbeSerialGet((u8
*)&m
.z
[m
.n
-lenRowid
], typeRowid
, &v
);
4351 sqlite3VdbeMemRelease(&m
);
4354 /* Jump here if database corruption is detected after m has been
4355 ** allocated. Free the m object and return SQLITE_CORRUPT. */
4356 idx_rowid_corruption
:
4357 testcase( m
.szMalloc
!=0 );
4358 sqlite3VdbeMemRelease(&m
);
4359 return SQLITE_CORRUPT_BKPT
;
4363 ** Compare the key of the index entry that cursor pC is pointing to against
4364 ** the key string in pUnpacked. Write into *pRes a number
4365 ** that is negative, zero, or positive if pC is less than, equal to,
4366 ** or greater than pUnpacked. Return SQLITE_OK on success.
4368 ** pUnpacked is either created without a rowid or is truncated so that it
4369 ** omits the rowid at the end. The rowid at the end of the index entry
4370 ** is ignored as well. Hence, this routine only compares the prefixes
4371 ** of the keys prior to the final rowid, not the entire key.
4373 int sqlite3VdbeIdxKeyCompare(
4374 sqlite3
*db
, /* Database connection */
4375 VdbeCursor
*pC
, /* The cursor to compare against */
4376 UnpackedRecord
*pUnpacked
, /* Unpacked version of key */
4377 int *res
/* Write the comparison result here */
4384 assert( pC
->eCurType
==CURTYPE_BTREE
);
4385 pCur
= pC
->uc
.pCursor
;
4386 assert( sqlite3BtreeCursorIsValid(pCur
) );
4387 nCellKey
= sqlite3BtreePayloadSize(pCur
);
4388 /* nCellKey will always be between 0 and 0xffffffff because of the way
4389 ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
4390 if( nCellKey
<=0 || nCellKey
>0x7fffffff ){
4392 return SQLITE_CORRUPT_BKPT
;
4394 sqlite3VdbeMemInit(&m
, db
, 0);
4395 rc
= sqlite3VdbeMemFromBtree(pCur
, 0, (u32
)nCellKey
, 1, &m
);
4399 *res
= sqlite3VdbeRecordCompare(m
.n
, m
.z
, pUnpacked
);
4400 sqlite3VdbeMemRelease(&m
);
4405 ** This routine sets the value to be returned by subsequent calls to
4406 ** sqlite3_changes() on the database handle 'db'.
4408 void sqlite3VdbeSetChanges(sqlite3
*db
, int nChange
){
4409 assert( sqlite3_mutex_held(db
->mutex
) );
4410 db
->nChange
= nChange
;
4411 db
->nTotalChange
+= nChange
;
4415 ** Set a flag in the vdbe to update the change counter when it is finalised
4418 void sqlite3VdbeCountChanges(Vdbe
*v
){
4423 ** Mark every prepared statement associated with a database connection
4426 ** An expired statement means that recompilation of the statement is
4427 ** recommend. Statements expire when things happen that make their
4428 ** programs obsolete. Removing user-defined functions or collating
4429 ** sequences, or changing an authorization function are the types of
4430 ** things that make prepared statements obsolete.
4432 void sqlite3ExpirePreparedStatements(sqlite3
*db
){
4434 for(p
= db
->pVdbe
; p
; p
=p
->pNext
){
4440 ** Return the database associated with the Vdbe.
4442 sqlite3
*sqlite3VdbeDb(Vdbe
*v
){
4447 ** Return a pointer to an sqlite3_value structure containing the value bound
4448 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
4449 ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_*
4450 ** constants) to the value before returning it.
4452 ** The returned value must be freed by the caller using sqlite3ValueFree().
4454 sqlite3_value
*sqlite3VdbeGetBoundValue(Vdbe
*v
, int iVar
, u8 aff
){
4457 Mem
*pMem
= &v
->aVar
[iVar
-1];
4458 if( 0==(pMem
->flags
& MEM_Null
) ){
4459 sqlite3_value
*pRet
= sqlite3ValueNew(v
->db
);
4461 sqlite3VdbeMemCopy((Mem
*)pRet
, pMem
);
4462 sqlite3ValueApplyAffinity(pRet
, aff
, SQLITE_UTF8
);
4471 ** Configure SQL variable iVar so that binding a new value to it signals
4472 ** to sqlite3_reoptimize() that re-preparing the statement may result
4473 ** in a better query plan.
4475 void sqlite3VdbeSetVarmask(Vdbe
*v
, int iVar
){
4478 v
->expmask
= 0xffffffff;
4480 v
->expmask
|= ((u32
)1 << (iVar
-1));
4484 #ifndef SQLITE_OMIT_VIRTUALTABLE
4486 ** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored
4487 ** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored
4488 ** in memory obtained from sqlite3DbMalloc).
4490 void sqlite3VtabImportErrmsg(Vdbe
*p
, sqlite3_vtab
*pVtab
){
4491 if( pVtab
->zErrMsg
){
4492 sqlite3
*db
= p
->db
;
4493 sqlite3DbFree(db
, p
->zErrMsg
);
4494 p
->zErrMsg
= sqlite3DbStrDup(db
, pVtab
->zErrMsg
);
4495 sqlite3_free(pVtab
->zErrMsg
);
4499 #endif /* SQLITE_OMIT_VIRTUALTABLE */
4501 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
4504 ** If the second argument is not NULL, release any allocations associated
4505 ** with the memory cells in the p->aMem[] array. Also free the UnpackedRecord
4506 ** structure itself, using sqlite3DbFree().
4508 ** This function is used to free UnpackedRecord structures allocated by
4509 ** the vdbeUnpackRecord() function found in vdbeapi.c.
4511 static void vdbeFreeUnpacked(sqlite3
*db
, UnpackedRecord
*p
){
4514 for(i
=0; i
<p
->nField
; i
++){
4515 Mem
*pMem
= &p
->aMem
[i
];
4516 if( pMem
->zMalloc
) sqlite3VdbeMemRelease(pMem
);
4518 sqlite3DbFree(db
, p
);
4521 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
4523 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
4525 ** Invoke the pre-update hook. If this is an UPDATE or DELETE pre-update call,
4526 ** then cursor passed as the second argument should point to the row about
4527 ** to be update or deleted. If the application calls sqlite3_preupdate_old(),
4528 ** the required value will be read from the row the cursor points to.
4530 void sqlite3VdbePreUpdateHook(
4531 Vdbe
*v
, /* Vdbe pre-update hook is invoked by */
4532 VdbeCursor
*pCsr
, /* Cursor to grab old.* values from */
4533 int op
, /* SQLITE_INSERT, UPDATE or DELETE */
4534 const char *zDb
, /* Database name */
4535 Table
*pTab
, /* Modified table */
4536 i64 iKey1
, /* Initial key value */
4537 int iReg
/* Register for new.* record */
4539 sqlite3
*db
= v
->db
;
4541 PreUpdate preupdate
;
4542 const char *zTbl
= pTab
->zName
;
4543 static const u8 fakeSortOrder
= 0;
4545 assert( db
->pPreUpdate
==0 );
4546 memset(&preupdate
, 0, sizeof(PreUpdate
));
4547 if( op
==SQLITE_UPDATE
){
4548 iKey2
= v
->aMem
[iReg
].u
.i
;
4553 assert( pCsr
->nField
==pTab
->nCol
4554 || (pCsr
->nField
==pTab
->nCol
+1 && op
==SQLITE_DELETE
&& iReg
==-1)
4558 preupdate
.pCsr
= pCsr
;
4560 preupdate
.iNewReg
= iReg
;
4561 preupdate
.keyinfo
.db
= db
;
4562 preupdate
.keyinfo
.enc
= ENC(db
);
4563 preupdate
.keyinfo
.nField
= pTab
->nCol
;
4564 preupdate
.keyinfo
.aSortOrder
= (u8
*)&fakeSortOrder
;
4565 preupdate
.iKey1
= iKey1
;
4566 preupdate
.iKey2
= iKey2
;
4567 preupdate
.iPKey
= pTab
->iPKey
;
4569 db
->pPreUpdate
= &preupdate
;
4570 db
->xPreUpdateCallback(db
->pPreUpdateArg
, db
, op
, zDb
, zTbl
, iKey1
, iKey2
);
4572 sqlite3DbFree(db
, preupdate
.aRecord
);
4573 vdbeFreeUnpacked(db
, preupdate
.pUnpacked
);
4574 vdbeFreeUnpacked(db
, preupdate
.pNewUnpacked
);
4575 if( preupdate
.aNew
){
4577 for(i
=0; i
<pCsr
->nField
; i
++){
4578 sqlite3VdbeMemRelease(&preupdate
.aNew
[i
]);
4580 sqlite3DbFree(db
, preupdate
.aNew
);
4583 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */