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 );
42 ** Remember the SQL string for a prepared statement.
44 void sqlite3VdbeSetSql(Vdbe
*p
, const char *z
, int n
, int isPrepareV2
){
45 assert( isPrepareV2
==1 || isPrepareV2
==0 );
47 #if defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_ENABLE_SQLLOG)
48 if( !isPrepareV2
) return;
51 p
->zSql
= sqlite3DbStrNDup(p
->db
, z
, n
);
52 p
->isPrepareV2
= (u8
)isPrepareV2
;
56 ** Return the SQL associated with a prepared statement
58 const char *sqlite3_sql(sqlite3_stmt
*pStmt
){
59 Vdbe
*p
= (Vdbe
*)pStmt
;
60 return (p
&& p
->isPrepareV2
) ? p
->zSql
: 0;
64 ** Swap all content between two VDBE structures.
66 void sqlite3VdbeSwap(Vdbe
*pA
, Vdbe
*pB
){
73 pA
->pNext
= pB
->pNext
;
76 pA
->pPrev
= pB
->pPrev
;
81 pB
->isPrepareV2
= pA
->isPrepareV2
;
85 ** Resize the Vdbe.aOp array so that it is at least nOp elements larger
86 ** than its current size. nOp is guaranteed to be less than or equal
87 ** to 1024/sizeof(Op).
89 ** If an out-of-memory error occurs while resizing the array, return
90 ** SQLITE_NOMEM. In this case Vdbe.aOp and Parse.nOpAlloc remain
91 ** unchanged (this is so that any opcodes already allocated can be
92 ** correctly deallocated along with the rest of the Vdbe).
94 static int growOpArray(Vdbe
*v
, int nOp
){
98 /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
99 ** more frequent reallocs and hence provide more opportunities for
100 ** simulated OOM faults. SQLITE_TEST_REALLOC_STRESS is generally used
101 ** during testing only. With SQLITE_TEST_REALLOC_STRESS grow the op array
102 ** by the minimum* amount required until the size reaches 512. Normal
103 ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
104 ** size of the op array or add 1KB of space, whichever is smaller. */
105 #ifdef SQLITE_TEST_REALLOC_STRESS
106 int nNew
= (p
->nOpAlloc
>=512 ? p
->nOpAlloc
*2 : p
->nOpAlloc
+nOp
);
108 int nNew
= (p
->nOpAlloc
? p
->nOpAlloc
*2 : (int)(1024/sizeof(Op
)));
109 UNUSED_PARAMETER(nOp
);
112 assert( nOp
<=(1024/sizeof(Op
)) );
113 assert( nNew
>=(p
->nOpAlloc
+nOp
) );
114 pNew
= sqlite3DbRealloc(p
->db
, v
->aOp
, nNew
*sizeof(Op
));
116 p
->nOpAlloc
= sqlite3DbMallocSize(p
->db
, pNew
)/sizeof(Op
);
119 return (pNew
? SQLITE_OK
: SQLITE_NOMEM
);
123 /* This routine is just a convenient place to set a breakpoint that will
124 ** fire after each opcode is inserted and displayed using
125 ** "PRAGMA vdbe_addoptrace=on".
127 static void test_addop_breakpoint(void){
134 ** Add a new instruction to the list of instructions current in the
135 ** VDBE. Return the address of the new instruction.
139 ** p Pointer to the VDBE
141 ** op The opcode for this instruction
143 ** p1, p2, p3 Operands
145 ** Use the sqlite3VdbeResolveLabel() function to fix an address and
146 ** the sqlite3VdbeChangeP4() function to change the value of the P4
149 int sqlite3VdbeAddOp3(Vdbe
*p
, int op
, int p1
, int p2
, int p3
){
154 assert( p
->magic
==VDBE_MAGIC_INIT
);
155 assert( op
>0 && op
<0xff );
156 if( p
->pParse
->nOpAlloc
<=i
){
157 if( growOpArray(p
, 1) ){
163 pOp
->opcode
= (u8
)op
;
169 pOp
->p4type
= P4_NOTUSED
;
170 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
174 if( p
->db
->flags
& SQLITE_VdbeAddopTrace
){
176 Parse
*pParse
= p
->pParse
;
177 for(jj
=kk
=0; jj
<SQLITE_N_COLCACHE
; jj
++){
178 struct yColCache
*x
= pParse
->aColCache
+ jj
;
179 if( x
->iLevel
>pParse
->iCacheLevel
|| x
->iReg
==0 ) continue;
180 printf(" r[%d]={%d:%d}", x
->iReg
, x
->iTable
, x
->iColumn
);
183 if( kk
) printf("\n");
184 sqlite3VdbePrintOp(0, i
, &p
->aOp
[i
]);
185 test_addop_breakpoint();
192 #ifdef SQLITE_VDBE_COVERAGE
197 int sqlite3VdbeAddOp0(Vdbe
*p
, int op
){
198 return sqlite3VdbeAddOp3(p
, op
, 0, 0, 0);
200 int sqlite3VdbeAddOp1(Vdbe
*p
, int op
, int p1
){
201 return sqlite3VdbeAddOp3(p
, op
, p1
, 0, 0);
203 int sqlite3VdbeAddOp2(Vdbe
*p
, int op
, int p1
, int p2
){
204 return sqlite3VdbeAddOp3(p
, op
, p1
, p2
, 0);
209 ** Add an opcode that includes the p4 value as a pointer.
211 int sqlite3VdbeAddOp4(
212 Vdbe
*p
, /* Add the opcode to this VM */
213 int op
, /* The new opcode */
214 int p1
, /* The P1 operand */
215 int p2
, /* The P2 operand */
216 int p3
, /* The P3 operand */
217 const char *zP4
, /* The P4 operand */
218 int p4type
/* P4 operand type */
220 int addr
= sqlite3VdbeAddOp3(p
, op
, p1
, p2
, p3
);
221 sqlite3VdbeChangeP4(p
, addr
, zP4
, p4type
);
226 ** Add an OP_ParseSchema opcode. This routine is broken out from
227 ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
228 ** as having been used.
230 ** The zWhere string must have been obtained from sqlite3_malloc().
231 ** This routine will take ownership of the allocated memory.
233 void sqlite3VdbeAddParseSchemaOp(Vdbe
*p
, int iDb
, char *zWhere
){
235 int addr
= sqlite3VdbeAddOp3(p
, OP_ParseSchema
, iDb
, 0, 0);
236 sqlite3VdbeChangeP4(p
, addr
, zWhere
, P4_DYNAMIC
);
237 for(j
=0; j
<p
->db
->nDb
; j
++) sqlite3VdbeUsesBtree(p
, j
);
241 ** Add an opcode that includes the p4 value as an integer.
243 int sqlite3VdbeAddOp4Int(
244 Vdbe
*p
, /* Add the opcode to this VM */
245 int op
, /* The new opcode */
246 int p1
, /* The P1 operand */
247 int p2
, /* The P2 operand */
248 int p3
, /* The P3 operand */
249 int p4
/* The P4 operand as an integer */
251 int addr
= sqlite3VdbeAddOp3(p
, op
, p1
, p2
, p3
);
252 sqlite3VdbeChangeP4(p
, addr
, SQLITE_INT_TO_PTR(p4
), P4_INT32
);
257 ** Create a new symbolic label for an instruction that has yet to be
258 ** coded. The symbolic label is really just a negative number. The
259 ** label can be used as the P2 value of an operation. Later, when
260 ** the label is resolved to a specific address, the VDBE will scan
261 ** through its operation list and change all values of P2 which match
262 ** the label into the resolved address.
264 ** The VDBE knows that a P2 value is a label because labels are
265 ** always negative and P2 values are suppose to be non-negative.
266 ** Hence, a negative P2 value is a label that has yet to be resolved.
268 ** Zero is returned if a malloc() fails.
270 int sqlite3VdbeMakeLabel(Vdbe
*v
){
271 Parse
*p
= v
->pParse
;
273 assert( v
->magic
==VDBE_MAGIC_INIT
);
274 if( (i
& (i
-1))==0 ){
275 p
->aLabel
= sqlite3DbReallocOrFree(p
->db
, p
->aLabel
,
276 (i
*2+1)*sizeof(p
->aLabel
[0]));
285 ** Resolve label "x" to be the address of the next instruction to
286 ** be inserted. The parameter "x" must have been obtained from
287 ** a prior call to sqlite3VdbeMakeLabel().
289 void sqlite3VdbeResolveLabel(Vdbe
*v
, int x
){
290 Parse
*p
= v
->pParse
;
292 assert( v
->magic
==VDBE_MAGIC_INIT
);
293 assert( j
<p
->nLabel
);
294 if( ALWAYS(j
>=0) && p
->aLabel
){
295 p
->aLabel
[j
] = v
->nOp
;
297 p
->iFixedOp
= v
->nOp
- 1;
301 ** Mark the VDBE as one that can only be run one time.
303 void sqlite3VdbeRunOnlyOnce(Vdbe
*p
){
307 #ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */
310 ** The following type and function are used to iterate through all opcodes
311 ** in a Vdbe main program and each of the sub-programs (triggers) it may
312 ** invoke directly or indirectly. It should be used as follows:
317 ** memset(&sIter, 0, sizeof(sIter));
318 ** sIter.v = v; // v is of type Vdbe*
319 ** while( (pOp = opIterNext(&sIter)) ){
320 ** // Do something with pOp
322 ** sqlite3DbFree(v->db, sIter.apSub);
325 typedef struct VdbeOpIter VdbeOpIter
;
327 Vdbe
*v
; /* Vdbe to iterate through the opcodes of */
328 SubProgram
**apSub
; /* Array of subprograms */
329 int nSub
; /* Number of entries in apSub */
330 int iAddr
; /* Address of next instruction to return */
331 int iSub
; /* 0 = main program, 1 = first sub-program etc. */
333 static Op
*opIterNext(VdbeOpIter
*p
){
339 if( p
->iSub
<=p
->nSub
){
345 aOp
= p
->apSub
[p
->iSub
-1]->aOp
;
346 nOp
= p
->apSub
[p
->iSub
-1]->nOp
;
348 assert( p
->iAddr
<nOp
);
350 pRet
= &aOp
[p
->iAddr
];
357 if( pRet
->p4type
==P4_SUBPROGRAM
){
358 int nByte
= (p
->nSub
+1)*sizeof(SubProgram
*);
360 for(j
=0; j
<p
->nSub
; j
++){
361 if( p
->apSub
[j
]==pRet
->p4
.pProgram
) break;
364 p
->apSub
= sqlite3DbReallocOrFree(v
->db
, p
->apSub
, nByte
);
368 p
->apSub
[p
->nSub
++] = pRet
->p4
.pProgram
;
378 ** Check if the program stored in the VM associated with pParse may
379 ** throw an ABORT exception (causing the statement, but not entire transaction
380 ** to be rolled back). This condition is true if the main program or any
381 ** sub-programs contains any of the following:
383 ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
384 ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
388 ** * OP_FkCounter with P2==0 (immediate foreign key constraint)
390 ** Then check that the value of Parse.mayAbort is true if an
391 ** ABORT may be thrown, or false otherwise. Return true if it does
392 ** match, or false otherwise. This function is intended to be used as
393 ** part of an assert statement in the compiler. Similar to:
395 ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
397 int sqlite3VdbeAssertMayAbort(Vdbe
*v
, int mayAbort
){
399 int hasFkCounter
= 0;
402 memset(&sIter
, 0, sizeof(sIter
));
405 while( (pOp
= opIterNext(&sIter
))!=0 ){
406 int opcode
= pOp
->opcode
;
407 if( opcode
==OP_Destroy
|| opcode
==OP_VUpdate
|| opcode
==OP_VRename
408 || ((opcode
==OP_Halt
|| opcode
==OP_HaltIfNull
)
409 && ((pOp
->p1
&0xff)==SQLITE_CONSTRAINT
&& pOp
->p2
==OE_Abort
))
414 #ifndef SQLITE_OMIT_FOREIGN_KEY
415 if( opcode
==OP_FkCounter
&& pOp
->p1
==0 && pOp
->p2
==1 ){
420 sqlite3DbFree(v
->db
, sIter
.apSub
);
422 /* Return true if hasAbort==mayAbort. Or if a malloc failure occurred.
423 ** If malloc failed, then the while() loop above may not have iterated
424 ** through all opcodes and hasAbort may be set incorrectly. Return
425 ** true for this case to prevent the assert() in the callers frame
427 return ( v
->db
->mallocFailed
|| hasAbort
==mayAbort
|| hasFkCounter
);
429 #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */
432 ** Loop through the program looking for P2 values that are negative
433 ** on jump instructions. Each such value is a label. Resolve the
434 ** label by setting the P2 value to its correct non-zero value.
436 ** This routine is called once after all opcodes have been inserted.
438 ** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument
439 ** to an OP_Function, OP_AggStep or OP_VFilter opcode. This is used by
440 ** sqlite3VdbeMakeReady() to size the Vdbe.apArg[] array.
442 ** The Op.opflags field is set on all opcodes.
444 static void resolveP2Values(Vdbe
*p
, int *pMaxFuncArgs
){
446 int nMaxArgs
= *pMaxFuncArgs
;
448 Parse
*pParse
= p
->pParse
;
449 int *aLabel
= pParse
->aLabel
;
452 for(pOp
=p
->aOp
, i
=p
->nOp
-1; i
>=0; i
--, pOp
++){
453 u8 opcode
= pOp
->opcode
;
455 /* NOTE: Be sure to update mkopcodeh.awk when adding or removing
456 ** cases from this switch! */
460 if( pOp
->p5
>nMaxArgs
) nMaxArgs
= pOp
->p5
;
463 case OP_Transaction
: {
464 if( pOp
->p2
!=0 ) p
->readOnly
= 0;
472 #ifndef SQLITE_OMIT_WAL
476 case OP_JournalMode
: {
481 #ifndef SQLITE_OMIT_VIRTUALTABLE
483 if( pOp
->p2
>nMaxArgs
) nMaxArgs
= pOp
->p2
;
488 assert( p
->nOp
- i
>= 3 );
489 assert( pOp
[-1].opcode
==OP_Integer
);
491 if( n
>nMaxArgs
) nMaxArgs
= n
;
497 case OP_SorterNext
: {
498 pOp
->p4
.xAdvance
= sqlite3BtreeNext
;
499 pOp
->p4type
= P4_ADVANCE
;
503 case OP_PrevIfOpen
: {
504 pOp
->p4
.xAdvance
= sqlite3BtreePrevious
;
505 pOp
->p4type
= P4_ADVANCE
;
510 pOp
->opflags
= sqlite3OpcodeProperty
[opcode
];
511 if( (pOp
->opflags
& OPFLG_JUMP
)!=0 && pOp
->p2
<0 ){
512 assert( -1-pOp
->p2
<pParse
->nLabel
);
513 pOp
->p2
= aLabel
[-1-pOp
->p2
];
516 sqlite3DbFree(p
->db
, pParse
->aLabel
);
519 *pMaxFuncArgs
= nMaxArgs
;
520 assert( p
->bIsReader
!=0 || DbMaskAllZero(p
->btreeMask
) );
524 ** Return the address of the next instruction to be inserted.
526 int sqlite3VdbeCurrentAddr(Vdbe
*p
){
527 assert( p
->magic
==VDBE_MAGIC_INIT
);
532 ** This function returns a pointer to the array of opcodes associated with
533 ** the Vdbe passed as the first argument. It is the callers responsibility
534 ** to arrange for the returned array to be eventually freed using the
535 ** vdbeFreeOpArray() function.
537 ** Before returning, *pnOp is set to the number of entries in the returned
538 ** array. Also, *pnMaxArg is set to the larger of its current value and
539 ** the number of entries in the Vdbe.apArg[] array required to execute the
542 VdbeOp
*sqlite3VdbeTakeOpArray(Vdbe
*p
, int *pnOp
, int *pnMaxArg
){
543 VdbeOp
*aOp
= p
->aOp
;
544 assert( aOp
&& !p
->db
->mallocFailed
);
546 /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
547 assert( DbMaskAllZero(p
->btreeMask
) );
549 resolveP2Values(p
, pnMaxArg
);
556 ** Add a whole list of operations to the operation stack. Return the
557 ** address of the first operation added.
559 int sqlite3VdbeAddOpList(Vdbe
*p
, int nOp
, VdbeOpList
const *aOp
, int iLineno
){
561 assert( p
->magic
==VDBE_MAGIC_INIT
);
562 if( p
->nOp
+ nOp
> p
->pParse
->nOpAlloc
&& growOpArray(p
, nOp
) ){
568 VdbeOpList
const *pIn
= aOp
;
569 for(i
=0; i
<nOp
; i
++, pIn
++){
571 VdbeOp
*pOut
= &p
->aOp
[i
+addr
];
572 pOut
->opcode
= pIn
->opcode
;
575 assert( sqlite3OpcodeProperty
[pOut
->opcode
] & OPFLG_JUMP
);
576 pOut
->p2
= addr
+ ADDR(p2
);
581 pOut
->p4type
= P4_NOTUSED
;
584 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
587 #ifdef SQLITE_VDBE_COVERAGE
588 pOut
->iSrcLine
= iLineno
+i
;
593 if( p
->db
->flags
& SQLITE_VdbeAddopTrace
){
594 sqlite3VdbePrintOp(0, i
+addr
, &p
->aOp
[i
+addr
]);
603 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS)
605 ** Add an entry to the array of counters managed by sqlite3_stmt_scanstatus().
607 void sqlite3VdbeScanStatus(
608 Vdbe
*p
, /* VM to add scanstatus() to */
609 int addrExplain
, /* Address of OP_Explain (or 0) */
610 int addrLoop
, /* Address of loop counter */
611 int addrVisit
, /* Address of rows visited counter */
612 LogEst nEst
, /* Estimated number of output rows */
613 const char *zName
/* Name of table or index being scanned */
615 int nByte
= (p
->nScan
+1) * sizeof(ScanStatus
);
617 aNew
= (ScanStatus
*)sqlite3DbRealloc(p
->db
, p
->aScan
, nByte
);
619 ScanStatus
*pNew
= &aNew
[p
->nScan
++];
620 pNew
->addrExplain
= addrExplain
;
621 pNew
->addrLoop
= addrLoop
;
622 pNew
->addrVisit
= addrVisit
;
624 pNew
->zName
= sqlite3DbStrDup(p
->db
, zName
);
632 ** Change the value of the P1 operand for a specific instruction.
633 ** This routine is useful when a large program is loaded from a
634 ** static array using sqlite3VdbeAddOpList but we want to make a
635 ** few minor changes to the program.
637 void sqlite3VdbeChangeP1(Vdbe
*p
, u32 addr
, int val
){
639 if( ((u32
)p
->nOp
)>addr
){
640 p
->aOp
[addr
].p1
= val
;
645 ** Change the value of the P2 operand for a specific instruction.
646 ** This routine is useful for setting a jump destination.
648 void sqlite3VdbeChangeP2(Vdbe
*p
, u32 addr
, int val
){
650 if( ((u32
)p
->nOp
)>addr
){
651 p
->aOp
[addr
].p2
= val
;
656 ** Change the value of the P3 operand for a specific instruction.
658 void sqlite3VdbeChangeP3(Vdbe
*p
, u32 addr
, int val
){
660 if( ((u32
)p
->nOp
)>addr
){
661 p
->aOp
[addr
].p3
= val
;
666 ** Change the value of the P5 operand for the most recently
669 void sqlite3VdbeChangeP5(Vdbe
*p
, u8 val
){
673 p
->aOp
[p
->nOp
-1].p5
= val
;
678 ** Change the P2 operand of instruction addr so that it points to
679 ** the address of the next instruction to be coded.
681 void sqlite3VdbeJumpHere(Vdbe
*p
, int addr
){
682 sqlite3VdbeChangeP2(p
, addr
, p
->nOp
);
683 p
->pParse
->iFixedOp
= p
->nOp
- 1;
688 ** If the input FuncDef structure is ephemeral, then free it. If
689 ** the FuncDef is not ephermal, then do nothing.
691 static void freeEphemeralFunction(sqlite3
*db
, FuncDef
*pDef
){
692 if( ALWAYS(pDef
) && (pDef
->funcFlags
& SQLITE_FUNC_EPHEM
)!=0 ){
693 sqlite3DbFree(db
, pDef
);
697 static void vdbeFreeOpArray(sqlite3
*, Op
*, int);
700 ** Delete a P4 value if necessary.
702 static void freeP4(sqlite3
*db
, int p4type
, void *p4
){
710 sqlite3DbFree(db
, p4
);
714 if( db
->pnBytesFreed
==0 ) sqlite3KeyInfoUnref((KeyInfo
*)p4
);
718 if( db
->pnBytesFreed
==0 ) sqlite3_free(p4
);
722 freeEphemeralFunction(db
, (FuncDef
*)p4
);
726 if( db
->pnBytesFreed
==0 ){
727 sqlite3ValueFree((sqlite3_value
*)p4
);
730 if( p
->szMalloc
) sqlite3DbFree(db
, p
->zMalloc
);
731 sqlite3DbFree(db
, p
);
736 if( db
->pnBytesFreed
==0 ) sqlite3VtabUnlock((VTable
*)p4
);
744 ** Free the space allocated for aOp and any p4 values allocated for the
745 ** opcodes contained within. If aOp is not NULL it is assumed to contain
748 static void vdbeFreeOpArray(sqlite3
*db
, Op
*aOp
, int nOp
){
751 for(pOp
=aOp
; pOp
<&aOp
[nOp
]; pOp
++){
752 freeP4(db
, pOp
->p4type
, pOp
->p4
.p
);
753 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
754 sqlite3DbFree(db
, pOp
->zComment
);
758 sqlite3DbFree(db
, aOp
);
762 ** Link the SubProgram object passed as the second argument into the linked
763 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
764 ** objects when the VM is no longer required.
766 void sqlite3VdbeLinkSubProgram(Vdbe
*pVdbe
, SubProgram
*p
){
767 p
->pNext
= pVdbe
->pProgram
;
772 ** Change the opcode at addr into OP_Noop
774 void sqlite3VdbeChangeToNoop(Vdbe
*p
, int addr
){
776 VdbeOp
*pOp
= &p
->aOp
[addr
];
778 freeP4(db
, pOp
->p4type
, pOp
->p4
.p
);
779 memset(pOp
, 0, sizeof(pOp
[0]));
780 pOp
->opcode
= OP_Noop
;
781 if( addr
==p
->nOp
-1 ) p
->nOp
--;
786 ** If the last opcode is "op" and it is not a jump destination,
787 ** then remove it. Return true if and only if an opcode was removed.
789 int sqlite3VdbeDeletePriorOpcode(Vdbe
*p
, u8 op
){
790 if( (p
->nOp
-1)>(p
->pParse
->iFixedOp
) && p
->aOp
[p
->nOp
-1].opcode
==op
){
791 sqlite3VdbeChangeToNoop(p
, p
->nOp
-1);
799 ** Change the value of the P4 operand for a specific instruction.
800 ** This routine is useful when a large program is loaded from a
801 ** static array using sqlite3VdbeAddOpList but we want to make a
802 ** few minor changes to the program.
804 ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
805 ** the string is made into memory obtained from sqlite3_malloc().
806 ** A value of n==0 means copy bytes of zP4 up to and including the
807 ** first null byte. If n>0 then copy n+1 bytes of zP4.
809 ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
810 ** to a string or structure that is guaranteed to exist for the lifetime of
811 ** the Vdbe. In these cases we can just copy the pointer.
813 ** If addr<0 then change P4 on the most recently inserted instruction.
815 void sqlite3VdbeChangeP4(Vdbe
*p
, int addr
, const char *zP4
, int n
){
820 assert( p
->magic
==VDBE_MAGIC_INIT
);
821 if( p
->aOp
==0 || db
->mallocFailed
){
823 freeP4(db
, n
, (void*)*(char**)&zP4
);
828 assert( addr
<p
->nOp
);
833 assert( pOp
->p4type
==P4_NOTUSED
834 || pOp
->p4type
==P4_INT32
835 || pOp
->p4type
==P4_KEYINFO
);
836 freeP4(db
, pOp
->p4type
, pOp
->p4
.p
);
839 /* Note: this cast is safe, because the origin data point was an int
840 ** that was cast to a (const char *). */
841 pOp
->p4
.i
= SQLITE_PTR_TO_INT(zP4
);
842 pOp
->p4type
= P4_INT32
;
845 pOp
->p4type
= P4_NOTUSED
;
846 }else if( n
==P4_KEYINFO
){
847 pOp
->p4
.p
= (void*)zP4
;
848 pOp
->p4type
= P4_KEYINFO
;
849 }else if( n
==P4_VTAB
){
850 pOp
->p4
.p
= (void*)zP4
;
851 pOp
->p4type
= P4_VTAB
;
852 sqlite3VtabLock((VTable
*)zP4
);
853 assert( ((VTable
*)zP4
)->db
==p
->db
);
855 pOp
->p4
.p
= (void*)zP4
;
856 pOp
->p4type
= (signed char)n
;
858 if( n
==0 ) n
= sqlite3Strlen30(zP4
);
859 pOp
->p4
.z
= sqlite3DbStrNDup(p
->db
, zP4
, n
);
860 pOp
->p4type
= P4_DYNAMIC
;
865 ** Set the P4 on the most recently added opcode to the KeyInfo for the
868 void sqlite3VdbeSetP4KeyInfo(Parse
*pParse
, Index
*pIdx
){
869 Vdbe
*v
= pParse
->pVdbe
;
872 sqlite3VdbeChangeP4(v
, -1, (char*)sqlite3KeyInfoOfIndex(pParse
, pIdx
),
876 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
878 ** Change the comment on the most recently coded instruction. Or
879 ** insert a No-op and add the comment to that new instruction. This
880 ** makes the code easier to read during debugging. None of this happens
881 ** in a production build.
883 static void vdbeVComment(Vdbe
*p
, const char *zFormat
, va_list ap
){
884 assert( p
->nOp
>0 || p
->aOp
==0 );
885 assert( p
->aOp
==0 || p
->aOp
[p
->nOp
-1].zComment
==0 || p
->db
->mallocFailed
);
888 sqlite3DbFree(p
->db
, p
->aOp
[p
->nOp
-1].zComment
);
889 p
->aOp
[p
->nOp
-1].zComment
= sqlite3VMPrintf(p
->db
, zFormat
, ap
);
892 void sqlite3VdbeComment(Vdbe
*p
, const char *zFormat
, ...){
895 va_start(ap
, zFormat
);
896 vdbeVComment(p
, zFormat
, ap
);
900 void sqlite3VdbeNoopComment(Vdbe
*p
, const char *zFormat
, ...){
903 sqlite3VdbeAddOp0(p
, OP_Noop
);
904 va_start(ap
, zFormat
);
905 vdbeVComment(p
, zFormat
, ap
);
911 #ifdef SQLITE_VDBE_COVERAGE
913 ** Set the value if the iSrcLine field for the previously coded instruction.
915 void sqlite3VdbeSetLineNumber(Vdbe
*v
, int iLine
){
916 sqlite3VdbeGetOp(v
,-1)->iSrcLine
= iLine
;
918 #endif /* SQLITE_VDBE_COVERAGE */
921 ** Return the opcode for a given address. If the address is -1, then
922 ** return the most recently inserted opcode.
924 ** If a memory allocation error has occurred prior to the calling of this
925 ** routine, then a pointer to a dummy VdbeOp will be returned. That opcode
926 ** is readable but not writable, though it is cast to a writable value.
927 ** The return of a dummy opcode allows the call to continue functioning
928 ** after an OOM fault without having to check to see if the return from
929 ** this routine is a valid pointer. But because the dummy.opcode is 0,
930 ** dummy will never be written to. This is verified by code inspection and
931 ** by running with Valgrind.
933 VdbeOp
*sqlite3VdbeGetOp(Vdbe
*p
, int addr
){
934 /* C89 specifies that the constant "dummy" will be initialized to all
935 ** zeros, which is correct. MSVC generates a warning, nevertheless. */
936 static VdbeOp dummy
; /* Ignore the MSVC warning about no initializer */
937 assert( p
->magic
==VDBE_MAGIC_INIT
);
941 assert( (addr
>=0 && addr
<p
->nOp
) || p
->db
->mallocFailed
);
942 if( p
->db
->mallocFailed
){
943 return (VdbeOp
*)&dummy
;
945 return &p
->aOp
[addr
];
949 #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS)
951 ** Return an integer value for one of the parameters to the opcode pOp
952 ** determined by character c.
954 static int translateP(char c
, const Op
*pOp
){
955 if( c
=='1' ) return pOp
->p1
;
956 if( c
=='2' ) return pOp
->p2
;
957 if( c
=='3' ) return pOp
->p3
;
958 if( c
=='4' ) return pOp
->p4
.i
;
963 ** Compute a string for the "comment" field of a VDBE opcode listing.
965 ** The Synopsis: field in comments in the vdbe.c source file gets converted
966 ** to an extra string that is appended to the sqlite3OpcodeName(). In the
967 ** absence of other comments, this synopsis becomes the comment on the opcode.
968 ** Some translation occurs:
971 ** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1
972 ** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0
973 ** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x
975 static int displayComment(
976 const Op
*pOp
, /* The opcode to be commented */
977 const char *zP4
, /* Previously obtained value for P4 */
978 char *zTemp
, /* Write result here */
979 int nTemp
/* Space available in zTemp[] */
982 const char *zSynopsis
;
985 zOpName
= sqlite3OpcodeName(pOp
->opcode
);
986 nOpName
= sqlite3Strlen30(zOpName
);
987 if( zOpName
[nOpName
+1] ){
990 zSynopsis
= zOpName
+= nOpName
+ 1;
991 for(ii
=jj
=0; jj
<nTemp
-1 && (c
= zSynopsis
[ii
])!=0; ii
++){
995 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "%s", zP4
);
997 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "%s", pOp
->zComment
);
1000 int v1
= translateP(c
, pOp
);
1002 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "%d", v1
);
1003 if( strncmp(zSynopsis
+ii
+1, "@P", 2)==0 ){
1005 jj
+= sqlite3Strlen30(zTemp
+jj
);
1006 v2
= translateP(zSynopsis
[ii
], pOp
);
1007 if( strncmp(zSynopsis
+ii
+1,"+1",2)==0 ){
1012 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "..%d", v1
+v2
-1);
1014 }else if( strncmp(zSynopsis
+ii
+1, "..P3", 4)==0 && pOp
->p3
==0 ){
1018 jj
+= sqlite3Strlen30(zTemp
+jj
);
1023 if( !seenCom
&& jj
<nTemp
-5 && pOp
->zComment
){
1024 sqlite3_snprintf(nTemp
-jj
, zTemp
+jj
, "; %s", pOp
->zComment
);
1025 jj
+= sqlite3Strlen30(zTemp
+jj
);
1027 if( jj
<nTemp
) zTemp
[jj
] = 0;
1028 }else if( pOp
->zComment
){
1029 sqlite3_snprintf(nTemp
, zTemp
, "%s", pOp
->zComment
);
1030 jj
= sqlite3Strlen30(zTemp
);
1037 #endif /* SQLITE_DEBUG */
1040 #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \
1041 || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
1043 ** Compute a string that describes the P4 parameter for an opcode.
1044 ** Use zTemp for any required temporary buffer space.
1046 static char *displayP4(Op
*pOp
, char *zTemp
, int nTemp
){
1048 assert( nTemp
>=20 );
1049 switch( pOp
->p4type
){
1052 KeyInfo
*pKeyInfo
= pOp
->p4
.pKeyInfo
;
1053 assert( pKeyInfo
->aSortOrder
!=0 );
1054 sqlite3_snprintf(nTemp
, zTemp
, "k(%d", pKeyInfo
->nField
);
1055 i
= sqlite3Strlen30(zTemp
);
1056 for(j
=0; j
<pKeyInfo
->nField
; j
++){
1057 CollSeq
*pColl
= pKeyInfo
->aColl
[j
];
1058 const char *zColl
= pColl
? pColl
->zName
: "nil";
1059 int n
= sqlite3Strlen30(zColl
);
1060 if( n
==6 && memcmp(zColl
,"BINARY",6)==0 ){
1065 memcpy(&zTemp
[i
],",...",4);
1069 if( pKeyInfo
->aSortOrder
[j
] ){
1072 memcpy(&zTemp
[i
], zColl
, n
+1);
1081 CollSeq
*pColl
= pOp
->p4
.pColl
;
1082 sqlite3_snprintf(nTemp
, zTemp
, "(%.20s)", pColl
->zName
);
1086 FuncDef
*pDef
= pOp
->p4
.pFunc
;
1087 sqlite3_snprintf(nTemp
, zTemp
, "%s(%d)", pDef
->zName
, pDef
->nArg
);
1091 sqlite3_snprintf(nTemp
, zTemp
, "%lld", *pOp
->p4
.pI64
);
1095 sqlite3_snprintf(nTemp
, zTemp
, "%d", pOp
->p4
.i
);
1099 sqlite3_snprintf(nTemp
, zTemp
, "%.16g", *pOp
->p4
.pReal
);
1103 Mem
*pMem
= pOp
->p4
.pMem
;
1104 if( pMem
->flags
& MEM_Str
){
1106 }else if( pMem
->flags
& MEM_Int
){
1107 sqlite3_snprintf(nTemp
, zTemp
, "%lld", pMem
->u
.i
);
1108 }else if( pMem
->flags
& MEM_Real
){
1109 sqlite3_snprintf(nTemp
, zTemp
, "%.16g", pMem
->u
.r
);
1110 }else if( pMem
->flags
& MEM_Null
){
1111 sqlite3_snprintf(nTemp
, zTemp
, "NULL");
1113 assert( pMem
->flags
& MEM_Blob
);
1118 #ifndef SQLITE_OMIT_VIRTUALTABLE
1120 sqlite3_vtab
*pVtab
= pOp
->p4
.pVtab
->pVtab
;
1121 sqlite3_snprintf(nTemp
, zTemp
, "vtab:%p:%p", pVtab
, pVtab
->pModule
);
1126 sqlite3_snprintf(nTemp
, zTemp
, "intarray");
1129 case P4_SUBPROGRAM
: {
1130 sqlite3_snprintf(nTemp
, zTemp
, "program");
1151 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
1153 ** The prepared statements need to know in advance the complete set of
1154 ** attached databases that will be use. A mask of these databases
1155 ** is maintained in p->btreeMask. The p->lockMask value is the subset of
1156 ** p->btreeMask of databases that will require a lock.
1158 void sqlite3VdbeUsesBtree(Vdbe
*p
, int i
){
1159 assert( i
>=0 && i
<p
->db
->nDb
&& i
<(int)sizeof(yDbMask
)*8 );
1160 assert( i
<(int)sizeof(p
->btreeMask
)*8 );
1161 DbMaskSet(p
->btreeMask
, i
);
1162 if( i
!=1 && sqlite3BtreeSharable(p
->db
->aDb
[i
].pBt
) ){
1163 DbMaskSet(p
->lockMask
, i
);
1167 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
1169 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
1170 ** this routine obtains the mutex associated with each BtShared structure
1171 ** that may be accessed by the VM passed as an argument. In doing so it also
1172 ** sets the BtShared.db member of each of the BtShared structures, ensuring
1173 ** that the correct busy-handler callback is invoked if required.
1175 ** If SQLite is not threadsafe but does support shared-cache mode, then
1176 ** sqlite3BtreeEnter() is invoked to set the BtShared.db variables
1177 ** of all of BtShared structures accessible via the database handle
1178 ** associated with the VM.
1180 ** If SQLite is not threadsafe and does not support shared-cache mode, this
1181 ** function is a no-op.
1183 ** The p->btreeMask field is a bitmask of all btrees that the prepared
1184 ** statement p will ever use. Let N be the number of bits in p->btreeMask
1185 ** corresponding to btrees that use shared cache. Then the runtime of
1186 ** this routine is N*N. But as N is rarely more than 1, this should not
1189 void sqlite3VdbeEnter(Vdbe
*p
){
1194 if( DbMaskAllZero(p
->lockMask
) ) return; /* The common case */
1198 for(i
=0; i
<nDb
; i
++){
1199 if( i
!=1 && DbMaskTest(p
->lockMask
,i
) && ALWAYS(aDb
[i
].pBt
!=0) ){
1200 sqlite3BtreeEnter(aDb
[i
].pBt
);
1206 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
1208 ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter().
1210 void sqlite3VdbeLeave(Vdbe
*p
){
1215 if( DbMaskAllZero(p
->lockMask
) ) return; /* The common case */
1219 for(i
=0; i
<nDb
; i
++){
1220 if( i
!=1 && DbMaskTest(p
->lockMask
,i
) && ALWAYS(aDb
[i
].pBt
!=0) ){
1221 sqlite3BtreeLeave(aDb
[i
].pBt
);
1227 #if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
1229 ** Print a single opcode. This routine is used for debugging only.
1231 void sqlite3VdbePrintOp(FILE *pOut
, int pc
, Op
*pOp
){
1235 static const char *zFormat1
= "%4d %-13s %4d %4d %4d %-13s %.2X %s\n";
1236 if( pOut
==0 ) pOut
= stdout
;
1237 zP4
= displayP4(pOp
, zPtr
, sizeof(zPtr
));
1238 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1239 displayComment(pOp
, zP4
, zCom
, sizeof(zCom
));
1243 /* NB: The sqlite3OpcodeName() function is implemented by code created
1244 ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the
1245 ** information from the vdbe.c source text */
1246 fprintf(pOut
, zFormat1
, pc
,
1247 sqlite3OpcodeName(pOp
->opcode
), pOp
->p1
, pOp
->p2
, pOp
->p3
, zP4
, pOp
->p5
,
1255 ** Release an array of N Mem elements
1257 static void releaseMemArray(Mem
*p
, int N
){
1260 sqlite3
*db
= p
->db
;
1261 u8 malloc_failed
= db
->mallocFailed
;
1262 if( db
->pnBytesFreed
){
1264 if( p
->szMalloc
) sqlite3DbFree(db
, p
->zMalloc
);
1265 }while( (++p
)<pEnd
);
1269 assert( (&p
[1])==pEnd
|| p
[0].db
==p
[1].db
);
1270 assert( sqlite3VdbeCheckMemInvariants(p
) );
1272 /* This block is really an inlined version of sqlite3VdbeMemRelease()
1273 ** that takes advantage of the fact that the memory cell value is
1274 ** being set to NULL after releasing any dynamic resources.
1276 ** The justification for duplicating code is that according to
1277 ** callgrind, this causes a certain test case to hit the CPU 4.7
1278 ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
1279 ** sqlite3MemRelease() were called from here. With -O2, this jumps
1280 ** to 6.6 percent. The test case is inserting 1000 rows into a table
1281 ** with no indexes using a single prepared INSERT statement, bind()
1282 ** and reset(). Inserts are grouped into a transaction.
1284 testcase( p
->flags
& MEM_Agg
);
1285 testcase( p
->flags
& MEM_Dyn
);
1286 testcase( p
->flags
& MEM_Frame
);
1287 testcase( p
->flags
& MEM_RowSet
);
1288 if( p
->flags
&(MEM_Agg
|MEM_Dyn
|MEM_Frame
|MEM_RowSet
) ){
1289 sqlite3VdbeMemRelease(p
);
1290 }else if( p
->szMalloc
){
1291 sqlite3DbFree(db
, p
->zMalloc
);
1295 p
->flags
= MEM_Undefined
;
1296 }while( (++p
)<pEnd
);
1297 db
->mallocFailed
= malloc_failed
;
1302 ** Delete a VdbeFrame object and its contents. VdbeFrame objects are
1303 ** allocated by the OP_Program opcode in sqlite3VdbeExec().
1305 void sqlite3VdbeFrameDelete(VdbeFrame
*p
){
1307 Mem
*aMem
= VdbeFrameMem(p
);
1308 VdbeCursor
**apCsr
= (VdbeCursor
**)&aMem
[p
->nChildMem
];
1309 for(i
=0; i
<p
->nChildCsr
; i
++){
1310 sqlite3VdbeFreeCursor(p
->v
, apCsr
[i
]);
1312 releaseMemArray(aMem
, p
->nChildMem
);
1313 sqlite3DbFree(p
->v
->db
, p
);
1316 #ifndef SQLITE_OMIT_EXPLAIN
1318 ** Give a listing of the program in the virtual machine.
1320 ** The interface is the same as sqlite3VdbeExec(). But instead of
1321 ** running the code, it invokes the callback once for each instruction.
1322 ** This feature is used to implement "EXPLAIN".
1324 ** When p->explain==1, each instruction is listed. When
1325 ** p->explain==2, only OP_Explain instructions are listed and these
1326 ** are shown in a different format. p->explain==2 is used to implement
1327 ** EXPLAIN QUERY PLAN.
1329 ** When p->explain==1, first the main program is listed, then each of
1330 ** the trigger subprograms are listed one by one.
1332 int sqlite3VdbeList(
1333 Vdbe
*p
/* The VDBE */
1335 int nRow
; /* Stop when row count reaches this */
1336 int nSub
= 0; /* Number of sub-vdbes seen so far */
1337 SubProgram
**apSub
= 0; /* Array of sub-vdbes */
1338 Mem
*pSub
= 0; /* Memory cell hold array of subprogs */
1339 sqlite3
*db
= p
->db
; /* The database connection */
1340 int i
; /* Loop counter */
1341 int rc
= SQLITE_OK
; /* Return code */
1342 Mem
*pMem
= &p
->aMem
[1]; /* First Mem of result set */
1344 assert( p
->explain
);
1345 assert( p
->magic
==VDBE_MAGIC_RUN
);
1346 assert( p
->rc
==SQLITE_OK
|| p
->rc
==SQLITE_BUSY
|| p
->rc
==SQLITE_NOMEM
);
1348 /* Even though this opcode does not use dynamic strings for
1349 ** the result, result columns may become dynamic if the user calls
1350 ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
1352 releaseMemArray(pMem
, 8);
1355 if( p
->rc
==SQLITE_NOMEM
){
1356 /* This happens if a malloc() inside a call to sqlite3_column_text() or
1357 ** sqlite3_column_text16() failed. */
1358 db
->mallocFailed
= 1;
1359 return SQLITE_ERROR
;
1362 /* When the number of output rows reaches nRow, that means the
1363 ** listing has finished and sqlite3_step() should return SQLITE_DONE.
1364 ** nRow is the sum of the number of rows in the main program, plus
1365 ** the sum of the number of rows in all trigger subprograms encountered
1366 ** so far. The nRow value will increase as new trigger subprograms are
1367 ** encountered, but p->pc will eventually catch up to nRow.
1370 if( p
->explain
==1 ){
1371 /* The first 8 memory cells are used for the result set. So we will
1372 ** commandeer the 9th cell to use as storage for an array of pointers
1373 ** to trigger subprograms. The VDBE is guaranteed to have at least 9
1375 assert( p
->nMem
>9 );
1377 if( pSub
->flags
&MEM_Blob
){
1378 /* On the first call to sqlite3_step(), pSub will hold a NULL. It is
1379 ** initialized to a BLOB by the P4_SUBPROGRAM processing logic below */
1380 nSub
= pSub
->n
/sizeof(Vdbe
*);
1381 apSub
= (SubProgram
**)pSub
->z
;
1383 for(i
=0; i
<nSub
; i
++){
1384 nRow
+= apSub
[i
]->nOp
;
1390 }while( i
<nRow
&& p
->explain
==2 && p
->aOp
[i
].opcode
!=OP_Explain
);
1394 }else if( db
->u1
.isInterrupted
){
1395 p
->rc
= SQLITE_INTERRUPT
;
1397 sqlite3SetString(&p
->zErrMsg
, db
, "%s", sqlite3ErrStr(p
->rc
));
1402 /* The output line number is small enough that we are still in the
1406 /* We are currently listing subprograms. Figure out which one and
1407 ** pick up the appropriate opcode. */
1410 for(j
=0; i
>=apSub
[j
]->nOp
; j
++){
1413 pOp
= &apSub
[j
]->aOp
[i
];
1415 if( p
->explain
==1 ){
1416 pMem
->flags
= MEM_Int
;
1417 pMem
->u
.i
= i
; /* Program counter */
1420 pMem
->flags
= MEM_Static
|MEM_Str
|MEM_Term
;
1421 pMem
->z
= (char*)sqlite3OpcodeName(pOp
->opcode
); /* Opcode */
1422 assert( pMem
->z
!=0 );
1423 pMem
->n
= sqlite3Strlen30(pMem
->z
);
1424 pMem
->enc
= SQLITE_UTF8
;
1427 /* When an OP_Program opcode is encounter (the only opcode that has
1428 ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms
1429 ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
1430 ** has not already been seen.
1432 if( pOp
->p4type
==P4_SUBPROGRAM
){
1433 int nByte
= (nSub
+1)*sizeof(SubProgram
*);
1435 for(j
=0; j
<nSub
; j
++){
1436 if( apSub
[j
]==pOp
->p4
.pProgram
) break;
1438 if( j
==nSub
&& SQLITE_OK
==sqlite3VdbeMemGrow(pSub
, nByte
, nSub
!=0) ){
1439 apSub
= (SubProgram
**)pSub
->z
;
1440 apSub
[nSub
++] = pOp
->p4
.pProgram
;
1441 pSub
->flags
|= MEM_Blob
;
1442 pSub
->n
= nSub
*sizeof(SubProgram
*);
1447 pMem
->flags
= MEM_Int
;
1448 pMem
->u
.i
= pOp
->p1
; /* P1 */
1451 pMem
->flags
= MEM_Int
;
1452 pMem
->u
.i
= pOp
->p2
; /* P2 */
1455 pMem
->flags
= MEM_Int
;
1456 pMem
->u
.i
= pOp
->p3
; /* P3 */
1459 if( sqlite3VdbeMemClearAndResize(pMem
, 32) ){ /* P4 */
1460 assert( p
->db
->mallocFailed
);
1461 return SQLITE_ERROR
;
1463 pMem
->flags
= MEM_Str
|MEM_Term
;
1464 zP4
= displayP4(pOp
, pMem
->z
, 32);
1466 sqlite3VdbeMemSetStr(pMem
, zP4
, -1, SQLITE_UTF8
, 0);
1468 assert( pMem
->z
!=0 );
1469 pMem
->n
= sqlite3Strlen30(pMem
->z
);
1470 pMem
->enc
= SQLITE_UTF8
;
1474 if( p
->explain
==1 ){
1475 if( sqlite3VdbeMemClearAndResize(pMem
, 4) ){
1476 assert( p
->db
->mallocFailed
);
1477 return SQLITE_ERROR
;
1479 pMem
->flags
= MEM_Str
|MEM_Term
;
1481 sqlite3_snprintf(3, pMem
->z
, "%.2x", pOp
->p5
); /* P5 */
1482 pMem
->enc
= SQLITE_UTF8
;
1485 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
1486 if( sqlite3VdbeMemClearAndResize(pMem
, 500) ){
1487 assert( p
->db
->mallocFailed
);
1488 return SQLITE_ERROR
;
1490 pMem
->flags
= MEM_Str
|MEM_Term
;
1491 pMem
->n
= displayComment(pOp
, zP4
, pMem
->z
, 500);
1492 pMem
->enc
= SQLITE_UTF8
;
1494 pMem
->flags
= MEM_Null
; /* Comment */
1498 p
->nResColumn
= 8 - 4*(p
->explain
-1);
1499 p
->pResultSet
= &p
->aMem
[1];
1505 #endif /* SQLITE_OMIT_EXPLAIN */
1509 ** Print the SQL that was used to generate a VDBE program.
1511 void sqlite3VdbePrintSql(Vdbe
*p
){
1515 }else if( p
->nOp
>=1 ){
1516 const VdbeOp
*pOp
= &p
->aOp
[0];
1517 if( pOp
->opcode
==OP_Init
&& pOp
->p4
.z
!=0 ){
1519 while( sqlite3Isspace(*z
) ) z
++;
1522 if( z
) printf("SQL: [%s]\n", z
);
1526 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
1528 ** Print an IOTRACE message showing SQL content.
1530 void sqlite3VdbeIOTraceSql(Vdbe
*p
){
1533 if( sqlite3IoTrace
==0 ) return;
1536 if( pOp
->opcode
==OP_Init
&& pOp
->p4
.z
!=0 ){
1539 sqlite3_snprintf(sizeof(z
), z
, "%s", pOp
->p4
.z
);
1540 for(i
=0; sqlite3Isspace(z
[i
]); i
++){}
1541 for(j
=0; z
[i
]; i
++){
1542 if( sqlite3Isspace(z
[i
]) ){
1551 sqlite3IoTrace("SQL %s\n", z
);
1554 #endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */
1557 ** Allocate space from a fixed size buffer and return a pointer to
1558 ** that space. If insufficient space is available, return NULL.
1560 ** The pBuf parameter is the initial value of a pointer which will
1561 ** receive the new memory. pBuf is normally NULL. If pBuf is not
1562 ** NULL, it means that memory space has already been allocated and that
1563 ** this routine should not allocate any new memory. When pBuf is not
1564 ** NULL simply return pBuf. Only allocate new memory space when pBuf
1567 ** nByte is the number of bytes of space needed.
1569 ** *ppFrom points to available space and pEnd points to the end of the
1570 ** available space. When space is allocated, *ppFrom is advanced past
1571 ** the end of the allocated space.
1573 ** *pnByte is a counter of the number of bytes of space that have failed
1574 ** to allocate. If there is insufficient space in *ppFrom to satisfy the
1575 ** request, then increment *pnByte by the amount of the request.
1577 static void *allocSpace(
1578 void *pBuf
, /* Where return pointer will be stored */
1579 int nByte
, /* Number of bytes to allocate */
1580 u8
**ppFrom
, /* IN/OUT: Allocate from *ppFrom */
1581 u8
*pEnd
, /* Pointer to 1 byte past the end of *ppFrom buffer */
1582 int *pnByte
/* If allocation cannot be made, increment *pnByte */
1584 assert( EIGHT_BYTE_ALIGNMENT(*ppFrom
) );
1585 if( pBuf
) return pBuf
;
1586 nByte
= ROUND8(nByte
);
1587 if( &(*ppFrom
)[nByte
] <= pEnd
){
1588 pBuf
= (void*)*ppFrom
;
1597 ** Rewind the VDBE back to the beginning in preparation for
1600 void sqlite3VdbeRewind(Vdbe
*p
){
1601 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
1605 assert( p
->magic
==VDBE_MAGIC_INIT
);
1607 /* There should be at least one opcode.
1611 /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */
1612 p
->magic
= VDBE_MAGIC_RUN
;
1615 for(i
=1; i
<p
->nMem
; i
++){
1616 assert( p
->aMem
[i
].db
==p
->db
);
1621 p
->errorAction
= OE_Abort
;
1622 p
->magic
= VDBE_MAGIC_RUN
;
1625 p
->minWriteFileFormat
= 255;
1627 p
->nFkConstraint
= 0;
1629 for(i
=0; i
<p
->nOp
; i
++){
1631 p
->aOp
[i
].cycles
= 0;
1637 ** Prepare a virtual machine for execution for the first time after
1638 ** creating the virtual machine. This involves things such
1639 ** as allocating registers and initializing the program counter.
1640 ** After the VDBE has be prepped, it can be executed by one or more
1641 ** calls to sqlite3VdbeExec().
1643 ** This function may be called exactly once on each virtual machine.
1644 ** After this routine is called the VM has been "packaged" and is ready
1645 ** to run. After this routine is called, further calls to
1646 ** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects
1647 ** the Vdbe from the Parse object that helped generate it so that the
1648 ** the Vdbe becomes an independent entity and the Parse object can be
1651 ** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back
1652 ** to its initial state after it has been run.
1654 void sqlite3VdbeMakeReady(
1655 Vdbe
*p
, /* The VDBE */
1656 Parse
*pParse
/* Parsing context */
1658 sqlite3
*db
; /* The database connection */
1659 int nVar
; /* Number of parameters */
1660 int nMem
; /* Number of VM memory registers */
1661 int nCursor
; /* Number of cursors required */
1662 int nArg
; /* Number of arguments in subprograms */
1663 int nOnce
; /* Number of OP_Once instructions */
1664 int n
; /* Loop counter */
1665 u8
*zCsr
; /* Memory available for allocation */
1666 u8
*zEnd
; /* First byte past allocated memory */
1667 int nByte
; /* How much extra memory is needed */
1671 assert( pParse
!=0 );
1672 assert( p
->magic
==VDBE_MAGIC_INIT
);
1673 assert( pParse
==p
->pParse
);
1675 assert( db
->mallocFailed
==0 );
1676 nVar
= pParse
->nVar
;
1677 nMem
= pParse
->nMem
;
1678 nCursor
= pParse
->nTab
;
1679 nArg
= pParse
->nMaxArg
;
1680 nOnce
= pParse
->nOnce
;
1681 if( nOnce
==0 ) nOnce
= 1; /* Ensure at least one byte in p->aOnceFlag[] */
1683 /* For each cursor required, also allocate a memory cell. Memory
1684 ** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by
1685 ** the vdbe program. Instead they are used to allocate space for
1686 ** VdbeCursor/BtCursor structures. The blob of memory associated with
1687 ** cursor 0 is stored in memory cell nMem. Memory cell (nMem-1)
1688 ** stores the blob of memory associated with cursor 1, etc.
1690 ** See also: allocateCursor().
1694 /* Allocate space for memory registers, SQL variables, VDBE cursors and
1695 ** an array to marshal SQL function arguments in.
1697 zCsr
= (u8
*)&p
->aOp
[p
->nOp
]; /* Memory avaliable for allocation */
1698 zEnd
= (u8
*)&p
->aOp
[pParse
->nOpAlloc
]; /* First byte past end of zCsr[] */
1700 resolveP2Values(p
, &nArg
);
1701 p
->usesStmtJournal
= (u8
)(pParse
->isMultiWrite
&& pParse
->mayAbort
);
1702 if( pParse
->explain
&& nMem
<10 ){
1705 memset(zCsr
, 0, zEnd
-zCsr
);
1706 zCsr
+= (zCsr
- (u8
*)0)&7;
1707 assert( EIGHT_BYTE_ALIGNMENT(zCsr
) );
1710 /* Memory for registers, parameters, cursor, etc, is allocated in two
1711 ** passes. On the first pass, we try to reuse unused space at the
1712 ** end of the opcode array. If we are unable to satisfy all memory
1713 ** requirements by reusing the opcode array tail, then the second
1714 ** pass will fill in the rest using a fresh allocation.
1716 ** This two-pass approach that reuses as much memory as possible from
1717 ** the leftover space at the end of the opcode array can significantly
1718 ** reduce the amount of memory held by a prepared statement.
1722 p
->aMem
= allocSpace(p
->aMem
, nMem
*sizeof(Mem
), &zCsr
, zEnd
, &nByte
);
1723 p
->aVar
= allocSpace(p
->aVar
, nVar
*sizeof(Mem
), &zCsr
, zEnd
, &nByte
);
1724 p
->apArg
= allocSpace(p
->apArg
, nArg
*sizeof(Mem
*), &zCsr
, zEnd
, &nByte
);
1725 p
->azVar
= allocSpace(p
->azVar
, nVar
*sizeof(char*), &zCsr
, zEnd
, &nByte
);
1726 p
->apCsr
= allocSpace(p
->apCsr
, nCursor
*sizeof(VdbeCursor
*),
1727 &zCsr
, zEnd
, &nByte
);
1728 p
->aOnceFlag
= allocSpace(p
->aOnceFlag
, nOnce
, &zCsr
, zEnd
, &nByte
);
1729 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
1730 p
->anExec
= allocSpace(p
->anExec
, p
->nOp
*sizeof(i64
), &zCsr
, zEnd
, &nByte
);
1733 p
->pFree
= sqlite3DbMallocZero(db
, nByte
);
1736 zEnd
= &zCsr
[nByte
];
1737 }while( nByte
&& !db
->mallocFailed
);
1739 p
->nCursor
= nCursor
;
1740 p
->nOnceFlag
= nOnce
;
1742 p
->nVar
= (ynVar
)nVar
;
1743 for(n
=0; n
<nVar
; n
++){
1744 p
->aVar
[n
].flags
= MEM_Null
;
1748 if( p
->azVar
&& pParse
->nzVar
>0 ){
1749 p
->nzVar
= pParse
->nzVar
;
1750 memcpy(p
->azVar
, pParse
->azVar
, p
->nzVar
*sizeof(p
->azVar
[0]));
1751 memset(pParse
->azVar
, 0, pParse
->nzVar
*sizeof(pParse
->azVar
[0]));
1754 p
->aMem
--; /* aMem[] goes from 1..nMem */
1755 p
->nMem
= nMem
; /* not from 0..nMem-1 */
1756 for(n
=1; n
<=nMem
; n
++){
1757 p
->aMem
[n
].flags
= MEM_Undefined
;
1761 p
->explain
= pParse
->explain
;
1762 sqlite3VdbeRewind(p
);
1766 ** Close a VDBE cursor and release all the resources that cursor
1769 void sqlite3VdbeFreeCursor(Vdbe
*p
, VdbeCursor
*pCx
){
1773 sqlite3VdbeSorterClose(p
->db
, pCx
);
1775 sqlite3BtreeClose(pCx
->pBt
);
1776 /* The pCx->pCursor will be close automatically, if it exists, by
1777 ** the call above. */
1778 }else if( pCx
->pCursor
){
1779 sqlite3BtreeCloseCursor(pCx
->pCursor
);
1781 #ifndef SQLITE_OMIT_VIRTUALTABLE
1782 else if( pCx
->pVtabCursor
){
1783 sqlite3_vtab_cursor
*pVtabCursor
= pCx
->pVtabCursor
;
1784 const sqlite3_module
*pModule
= pVtabCursor
->pVtab
->pModule
;
1785 p
->inVtabMethod
= 1;
1786 pModule
->xClose(pVtabCursor
);
1787 p
->inVtabMethod
= 0;
1793 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
1794 ** is used, for example, when a trigger sub-program is halted to restore
1795 ** control to the main program.
1797 int sqlite3VdbeFrameRestore(VdbeFrame
*pFrame
){
1798 Vdbe
*v
= pFrame
->v
;
1799 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
1800 v
->anExec
= pFrame
->anExec
;
1802 v
->aOnceFlag
= pFrame
->aOnceFlag
;
1803 v
->nOnceFlag
= pFrame
->nOnceFlag
;
1804 v
->aOp
= pFrame
->aOp
;
1805 v
->nOp
= pFrame
->nOp
;
1806 v
->aMem
= pFrame
->aMem
;
1807 v
->nMem
= pFrame
->nMem
;
1808 v
->apCsr
= pFrame
->apCsr
;
1809 v
->nCursor
= pFrame
->nCursor
;
1810 v
->db
->lastRowid
= pFrame
->lastRowid
;
1811 v
->nChange
= pFrame
->nChange
;
1812 v
->db
->nChange
= pFrame
->nDbChange
;
1817 ** Close all cursors.
1819 ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory
1820 ** cell array. This is necessary as the memory cell array may contain
1821 ** pointers to VdbeFrame objects, which may in turn contain pointers to
1824 static void closeAllCursors(Vdbe
*p
){
1827 for(pFrame
=p
->pFrame
; pFrame
->pParent
; pFrame
=pFrame
->pParent
);
1828 sqlite3VdbeFrameRestore(pFrame
);
1832 assert( p
->nFrame
==0 );
1836 for(i
=0; i
<p
->nCursor
; i
++){
1837 VdbeCursor
*pC
= p
->apCsr
[i
];
1839 sqlite3VdbeFreeCursor(p
, pC
);
1845 releaseMemArray(&p
->aMem
[1], p
->nMem
);
1847 while( p
->pDelFrame
){
1848 VdbeFrame
*pDel
= p
->pDelFrame
;
1849 p
->pDelFrame
= pDel
->pParent
;
1850 sqlite3VdbeFrameDelete(pDel
);
1853 /* Delete any auxdata allocations made by the VM */
1854 if( p
->pAuxData
) sqlite3VdbeDeleteAuxData(p
, -1, 0);
1855 assert( p
->pAuxData
==0 );
1859 ** Clean up the VM after a single run.
1861 static void Cleanup(Vdbe
*p
){
1862 sqlite3
*db
= p
->db
;
1865 /* Execute assert() statements to ensure that the Vdbe.apCsr[] and
1866 ** Vdbe.aMem[] arrays have already been cleaned up. */
1868 if( p
->apCsr
) for(i
=0; i
<p
->nCursor
; i
++) assert( p
->apCsr
[i
]==0 );
1870 for(i
=1; i
<=p
->nMem
; i
++) assert( p
->aMem
[i
].flags
==MEM_Undefined
);
1874 sqlite3DbFree(db
, p
->zErrMsg
);
1880 ** Set the number of result columns that will be returned by this SQL
1881 ** statement. This is now set at compile time, rather than during
1882 ** execution of the vdbe program so that sqlite3_column_count() can
1883 ** be called on an SQL statement before sqlite3_step().
1885 void sqlite3VdbeSetNumCols(Vdbe
*p
, int nResColumn
){
1888 sqlite3
*db
= p
->db
;
1890 releaseMemArray(p
->aColName
, p
->nResColumn
*COLNAME_N
);
1891 sqlite3DbFree(db
, p
->aColName
);
1892 n
= nResColumn
*COLNAME_N
;
1893 p
->nResColumn
= (u16
)nResColumn
;
1894 p
->aColName
= pColName
= (Mem
*)sqlite3DbMallocZero(db
, sizeof(Mem
)*n
);
1895 if( p
->aColName
==0 ) return;
1897 pColName
->flags
= MEM_Null
;
1898 pColName
->db
= p
->db
;
1904 ** Set the name of the idx'th column to be returned by the SQL statement.
1905 ** zName must be a pointer to a nul terminated string.
1907 ** This call must be made after a call to sqlite3VdbeSetNumCols().
1909 ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
1910 ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
1911 ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
1913 int sqlite3VdbeSetColName(
1914 Vdbe
*p
, /* Vdbe being configured */
1915 int idx
, /* Index of column zName applies to */
1916 int var
, /* One of the COLNAME_* constants */
1917 const char *zName
, /* Pointer to buffer containing name */
1918 void (*xDel
)(void*) /* Memory management strategy for zName */
1922 assert( idx
<p
->nResColumn
);
1923 assert( var
<COLNAME_N
);
1924 if( p
->db
->mallocFailed
){
1925 assert( !zName
|| xDel
!=SQLITE_DYNAMIC
);
1926 return SQLITE_NOMEM
;
1928 assert( p
->aColName
!=0 );
1929 pColName
= &(p
->aColName
[idx
+var
*p
->nResColumn
]);
1930 rc
= sqlite3VdbeMemSetStr(pColName
, zName
, -1, SQLITE_UTF8
, xDel
);
1931 assert( rc
!=0 || !zName
|| (pColName
->flags
&MEM_Term
)!=0 );
1936 ** A read or write transaction may or may not be active on database handle
1937 ** db. If a transaction is active, commit it. If there is a
1938 ** write-transaction spanning more than one database file, this routine
1939 ** takes care of the master journal trickery.
1941 static int vdbeCommit(sqlite3
*db
, Vdbe
*p
){
1943 int nTrans
= 0; /* Number of databases with an active write-transaction */
1945 int needXcommit
= 0;
1947 #ifdef SQLITE_OMIT_VIRTUALTABLE
1948 /* With this option, sqlite3VtabSync() is defined to be simply
1949 ** SQLITE_OK so p is not used.
1951 UNUSED_PARAMETER(p
);
1954 /* Before doing anything else, call the xSync() callback for any
1955 ** virtual module tables written in this transaction. This has to
1956 ** be done before determining whether a master journal file is
1957 ** required, as an xSync() callback may add an attached database
1958 ** to the transaction.
1960 rc
= sqlite3VtabSync(db
, p
);
1962 /* This loop determines (a) if the commit hook should be invoked and
1963 ** (b) how many database files have open write transactions, not
1964 ** including the temp database. (b) is important because if more than
1965 ** one database file has an open write transaction, a master journal
1966 ** file is required for an atomic commit.
1968 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
1969 Btree
*pBt
= db
->aDb
[i
].pBt
;
1970 if( sqlite3BtreeIsInTrans(pBt
) ){
1972 if( i
!=1 ) nTrans
++;
1973 sqlite3BtreeEnter(pBt
);
1974 rc
= sqlite3PagerExclusiveLock(sqlite3BtreePager(pBt
));
1975 sqlite3BtreeLeave(pBt
);
1978 if( rc
!=SQLITE_OK
){
1982 /* If there are any write-transactions at all, invoke the commit hook */
1983 if( needXcommit
&& db
->xCommitCallback
){
1984 rc
= db
->xCommitCallback(db
->pCommitArg
);
1986 return SQLITE_CONSTRAINT_COMMITHOOK
;
1990 /* The simple case - no more than one database file (not counting the
1991 ** TEMP database) has a transaction active. There is no need for the
1994 ** If the return value of sqlite3BtreeGetFilename() is a zero length
1995 ** string, it means the main database is :memory: or a temp file. In
1996 ** that case we do not support atomic multi-file commits, so use the
1997 ** simple case then too.
1999 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db
->aDb
[0].pBt
))
2002 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2003 Btree
*pBt
= db
->aDb
[i
].pBt
;
2005 rc
= sqlite3BtreeCommitPhaseOne(pBt
, 0);
2009 /* Do the commit only if all databases successfully complete phase 1.
2010 ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
2011 ** IO error while deleting or truncating a journal file. It is unlikely,
2012 ** but could happen. In this case abandon processing and return the error.
2014 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2015 Btree
*pBt
= db
->aDb
[i
].pBt
;
2017 rc
= sqlite3BtreeCommitPhaseTwo(pBt
, 0);
2020 if( rc
==SQLITE_OK
){
2021 sqlite3VtabCommit(db
);
2025 /* The complex case - There is a multi-file write-transaction active.
2026 ** This requires a master journal file to ensure the transaction is
2027 ** committed atomically.
2029 #ifndef SQLITE_OMIT_DISKIO
2031 sqlite3_vfs
*pVfs
= db
->pVfs
;
2033 char *zMaster
= 0; /* File-name for the master journal */
2034 char const *zMainFile
= sqlite3BtreeGetFilename(db
->aDb
[0].pBt
);
2035 sqlite3_file
*pMaster
= 0;
2041 /* Select a master journal file name */
2042 nMainFile
= sqlite3Strlen30(zMainFile
);
2043 zMaster
= sqlite3MPrintf(db
, "%s-mjXXXXXX9XXz", zMainFile
);
2044 if( zMaster
==0 ) return SQLITE_NOMEM
;
2048 if( retryCount
>100 ){
2049 sqlite3_log(SQLITE_FULL
, "MJ delete: %s", zMaster
);
2050 sqlite3OsDelete(pVfs
, zMaster
, 0);
2052 }else if( retryCount
==1 ){
2053 sqlite3_log(SQLITE_FULL
, "MJ collide: %s", zMaster
);
2057 sqlite3_randomness(sizeof(iRandom
), &iRandom
);
2058 sqlite3_snprintf(13, &zMaster
[nMainFile
], "-mj%06X9%02X",
2059 (iRandom
>>8)&0xffffff, iRandom
&0xff);
2060 /* The antipenultimate character of the master journal name must
2061 ** be "9" to avoid name collisions when using 8+3 filenames. */
2062 assert( zMaster
[sqlite3Strlen30(zMaster
)-3]=='9' );
2063 sqlite3FileSuffix3(zMainFile
, zMaster
);
2064 rc
= sqlite3OsAccess(pVfs
, zMaster
, SQLITE_ACCESS_EXISTS
, &res
);
2065 }while( rc
==SQLITE_OK
&& res
);
2066 if( rc
==SQLITE_OK
){
2067 /* Open the master journal. */
2068 rc
= sqlite3OsOpenMalloc(pVfs
, zMaster
, &pMaster
,
2069 SQLITE_OPEN_READWRITE
|SQLITE_OPEN_CREATE
|
2070 SQLITE_OPEN_EXCLUSIVE
|SQLITE_OPEN_MASTER_JOURNAL
, 0
2073 if( rc
!=SQLITE_OK
){
2074 sqlite3DbFree(db
, zMaster
);
2078 /* Write the name of each database file in the transaction into the new
2079 ** master journal file. If an error occurs at this point close
2080 ** and delete the master journal file. All the individual journal files
2081 ** still have 'null' as the master journal pointer, so they will roll
2082 ** back independently if a failure occurs.
2084 for(i
=0; i
<db
->nDb
; i
++){
2085 Btree
*pBt
= db
->aDb
[i
].pBt
;
2086 if( sqlite3BtreeIsInTrans(pBt
) ){
2087 char const *zFile
= sqlite3BtreeGetJournalname(pBt
);
2089 continue; /* Ignore TEMP and :memory: databases */
2091 assert( zFile
[0]!=0 );
2092 if( !needSync
&& !sqlite3BtreeSyncDisabled(pBt
) ){
2095 rc
= sqlite3OsWrite(pMaster
, zFile
, sqlite3Strlen30(zFile
)+1, offset
);
2096 offset
+= sqlite3Strlen30(zFile
)+1;
2097 if( rc
!=SQLITE_OK
){
2098 sqlite3OsCloseFree(pMaster
);
2099 sqlite3OsDelete(pVfs
, zMaster
, 0);
2100 sqlite3DbFree(db
, zMaster
);
2106 /* Sync the master journal file. If the IOCAP_SEQUENTIAL device
2107 ** flag is set this is not required.
2110 && 0==(sqlite3OsDeviceCharacteristics(pMaster
)&SQLITE_IOCAP_SEQUENTIAL
)
2111 && SQLITE_OK
!=(rc
= sqlite3OsSync(pMaster
, SQLITE_SYNC_NORMAL
))
2113 sqlite3OsCloseFree(pMaster
);
2114 sqlite3OsDelete(pVfs
, zMaster
, 0);
2115 sqlite3DbFree(db
, zMaster
);
2119 /* Sync all the db files involved in the transaction. The same call
2120 ** sets the master journal pointer in each individual journal. If
2121 ** an error occurs here, do not delete the master journal file.
2123 ** If the error occurs during the first call to
2124 ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
2125 ** master journal file will be orphaned. But we cannot delete it,
2126 ** in case the master journal file name was written into the journal
2127 ** file before the failure occurred.
2129 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
2130 Btree
*pBt
= db
->aDb
[i
].pBt
;
2132 rc
= sqlite3BtreeCommitPhaseOne(pBt
, zMaster
);
2135 sqlite3OsCloseFree(pMaster
);
2136 assert( rc
!=SQLITE_BUSY
);
2137 if( rc
!=SQLITE_OK
){
2138 sqlite3DbFree(db
, zMaster
);
2142 /* Delete the master journal file. This commits the transaction. After
2143 ** doing this the directory is synced again before any individual
2144 ** transaction files are deleted.
2146 rc
= sqlite3OsDelete(pVfs
, zMaster
, 1);
2147 sqlite3DbFree(db
, zMaster
);
2153 /* All files and directories have already been synced, so the following
2154 ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
2155 ** deleting or truncating journals. If something goes wrong while
2156 ** this is happening we don't really care. The integrity of the
2157 ** transaction is already guaranteed, but some stray 'cold' journals
2158 ** may be lying around. Returning an error code won't help matters.
2160 disable_simulated_io_errors();
2161 sqlite3BeginBenignMalloc();
2162 for(i
=0; i
<db
->nDb
; i
++){
2163 Btree
*pBt
= db
->aDb
[i
].pBt
;
2165 sqlite3BtreeCommitPhaseTwo(pBt
, 1);
2168 sqlite3EndBenignMalloc();
2169 enable_simulated_io_errors();
2171 sqlite3VtabCommit(db
);
2179 ** This routine checks that the sqlite3.nVdbeActive count variable
2180 ** matches the number of vdbe's in the list sqlite3.pVdbe that are
2181 ** currently active. An assertion fails if the two counts do not match.
2182 ** This is an internal self-check only - it is not an essential processing
2185 ** This is a no-op if NDEBUG is defined.
2188 static void checkActiveVdbeCnt(sqlite3
*db
){
2195 if( sqlite3_stmt_busy((sqlite3_stmt
*)p
) ){
2197 if( p
->readOnly
==0 ) nWrite
++;
2198 if( p
->bIsReader
) nRead
++;
2202 assert( cnt
==db
->nVdbeActive
);
2203 assert( nWrite
==db
->nVdbeWrite
);
2204 assert( nRead
==db
->nVdbeRead
);
2207 #define checkActiveVdbeCnt(x)
2211 ** If the Vdbe passed as the first argument opened a statement-transaction,
2212 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
2213 ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
2214 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
2215 ** statement transaction is committed.
2217 ** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned.
2218 ** Otherwise SQLITE_OK.
2220 int sqlite3VdbeCloseStatement(Vdbe
*p
, int eOp
){
2221 sqlite3
*const db
= p
->db
;
2224 /* If p->iStatement is greater than zero, then this Vdbe opened a
2225 ** statement transaction that should be closed here. The only exception
2226 ** is that an IO error may have occurred, causing an emergency rollback.
2227 ** In this case (db->nStatement==0), and there is nothing to do.
2229 if( db
->nStatement
&& p
->iStatement
){
2231 const int iSavepoint
= p
->iStatement
-1;
2233 assert( eOp
==SAVEPOINT_ROLLBACK
|| eOp
==SAVEPOINT_RELEASE
);
2234 assert( db
->nStatement
>0 );
2235 assert( p
->iStatement
==(db
->nStatement
+db
->nSavepoint
) );
2237 for(i
=0; i
<db
->nDb
; i
++){
2238 int rc2
= SQLITE_OK
;
2239 Btree
*pBt
= db
->aDb
[i
].pBt
;
2241 if( eOp
==SAVEPOINT_ROLLBACK
){
2242 rc2
= sqlite3BtreeSavepoint(pBt
, SAVEPOINT_ROLLBACK
, iSavepoint
);
2244 if( rc2
==SQLITE_OK
){
2245 rc2
= sqlite3BtreeSavepoint(pBt
, SAVEPOINT_RELEASE
, iSavepoint
);
2247 if( rc
==SQLITE_OK
){
2255 if( rc
==SQLITE_OK
){
2256 if( eOp
==SAVEPOINT_ROLLBACK
){
2257 rc
= sqlite3VtabSavepoint(db
, SAVEPOINT_ROLLBACK
, iSavepoint
);
2259 if( rc
==SQLITE_OK
){
2260 rc
= sqlite3VtabSavepoint(db
, SAVEPOINT_RELEASE
, iSavepoint
);
2264 /* If the statement transaction is being rolled back, also restore the
2265 ** database handles deferred constraint counter to the value it had when
2266 ** the statement transaction was opened. */
2267 if( eOp
==SAVEPOINT_ROLLBACK
){
2268 db
->nDeferredCons
= p
->nStmtDefCons
;
2269 db
->nDeferredImmCons
= p
->nStmtDefImmCons
;
2276 ** This function is called when a transaction opened by the database
2277 ** handle associated with the VM passed as an argument is about to be
2278 ** committed. If there are outstanding deferred foreign key constraint
2279 ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
2281 ** If there are outstanding FK violations and this function returns
2282 ** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY
2283 ** and write an error message to it. Then return SQLITE_ERROR.
2285 #ifndef SQLITE_OMIT_FOREIGN_KEY
2286 int sqlite3VdbeCheckFk(Vdbe
*p
, int deferred
){
2287 sqlite3
*db
= p
->db
;
2288 if( (deferred
&& (db
->nDeferredCons
+db
->nDeferredImmCons
)>0)
2289 || (!deferred
&& p
->nFkConstraint
>0)
2291 p
->rc
= SQLITE_CONSTRAINT_FOREIGNKEY
;
2292 p
->errorAction
= OE_Abort
;
2293 sqlite3SetString(&p
->zErrMsg
, db
, "FOREIGN KEY constraint failed");
2294 return SQLITE_ERROR
;
2301 ** This routine is called the when a VDBE tries to halt. If the VDBE
2302 ** has made changes and is in autocommit mode, then commit those
2303 ** changes. If a rollback is needed, then do the rollback.
2305 ** This routine is the only way to move the state of a VM from
2306 ** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to
2307 ** call this on a VM that is in the SQLITE_MAGIC_HALT state.
2309 ** Return an error code. If the commit could not complete because of
2310 ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it
2311 ** means the close did not happen and needs to be repeated.
2313 int sqlite3VdbeHalt(Vdbe
*p
){
2314 int rc
; /* Used to store transient return codes */
2315 sqlite3
*db
= p
->db
;
2317 /* This function contains the logic that determines if a statement or
2318 ** transaction will be committed or rolled back as a result of the
2319 ** execution of this virtual machine.
2321 ** If any of the following errors occur:
2328 ** Then the internal cache might have been left in an inconsistent
2329 ** state. We need to rollback the statement transaction, if there is
2330 ** one, or the complete transaction if there is no statement transaction.
2333 if( p
->db
->mallocFailed
){
2334 p
->rc
= SQLITE_NOMEM
;
2336 if( p
->aOnceFlag
) memset(p
->aOnceFlag
, 0, p
->nOnceFlag
);
2338 if( p
->magic
!=VDBE_MAGIC_RUN
){
2341 checkActiveVdbeCnt(db
);
2343 /* No commit or rollback needed if the program never started or if the
2344 ** SQL statement does not read or write a database file. */
2345 if( p
->pc
>=0 && p
->bIsReader
){
2346 int mrc
; /* Primary error code from p->rc */
2347 int eStatementOp
= 0;
2348 int isSpecialError
; /* Set to true if a 'special' error */
2350 /* Lock all btrees used by the statement */
2351 sqlite3VdbeEnter(p
);
2353 /* Check for one of the special errors */
2355 isSpecialError
= mrc
==SQLITE_NOMEM
|| mrc
==SQLITE_IOERR
2356 || mrc
==SQLITE_INTERRUPT
|| mrc
==SQLITE_FULL
;
2357 if( isSpecialError
){
2358 /* If the query was read-only and the error code is SQLITE_INTERRUPT,
2359 ** no rollback is necessary. Otherwise, at least a savepoint
2360 ** transaction must be rolled back to restore the database to a
2361 ** consistent state.
2363 ** Even if the statement is read-only, it is important to perform
2364 ** a statement or transaction rollback operation. If the error
2365 ** occurred while writing to the journal, sub-journal or database
2366 ** file as part of an effort to free up cache space (see function
2367 ** pagerStress() in pager.c), the rollback is required to restore
2368 ** the pager to a consistent state.
2370 if( !p
->readOnly
|| mrc
!=SQLITE_INTERRUPT
){
2371 if( (mrc
==SQLITE_NOMEM
|| mrc
==SQLITE_FULL
) && p
->usesStmtJournal
){
2372 eStatementOp
= SAVEPOINT_ROLLBACK
;
2374 /* We are forced to roll back the active transaction. Before doing
2375 ** so, abort any other statements this handle currently has active.
2377 sqlite3RollbackAll(db
, SQLITE_ABORT_ROLLBACK
);
2378 sqlite3CloseSavepoints(db
);
2385 /* Check for immediate foreign key violations. */
2386 if( p
->rc
==SQLITE_OK
){
2387 sqlite3VdbeCheckFk(p
, 0);
2390 /* If the auto-commit flag is set and this is the only active writer
2391 ** VM, then we do either a commit or rollback of the current transaction.
2393 ** Note: This block also runs if one of the special errors handled
2394 ** above has occurred.
2396 if( !sqlite3VtabInSync(db
)
2398 && db
->nVdbeWrite
==(p
->readOnly
==0)
2400 if( p
->rc
==SQLITE_OK
|| (p
->errorAction
==OE_Fail
&& !isSpecialError
) ){
2401 rc
= sqlite3VdbeCheckFk(p
, 1);
2402 if( rc
!=SQLITE_OK
){
2403 if( NEVER(p
->readOnly
) ){
2404 sqlite3VdbeLeave(p
);
2405 return SQLITE_ERROR
;
2407 rc
= SQLITE_CONSTRAINT_FOREIGNKEY
;
2409 /* The auto-commit flag is true, the vdbe program was successful
2410 ** or hit an 'OR FAIL' constraint and there are no deferred foreign
2411 ** key constraints to hold up the transaction. This means a commit
2413 rc
= vdbeCommit(db
, p
);
2415 if( rc
==SQLITE_BUSY
&& p
->readOnly
){
2416 sqlite3VdbeLeave(p
);
2418 }else if( rc
!=SQLITE_OK
){
2420 sqlite3RollbackAll(db
, SQLITE_OK
);
2423 db
->nDeferredCons
= 0;
2424 db
->nDeferredImmCons
= 0;
2425 db
->flags
&= ~SQLITE_DeferFKs
;
2426 sqlite3CommitInternalChanges(db
);
2429 sqlite3RollbackAll(db
, SQLITE_OK
);
2433 }else if( eStatementOp
==0 ){
2434 if( p
->rc
==SQLITE_OK
|| p
->errorAction
==OE_Fail
){
2435 eStatementOp
= SAVEPOINT_RELEASE
;
2436 }else if( p
->errorAction
==OE_Abort
){
2437 eStatementOp
= SAVEPOINT_ROLLBACK
;
2439 sqlite3RollbackAll(db
, SQLITE_ABORT_ROLLBACK
);
2440 sqlite3CloseSavepoints(db
);
2446 /* If eStatementOp is non-zero, then a statement transaction needs to
2447 ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to
2448 ** do so. If this operation returns an error, and the current statement
2449 ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
2450 ** current statement error code.
2453 rc
= sqlite3VdbeCloseStatement(p
, eStatementOp
);
2455 if( p
->rc
==SQLITE_OK
|| (p
->rc
&0xff)==SQLITE_CONSTRAINT
){
2457 sqlite3DbFree(db
, p
->zErrMsg
);
2460 sqlite3RollbackAll(db
, SQLITE_ABORT_ROLLBACK
);
2461 sqlite3CloseSavepoints(db
);
2467 /* If this was an INSERT, UPDATE or DELETE and no statement transaction
2468 ** has been rolled back, update the database connection change-counter.
2470 if( p
->changeCntOn
){
2471 if( eStatementOp
!=SAVEPOINT_ROLLBACK
){
2472 sqlite3VdbeSetChanges(db
, p
->nChange
);
2474 sqlite3VdbeSetChanges(db
, 0);
2479 /* Release the locks */
2480 sqlite3VdbeLeave(p
);
2483 /* We have successfully halted and closed the VM. Record this fact. */
2486 if( !p
->readOnly
) db
->nVdbeWrite
--;
2487 if( p
->bIsReader
) db
->nVdbeRead
--;
2488 assert( db
->nVdbeActive
>=db
->nVdbeRead
);
2489 assert( db
->nVdbeRead
>=db
->nVdbeWrite
);
2490 assert( db
->nVdbeWrite
>=0 );
2492 p
->magic
= VDBE_MAGIC_HALT
;
2493 checkActiveVdbeCnt(db
);
2494 if( p
->db
->mallocFailed
){
2495 p
->rc
= SQLITE_NOMEM
;
2498 /* If the auto-commit flag is set to true, then any locks that were held
2499 ** by connection db have now been released. Call sqlite3ConnectionUnlocked()
2500 ** to invoke any required unlock-notify callbacks.
2502 if( db
->autoCommit
){
2503 sqlite3ConnectionUnlocked(db
);
2506 assert( db
->nVdbeActive
>0 || db
->autoCommit
==0 || db
->nStatement
==0 );
2507 return (p
->rc
==SQLITE_BUSY
? SQLITE_BUSY
: SQLITE_OK
);
2512 ** Each VDBE holds the result of the most recent sqlite3_step() call
2513 ** in p->rc. This routine sets that result back to SQLITE_OK.
2515 void sqlite3VdbeResetStepResult(Vdbe
*p
){
2520 ** Copy the error code and error message belonging to the VDBE passed
2521 ** as the first argument to its database handle (so that they will be
2522 ** returned by calls to sqlite3_errcode() and sqlite3_errmsg()).
2524 ** This function does not clear the VDBE error code or message, just
2525 ** copies them to the database handle.
2527 int sqlite3VdbeTransferError(Vdbe
*p
){
2528 sqlite3
*db
= p
->db
;
2531 u8 mallocFailed
= db
->mallocFailed
;
2532 sqlite3BeginBenignMalloc();
2533 if( db
->pErr
==0 ) db
->pErr
= sqlite3ValueNew(db
);
2534 sqlite3ValueSetStr(db
->pErr
, -1, p
->zErrMsg
, SQLITE_UTF8
, SQLITE_TRANSIENT
);
2535 sqlite3EndBenignMalloc();
2536 db
->mallocFailed
= mallocFailed
;
2539 sqlite3Error(db
, rc
);
2544 #ifdef SQLITE_ENABLE_SQLLOG
2546 ** If an SQLITE_CONFIG_SQLLOG hook is registered and the VM has been run,
2549 static void vdbeInvokeSqllog(Vdbe
*v
){
2550 if( sqlite3GlobalConfig
.xSqllog
&& v
->rc
==SQLITE_OK
&& v
->zSql
&& v
->pc
>=0 ){
2551 char *zExpanded
= sqlite3VdbeExpandSql(v
, v
->zSql
);
2552 assert( v
->db
->init
.busy
==0 );
2554 sqlite3GlobalConfig
.xSqllog(
2555 sqlite3GlobalConfig
.pSqllogArg
, v
->db
, zExpanded
, 1
2557 sqlite3DbFree(v
->db
, zExpanded
);
2562 # define vdbeInvokeSqllog(x)
2566 ** Clean up a VDBE after execution but do not delete the VDBE just yet.
2567 ** Write any error messages into *pzErrMsg. Return the result code.
2569 ** After this routine is run, the VDBE should be ready to be executed
2572 ** To look at it another way, this routine resets the state of the
2573 ** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to
2576 int sqlite3VdbeReset(Vdbe
*p
){
2580 /* If the VM did not run to completion or if it encountered an
2581 ** error, then it might not have been halted properly. So halt
2586 /* If the VDBE has be run even partially, then transfer the error code
2587 ** and error message from the VDBE into the main database structure. But
2588 ** if the VDBE has just been set to run but has not actually executed any
2589 ** instructions yet, leave the main database error information unchanged.
2592 vdbeInvokeSqllog(p
);
2593 sqlite3VdbeTransferError(p
);
2594 sqlite3DbFree(db
, p
->zErrMsg
);
2596 if( p
->runOnlyOnce
) p
->expired
= 1;
2597 }else if( p
->rc
&& p
->expired
){
2598 /* The expired flag was set on the VDBE before the first call
2599 ** to sqlite3_step(). For consistency (since sqlite3_step() was
2600 ** called), set the database error in this case as well.
2602 sqlite3ErrorWithMsg(db
, p
->rc
, p
->zErrMsg
? "%s" : 0, p
->zErrMsg
);
2603 sqlite3DbFree(db
, p
->zErrMsg
);
2607 /* Reclaim all memory used by the VDBE
2611 /* Save profiling information from this VDBE run.
2615 FILE *out
= fopen("vdbe_profile.out", "a");
2618 fprintf(out
, "---- ");
2619 for(i
=0; i
<p
->nOp
; i
++){
2620 fprintf(out
, "%02x", p
->aOp
[i
].opcode
);
2625 fprintf(out
, "-- ");
2626 for(i
=0; (c
= p
->zSql
[i
])!=0; i
++){
2627 if( pc
=='\n' ) fprintf(out
, "-- ");
2631 if( pc
!='\n' ) fprintf(out
, "\n");
2633 for(i
=0; i
<p
->nOp
; i
++){
2635 sqlite3_snprintf(sizeof(zHdr
), zHdr
, "%6u %12llu %8llu ",
2638 p
->aOp
[i
].cnt
>0 ? p
->aOp
[i
].cycles
/p
->aOp
[i
].cnt
: 0
2640 fprintf(out
, "%s", zHdr
);
2641 sqlite3VdbePrintOp(out
, i
, &p
->aOp
[i
]);
2647 p
->iCurrentTime
= 0;
2648 p
->magic
= VDBE_MAGIC_INIT
;
2649 return p
->rc
& db
->errMask
;
2653 ** Clean up and delete a VDBE after execution. Return an integer which is
2654 ** the result code. Write any error message text into *pzErrMsg.
2656 int sqlite3VdbeFinalize(Vdbe
*p
){
2658 if( p
->magic
==VDBE_MAGIC_RUN
|| p
->magic
==VDBE_MAGIC_HALT
){
2659 rc
= sqlite3VdbeReset(p
);
2660 assert( (rc
& p
->db
->errMask
)==rc
);
2662 sqlite3VdbeDelete(p
);
2667 ** If parameter iOp is less than zero, then invoke the destructor for
2668 ** all auxiliary data pointers currently cached by the VM passed as
2669 ** the first argument.
2671 ** Or, if iOp is greater than or equal to zero, then the destructor is
2672 ** only invoked for those auxiliary data pointers created by the user
2673 ** function invoked by the OP_Function opcode at instruction iOp of
2674 ** VM pVdbe, and only then if:
2676 ** * the associated function parameter is the 32nd or later (counting
2677 ** from left to right), or
2679 ** * the corresponding bit in argument mask is clear (where the first
2680 ** function parameter corresponds to bit 0 etc.).
2682 void sqlite3VdbeDeleteAuxData(Vdbe
*pVdbe
, int iOp
, int mask
){
2683 AuxData
**pp
= &pVdbe
->pAuxData
;
2685 AuxData
*pAux
= *pp
;
2687 || (pAux
->iOp
==iOp
&& (pAux
->iArg
>31 || !(mask
& MASKBIT32(pAux
->iArg
))))
2689 testcase( pAux
->iArg
==31 );
2690 if( pAux
->xDelete
){
2691 pAux
->xDelete(pAux
->pAux
);
2694 sqlite3DbFree(pVdbe
->db
, pAux
);
2702 ** Free all memory associated with the Vdbe passed as the second argument,
2703 ** except for object itself, which is preserved.
2705 ** The difference between this function and sqlite3VdbeDelete() is that
2706 ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
2707 ** the database connection and frees the object itself.
2709 void sqlite3VdbeClearObject(sqlite3
*db
, Vdbe
*p
){
2710 SubProgram
*pSub
, *pNext
;
2712 assert( p
->db
==0 || p
->db
==db
);
2713 releaseMemArray(p
->aVar
, p
->nVar
);
2714 releaseMemArray(p
->aColName
, p
->nResColumn
*COLNAME_N
);
2715 for(pSub
=p
->pProgram
; pSub
; pSub
=pNext
){
2716 pNext
= pSub
->pNext
;
2717 vdbeFreeOpArray(db
, pSub
->aOp
, pSub
->nOp
);
2718 sqlite3DbFree(db
, pSub
);
2720 for(i
=p
->nzVar
-1; i
>=0; i
--) sqlite3DbFree(db
, p
->azVar
[i
]);
2721 vdbeFreeOpArray(db
, p
->aOp
, p
->nOp
);
2722 sqlite3DbFree(db
, p
->aColName
);
2723 sqlite3DbFree(db
, p
->zSql
);
2724 sqlite3DbFree(db
, p
->pFree
);
2725 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
2726 for(i
=0; i
<p
->nScan
; i
++){
2727 sqlite3DbFree(db
, p
->aScan
[i
].zName
);
2729 sqlite3DbFree(db
, p
->aScan
);
2734 ** Delete an entire VDBE.
2736 void sqlite3VdbeDelete(Vdbe
*p
){
2739 if( NEVER(p
==0) ) return;
2741 assert( sqlite3_mutex_held(db
->mutex
) );
2742 sqlite3VdbeClearObject(db
, p
);
2744 p
->pPrev
->pNext
= p
->pNext
;
2746 assert( db
->pVdbe
==p
);
2747 db
->pVdbe
= p
->pNext
;
2750 p
->pNext
->pPrev
= p
->pPrev
;
2752 p
->magic
= VDBE_MAGIC_DEAD
;
2754 sqlite3DbFree(db
, p
);
2758 ** The cursor "p" has a pending seek operation that has not yet been
2759 ** carried out. Seek the cursor now. If an error occurs, return
2760 ** the appropriate error code.
2762 static int SQLITE_NOINLINE
handleDeferredMoveto(VdbeCursor
*p
){
2765 extern int sqlite3_search_count
;
2767 assert( p
->deferredMoveto
);
2768 assert( p
->isTable
);
2769 rc
= sqlite3BtreeMovetoUnpacked(p
->pCursor
, 0, p
->movetoTarget
, 0, &res
);
2771 if( res
!=0 ) return SQLITE_CORRUPT_BKPT
;
2773 sqlite3_search_count
++;
2775 p
->deferredMoveto
= 0;
2776 p
->cacheStatus
= CACHE_STALE
;
2781 ** Something has moved cursor "p" out of place. Maybe the row it was
2782 ** pointed to was deleted out from under it. Or maybe the btree was
2783 ** rebalanced. Whatever the cause, try to restore "p" to the place it
2784 ** is supposed to be pointing. If the row was deleted out from under the
2785 ** cursor, set the cursor to point to a NULL row.
2787 static int SQLITE_NOINLINE
handleMovedCursor(VdbeCursor
*p
){
2788 int isDifferentRow
, rc
;
2789 assert( p
->pCursor
!=0 );
2790 assert( sqlite3BtreeCursorHasMoved(p
->pCursor
) );
2791 rc
= sqlite3BtreeCursorRestore(p
->pCursor
, &isDifferentRow
);
2792 p
->cacheStatus
= CACHE_STALE
;
2793 if( isDifferentRow
) p
->nullRow
= 1;
2798 ** Check to ensure that the cursor is valid. Restore the cursor
2799 ** if need be. Return any I/O error from the restore operation.
2801 int sqlite3VdbeCursorRestore(VdbeCursor
*p
){
2802 if( sqlite3BtreeCursorHasMoved(p
->pCursor
) ){
2803 return handleMovedCursor(p
);
2809 ** Make sure the cursor p is ready to read or write the row to which it
2810 ** was last positioned. Return an error code if an OOM fault or I/O error
2811 ** prevents us from positioning the cursor to its correct position.
2813 ** If a MoveTo operation is pending on the given cursor, then do that
2814 ** MoveTo now. If no move is pending, check to see if the row has been
2815 ** deleted out from under the cursor and if it has, mark the row as
2818 ** If the cursor is already pointing to the correct row and that row has
2819 ** not been deleted out from under the cursor, then this routine is a no-op.
2821 int sqlite3VdbeCursorMoveto(VdbeCursor
*p
){
2822 if( p
->deferredMoveto
){
2823 return handleDeferredMoveto(p
);
2825 if( p
->pCursor
&& sqlite3BtreeCursorHasMoved(p
->pCursor
) ){
2826 return handleMovedCursor(p
);
2832 ** The following functions:
2834 ** sqlite3VdbeSerialType()
2835 ** sqlite3VdbeSerialTypeLen()
2836 ** sqlite3VdbeSerialLen()
2837 ** sqlite3VdbeSerialPut()
2838 ** sqlite3VdbeSerialGet()
2840 ** encapsulate the code that serializes values for storage in SQLite
2841 ** data and index records. Each serialized value consists of a
2842 ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
2843 ** integer, stored as a varint.
2845 ** In an SQLite index record, the serial type is stored directly before
2846 ** the blob of data that it corresponds to. In a table record, all serial
2847 ** types are stored at the start of the record, and the blobs of data at
2848 ** the end. Hence these functions allow the caller to handle the
2849 ** serial-type and data blob separately.
2851 ** The following table describes the various storage classes for data:
2853 ** serial type bytes of data type
2854 ** -------------- --------------- ---------------
2856 ** 1 1 signed integer
2857 ** 2 2 signed integer
2858 ** 3 3 signed integer
2859 ** 4 4 signed integer
2860 ** 5 6 signed integer
2861 ** 6 8 signed integer
2863 ** 8 0 Integer constant 0
2864 ** 9 0 Integer constant 1
2865 ** 10,11 reserved for expansion
2866 ** N>=12 and even (N-12)/2 BLOB
2867 ** N>=13 and odd (N-13)/2 text
2869 ** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions
2870 ** of SQLite will not understand those serial types.
2874 ** Return the serial-type for the value stored in pMem.
2876 u32
sqlite3VdbeSerialType(Mem
*pMem
, int file_format
){
2877 int flags
= pMem
->flags
;
2880 if( flags
&MEM_Null
){
2883 if( flags
&MEM_Int
){
2884 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
2885 # define MAX_6BYTE ((((i64)0x00008000)<<32)-1)
2894 return ((i
&1)==i
&& file_format
>=4) ? 8+(u32
)u
: 1;
2896 if( u
<=32767 ) return 2;
2897 if( u
<=8388607 ) return 3;
2898 if( u
<=2147483647 ) return 4;
2899 if( u
<=MAX_6BYTE
) return 5;
2902 if( flags
&MEM_Real
){
2905 assert( pMem
->db
->mallocFailed
|| flags
&(MEM_Str
|MEM_Blob
) );
2906 assert( pMem
->n
>=0 );
2908 if( flags
& MEM_Zero
){
2911 return ((n
*2) + 12 + ((flags
&MEM_Str
)!=0));
2915 ** Return the length of the data corresponding to the supplied serial-type.
2917 u32
sqlite3VdbeSerialTypeLen(u32 serial_type
){
2918 if( serial_type
>=12 ){
2919 return (serial_type
-12)/2;
2921 static const u8 aSize
[] = { 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0 };
2922 return aSize
[serial_type
];
2927 ** If we are on an architecture with mixed-endian floating
2928 ** points (ex: ARM7) then swap the lower 4 bytes with the
2929 ** upper 4 bytes. Return the result.
2931 ** For most architectures, this is a no-op.
2933 ** (later): It is reported to me that the mixed-endian problem
2934 ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
2935 ** that early versions of GCC stored the two words of a 64-bit
2936 ** float in the wrong order. And that error has been propagated
2937 ** ever since. The blame is not necessarily with GCC, though.
2938 ** GCC might have just copying the problem from a prior compiler.
2939 ** I am also told that newer versions of GCC that follow a different
2940 ** ABI get the byte order right.
2942 ** Developers using SQLite on an ARM7 should compile and run their
2943 ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
2944 ** enabled, some asserts below will ensure that the byte order of
2945 ** floating point values is correct.
2947 ** (2007-08-30) Frank van Vugt has studied this problem closely
2948 ** and has send his findings to the SQLite developers. Frank
2949 ** writes that some Linux kernels offer floating point hardware
2950 ** emulation that uses only 32-bit mantissas instead of a full
2951 ** 48-bits as required by the IEEE standard. (This is the
2952 ** CONFIG_FPE_FASTFPE option.) On such systems, floating point
2953 ** byte swapping becomes very complicated. To avoid problems,
2954 ** the necessary byte swapping is carried out using a 64-bit integer
2955 ** rather than a 64-bit float. Frank assures us that the code here
2956 ** works for him. We, the developers, have no way to independently
2957 ** verify this, but Frank seems to know what he is talking about
2960 #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
2961 static u64
floatSwap(u64 in
){
2974 # define swapMixedEndianFloat(X) X = floatSwap(X)
2976 # define swapMixedEndianFloat(X)
2980 ** Write the serialized data blob for the value stored in pMem into
2981 ** buf. It is assumed that the caller has allocated sufficient space.
2982 ** Return the number of bytes written.
2984 ** nBuf is the amount of space left in buf[]. The caller is responsible
2985 ** for allocating enough space to buf[] to hold the entire field, exclusive
2986 ** of the pMem->u.nZero bytes for a MEM_Zero value.
2988 ** Return the number of bytes actually written into buf[]. The number
2989 ** of bytes in the zero-filled tail is included in the return value only
2990 ** if those bytes were zeroed in buf[].
2992 u32
sqlite3VdbeSerialPut(u8
*buf
, Mem
*pMem
, u32 serial_type
){
2995 /* Integer and Real */
2996 if( serial_type
<=7 && serial_type
>0 ){
2999 if( serial_type
==7 ){
3000 assert( sizeof(v
)==sizeof(pMem
->u
.r
) );
3001 memcpy(&v
, &pMem
->u
.r
, sizeof(v
));
3002 swapMixedEndianFloat(v
);
3006 len
= i
= sqlite3VdbeSerialTypeLen(serial_type
);
3009 buf
[--i
] = (u8
)(v
&0xFF);
3015 /* String or blob */
3016 if( serial_type
>=12 ){
3017 assert( pMem
->n
+ ((pMem
->flags
& MEM_Zero
)?pMem
->u
.nZero
:0)
3018 == (int)sqlite3VdbeSerialTypeLen(serial_type
) );
3020 memcpy(buf
, pMem
->z
, len
);
3024 /* NULL or constants 0 or 1 */
3028 /* Input "x" is a sequence of unsigned characters that represent a
3029 ** big-endian integer. Return the equivalent native integer
3031 #define ONE_BYTE_INT(x) ((i8)(x)[0])
3032 #define TWO_BYTE_INT(x) (256*(i8)((x)[0])|(x)[1])
3033 #define THREE_BYTE_INT(x) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2])
3034 #define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
3035 #define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
3038 ** Deserialize the data blob pointed to by buf as serial type serial_type
3039 ** and store the result in pMem. Return the number of bytes read.
3041 ** This function is implemented as two separate routines for performance.
3042 ** The few cases that require local variables are broken out into a separate
3043 ** routine so that in most cases the overhead of moving the stack pointer
3046 static u32 SQLITE_NOINLINE
serialGet(
3047 const unsigned char *buf
, /* Buffer to deserialize from */
3048 u32 serial_type
, /* Serial type to deserialize */
3049 Mem
*pMem
/* Memory cell to write value into */
3051 u64 x
= FOUR_BYTE_UINT(buf
);
3052 u32 y
= FOUR_BYTE_UINT(buf
+4);
3054 if( serial_type
==6 ){
3055 /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit
3056 ** twos-complement integer. */
3057 pMem
->u
.i
= *(i64
*)&x
;
3058 pMem
->flags
= MEM_Int
;
3059 testcase( pMem
->u
.i
<0 );
3061 /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit
3062 ** floating point number. */
3063 #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
3064 /* Verify that integers and floating point values use the same
3065 ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
3066 ** defined that 64-bit floating point values really are mixed
3069 static const u64 t1
= ((u64
)0x3ff00000)<<32;
3070 static const double r1
= 1.0;
3072 swapMixedEndianFloat(t2
);
3073 assert( sizeof(r1
)==sizeof(t2
) && memcmp(&r1
, &t2
, sizeof(r1
))==0 );
3075 assert( sizeof(x
)==8 && sizeof(pMem
->u
.r
)==8 );
3076 swapMixedEndianFloat(x
);
3077 memcpy(&pMem
->u
.r
, &x
, sizeof(x
));
3078 pMem
->flags
= sqlite3IsNaN(pMem
->u
.r
) ? MEM_Null
: MEM_Real
;
3082 u32
sqlite3VdbeSerialGet(
3083 const unsigned char *buf
, /* Buffer to deserialize from */
3084 u32 serial_type
, /* Serial type to deserialize */
3085 Mem
*pMem
/* Memory cell to write value into */
3087 switch( serial_type
){
3088 case 10: /* Reserved for future use */
3089 case 11: /* Reserved for future use */
3090 case 0: { /* Null */
3091 /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */
3092 pMem
->flags
= MEM_Null
;
3096 /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement
3098 pMem
->u
.i
= ONE_BYTE_INT(buf
);
3099 pMem
->flags
= MEM_Int
;
3100 testcase( pMem
->u
.i
<0 );
3103 case 2: { /* 2-byte signed integer */
3104 /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit
3105 ** twos-complement integer. */
3106 pMem
->u
.i
= TWO_BYTE_INT(buf
);
3107 pMem
->flags
= MEM_Int
;
3108 testcase( pMem
->u
.i
<0 );
3111 case 3: { /* 3-byte signed integer */
3112 /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit
3113 ** twos-complement integer. */
3114 pMem
->u
.i
= THREE_BYTE_INT(buf
);
3115 pMem
->flags
= MEM_Int
;
3116 testcase( pMem
->u
.i
<0 );
3119 case 4: { /* 4-byte signed integer */
3120 /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit
3121 ** twos-complement integer. */
3122 pMem
->u
.i
= FOUR_BYTE_INT(buf
);
3123 pMem
->flags
= MEM_Int
;
3124 testcase( pMem
->u
.i
<0 );
3127 case 5: { /* 6-byte signed integer */
3128 /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit
3129 ** twos-complement integer. */
3130 pMem
->u
.i
= FOUR_BYTE_UINT(buf
+2) + (((i64
)1)<<32)*TWO_BYTE_INT(buf
);
3131 pMem
->flags
= MEM_Int
;
3132 testcase( pMem
->u
.i
<0 );
3135 case 6: /* 8-byte signed integer */
3136 case 7: { /* IEEE floating point */
3137 /* These use local variables, so do them in a separate routine
3138 ** to avoid having to move the frame pointer in the common case */
3139 return serialGet(buf
,serial_type
,pMem
);
3141 case 8: /* Integer 0 */
3142 case 9: { /* Integer 1 */
3143 /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */
3144 /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */
3145 pMem
->u
.i
= serial_type
-8;
3146 pMem
->flags
= MEM_Int
;
3150 /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in
3152 ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and
3153 ** (N-13)/2 bytes in length. */
3154 static const u16 aFlag
[] = { MEM_Blob
|MEM_Ephem
, MEM_Str
|MEM_Ephem
};
3155 pMem
->z
= (char *)buf
;
3156 pMem
->n
= (serial_type
-12)/2;
3157 pMem
->flags
= aFlag
[serial_type
&1];
3164 ** This routine is used to allocate sufficient space for an UnpackedRecord
3165 ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
3166 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
3168 ** The space is either allocated using sqlite3DbMallocRaw() or from within
3169 ** the unaligned buffer passed via the second and third arguments (presumably
3170 ** stack space). If the former, then *ppFree is set to a pointer that should
3171 ** be eventually freed by the caller using sqlite3DbFree(). Or, if the
3172 ** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL
3173 ** before returning.
3175 ** If an OOM error occurs, NULL is returned.
3177 UnpackedRecord
*sqlite3VdbeAllocUnpackedRecord(
3178 KeyInfo
*pKeyInfo
, /* Description of the record */
3179 char *pSpace
, /* Unaligned space available */
3180 int szSpace
, /* Size of pSpace[] in bytes */
3181 char **ppFree
/* OUT: Caller should free this pointer */
3183 UnpackedRecord
*p
; /* Unpacked record to return */
3184 int nOff
; /* Increment pSpace by nOff to align it */
3185 int nByte
; /* Number of bytes required for *p */
3187 /* We want to shift the pointer pSpace up such that it is 8-byte aligned.
3188 ** Thus, we need to calculate a value, nOff, between 0 and 7, to shift
3189 ** it by. If pSpace is already 8-byte aligned, nOff should be zero.
3191 nOff
= (8 - (SQLITE_PTR_TO_INT(pSpace
) & 7)) & 7;
3192 nByte
= ROUND8(sizeof(UnpackedRecord
)) + sizeof(Mem
)*(pKeyInfo
->nField
+1);
3193 if( nByte
>szSpace
+nOff
){
3194 p
= (UnpackedRecord
*)sqlite3DbMallocRaw(pKeyInfo
->db
, nByte
);
3195 *ppFree
= (char *)p
;
3198 p
= (UnpackedRecord
*)&pSpace
[nOff
];
3202 p
->aMem
= (Mem
*)&((char*)p
)[ROUND8(sizeof(UnpackedRecord
))];
3203 assert( pKeyInfo
->aSortOrder
!=0 );
3204 p
->pKeyInfo
= pKeyInfo
;
3205 p
->nField
= pKeyInfo
->nField
+ 1;
3210 ** Given the nKey-byte encoding of a record in pKey[], populate the
3211 ** UnpackedRecord structure indicated by the fourth argument with the
3212 ** contents of the decoded record.
3214 void sqlite3VdbeRecordUnpack(
3215 KeyInfo
*pKeyInfo
, /* Information about the record format */
3216 int nKey
, /* Size of the binary record */
3217 const void *pKey
, /* The binary record */
3218 UnpackedRecord
*p
/* Populate this structure before returning. */
3220 const unsigned char *aKey
= (const unsigned char *)pKey
;
3222 u32 idx
; /* Offset in aKey[] to read from */
3223 u16 u
; /* Unsigned loop counter */
3225 Mem
*pMem
= p
->aMem
;
3228 assert( EIGHT_BYTE_ALIGNMENT(pMem
) );
3229 idx
= getVarint32(aKey
, szHdr
);
3232 while( idx
<szHdr
&& d
<=nKey
){
3235 idx
+= getVarint32(&aKey
[idx
], serial_type
);
3236 pMem
->enc
= pKeyInfo
->enc
;
3237 pMem
->db
= pKeyInfo
->db
;
3238 /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
3240 d
+= sqlite3VdbeSerialGet(&aKey
[d
], serial_type
, pMem
);
3242 if( (++u
)>=p
->nField
) break;
3244 assert( u
<=pKeyInfo
->nField
+ 1 );
3250 ** This function compares two index or table record keys in the same way
3251 ** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(),
3252 ** this function deserializes and compares values using the
3253 ** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
3254 ** in assert() statements to ensure that the optimized code in
3255 ** sqlite3VdbeRecordCompare() returns results with these two primitives.
3257 ** Return true if the result of comparison is equivalent to desiredResult.
3258 ** Return false if there is a disagreement.
3260 static int vdbeRecordCompareDebug(
3261 int nKey1
, const void *pKey1
, /* Left key */
3262 const UnpackedRecord
*pPKey2
, /* Right key */
3263 int desiredResult
/* Correct answer */
3265 u32 d1
; /* Offset into aKey[] of next data element */
3266 u32 idx1
; /* Offset into aKey[] of next header element */
3267 u32 szHdr1
; /* Number of bytes in header */
3270 const unsigned char *aKey1
= (const unsigned char *)pKey1
;
3274 pKeyInfo
= pPKey2
->pKeyInfo
;
3275 if( pKeyInfo
->db
==0 ) return 1;
3276 mem1
.enc
= pKeyInfo
->enc
;
3277 mem1
.db
= pKeyInfo
->db
;
3278 /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */
3279 VVA_ONLY( mem1
.szMalloc
= 0; ) /* Only needed by assert() statements */
3281 /* Compilers may complain that mem1.u.i is potentially uninitialized.
3282 ** We could initialize it, as shown here, to silence those complaints.
3283 ** But in fact, mem1.u.i will never actually be used uninitialized, and doing
3284 ** the unnecessary initialization has a measurable negative performance
3285 ** impact, since this routine is a very high runner. And so, we choose
3286 ** to ignore the compiler warnings and leave this variable uninitialized.
3288 /* mem1.u.i = 0; // not needed, here to silence compiler warning */
3290 idx1
= getVarint32(aKey1
, szHdr1
);
3292 assert( pKeyInfo
->nField
+pKeyInfo
->nXField
>=pPKey2
->nField
|| CORRUPT_DB
);
3293 assert( pKeyInfo
->aSortOrder
!=0 );
3294 assert( pKeyInfo
->nField
>0 );
3295 assert( idx1
<=szHdr1
|| CORRUPT_DB
);
3299 /* Read the serial types for the next element in each key. */
3300 idx1
+= getVarint32( aKey1
+idx1
, serial_type1
);
3302 /* Verify that there is enough key space remaining to avoid
3303 ** a buffer overread. The "d1+serial_type1+2" subexpression will
3304 ** always be greater than or equal to the amount of required key space.
3305 ** Use that approximation to avoid the more expensive call to
3306 ** sqlite3VdbeSerialTypeLen() in the common case.
3308 if( d1
+serial_type1
+2>(u32
)nKey1
3309 && d1
+sqlite3VdbeSerialTypeLen(serial_type1
)>(u32
)nKey1
3314 /* Extract the values to be compared.
3316 d1
+= sqlite3VdbeSerialGet(&aKey1
[d1
], serial_type1
, &mem1
);
3318 /* Do the comparison
3320 rc
= sqlite3MemCompare(&mem1
, &pPKey2
->aMem
[i
], pKeyInfo
->aColl
[i
]);
3322 assert( mem1
.szMalloc
==0 ); /* See comment below */
3323 if( pKeyInfo
->aSortOrder
[i
] ){
3324 rc
= -rc
; /* Invert the result for DESC sort order. */
3326 goto debugCompareEnd
;
3329 }while( idx1
<szHdr1
&& i
<pPKey2
->nField
);
3331 /* No memory allocation is ever used on mem1. Prove this using
3332 ** the following assert(). If the assert() fails, it indicates a
3333 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).
3335 assert( mem1
.szMalloc
==0 );
3337 /* rc==0 here means that one of the keys ran out of fields and
3338 ** all the fields up to that point were equal. Return the default_rc
3340 rc
= pPKey2
->default_rc
;
3343 if( desiredResult
==0 && rc
==0 ) return 1;
3344 if( desiredResult
<0 && rc
<0 ) return 1;
3345 if( desiredResult
>0 && rc
>0 ) return 1;
3346 if( CORRUPT_DB
) return 1;
3347 if( pKeyInfo
->db
->mallocFailed
) return 1;
3354 ** Count the number of fields (a.k.a. columns) in the record given by
3355 ** pKey,nKey. The verify that this count is less than or equal to the
3356 ** limit given by pKeyInfo->nField + pKeyInfo->nXField.
3358 ** If this constraint is not satisfied, it means that the high-speed
3359 ** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will
3360 ** not work correctly. If this assert() ever fires, it probably means
3361 ** that the KeyInfo.nField or KeyInfo.nXField values were computed
3364 static void vdbeAssertFieldCountWithinLimits(
3365 int nKey
, const void *pKey
, /* The record to verify */
3366 const KeyInfo
*pKeyInfo
/* Compare size with this KeyInfo */
3372 const unsigned char *aKey
= (const unsigned char*)pKey
;
3374 if( CORRUPT_DB
) return;
3375 idx
= getVarint32(aKey
, szHdr
);
3376 assert( szHdr
<=nKey
);
3378 idx
+= getVarint32(aKey
+idx
, notUsed
);
3381 assert( nField
<= pKeyInfo
->nField
+pKeyInfo
->nXField
);
3384 # define vdbeAssertFieldCountWithinLimits(A,B,C)
3388 ** Both *pMem1 and *pMem2 contain string values. Compare the two values
3389 ** using the collation sequence pColl. As usual, return a negative , zero
3390 ** or positive value if *pMem1 is less than, equal to or greater than
3391 ** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);".
3393 static int vdbeCompareMemString(
3396 const CollSeq
*pColl
,
3397 u8
*prcErr
/* If an OOM occurs, set to SQLITE_NOMEM */
3399 if( pMem1
->enc
==pColl
->enc
){
3400 /* The strings are already in the correct encoding. Call the
3401 ** comparison function directly */
3402 return pColl
->xCmp(pColl
->pUser
,pMem1
->n
,pMem1
->z
,pMem2
->n
,pMem2
->z
);
3405 const void *v1
, *v2
;
3409 sqlite3VdbeMemInit(&c1
, pMem1
->db
, MEM_Null
);
3410 sqlite3VdbeMemInit(&c2
, pMem1
->db
, MEM_Null
);
3411 sqlite3VdbeMemShallowCopy(&c1
, pMem1
, MEM_Ephem
);
3412 sqlite3VdbeMemShallowCopy(&c2
, pMem2
, MEM_Ephem
);
3413 v1
= sqlite3ValueText((sqlite3_value
*)&c1
, pColl
->enc
);
3414 n1
= v1
==0 ? 0 : c1
.n
;
3415 v2
= sqlite3ValueText((sqlite3_value
*)&c2
, pColl
->enc
);
3416 n2
= v2
==0 ? 0 : c2
.n
;
3417 rc
= pColl
->xCmp(pColl
->pUser
, n1
, v1
, n2
, v2
);
3418 sqlite3VdbeMemRelease(&c1
);
3419 sqlite3VdbeMemRelease(&c2
);
3420 if( (v1
==0 || v2
==0) && prcErr
) *prcErr
= SQLITE_NOMEM
;
3426 ** Compare two blobs. Return negative, zero, or positive if the first
3427 ** is less than, equal to, or greater than the second, respectively.
3428 ** If one blob is a prefix of the other, then the shorter is the lessor.
3430 static SQLITE_NOINLINE
int sqlite3BlobCompare(const Mem
*pB1
, const Mem
*pB2
){
3431 int c
= memcmp(pB1
->z
, pB2
->z
, pB1
->n
>pB2
->n
? pB2
->n
: pB1
->n
);
3433 return pB1
->n
- pB2
->n
;
3438 ** Compare the values contained by the two memory cells, returning
3439 ** negative, zero or positive if pMem1 is less than, equal to, or greater
3440 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
3441 ** and reals) sorted numerically, followed by text ordered by the collating
3442 ** sequence pColl and finally blob's ordered by memcmp().
3444 ** Two NULL values are considered equal by this function.
3446 int sqlite3MemCompare(const Mem
*pMem1
, const Mem
*pMem2
, const CollSeq
*pColl
){
3452 combined_flags
= f1
|f2
;
3453 assert( (combined_flags
& MEM_RowSet
)==0 );
3455 /* If one value is NULL, it is less than the other. If both values
3456 ** are NULL, return 0.
3458 if( combined_flags
&MEM_Null
){
3459 return (f2
&MEM_Null
) - (f1
&MEM_Null
);
3462 /* If one value is a number and the other is not, the number is less.
3463 ** If both are numbers, compare as reals if one is a real, or as integers
3464 ** if both values are integers.
3466 if( combined_flags
&(MEM_Int
|MEM_Real
) ){
3468 if( (f1
& f2
& MEM_Int
)!=0 ){
3469 if( pMem1
->u
.i
< pMem2
->u
.i
) return -1;
3470 if( pMem1
->u
.i
> pMem2
->u
.i
) return 1;
3473 if( (f1
&MEM_Real
)!=0 ){
3475 }else if( (f1
&MEM_Int
)!=0 ){
3476 r1
= (double)pMem1
->u
.i
;
3480 if( (f2
&MEM_Real
)!=0 ){
3482 }else if( (f2
&MEM_Int
)!=0 ){
3483 r2
= (double)pMem2
->u
.i
;
3487 if( r1
<r2
) return -1;
3488 if( r1
>r2
) return 1;
3492 /* If one value is a string and the other is a blob, the string is less.
3493 ** If both are strings, compare using the collating functions.
3495 if( combined_flags
&MEM_Str
){
3496 if( (f1
& MEM_Str
)==0 ){
3499 if( (f2
& MEM_Str
)==0 ){
3503 assert( pMem1
->enc
==pMem2
->enc
);
3504 assert( pMem1
->enc
==SQLITE_UTF8
||
3505 pMem1
->enc
==SQLITE_UTF16LE
|| pMem1
->enc
==SQLITE_UTF16BE
);
3507 /* The collation sequence must be defined at this point, even if
3508 ** the user deletes the collation sequence after the vdbe program is
3509 ** compiled (this was not always the case).
3511 assert( !pColl
|| pColl
->xCmp
);
3514 return vdbeCompareMemString(pMem1
, pMem2
, pColl
, 0);
3516 /* If a NULL pointer was passed as the collate function, fall through
3517 ** to the blob case and use memcmp(). */
3520 /* Both values must be blobs. Compare using memcmp(). */
3521 return sqlite3BlobCompare(pMem1
, pMem2
);
3526 ** The first argument passed to this function is a serial-type that
3527 ** corresponds to an integer - all values between 1 and 9 inclusive
3528 ** except 7. The second points to a buffer containing an integer value
3529 ** serialized according to serial_type. This function deserializes
3530 ** and returns the value.
3532 static i64
vdbeRecordDecodeInt(u32 serial_type
, const u8
*aKey
){
3534 assert( CORRUPT_DB
|| (serial_type
>=1 && serial_type
<=9 && serial_type
!=7) );
3535 switch( serial_type
){
3538 testcase( aKey
[0]&0x80 );
3539 return ONE_BYTE_INT(aKey
);
3541 testcase( aKey
[0]&0x80 );
3542 return TWO_BYTE_INT(aKey
);
3544 testcase( aKey
[0]&0x80 );
3545 return THREE_BYTE_INT(aKey
);
3547 testcase( aKey
[0]&0x80 );
3548 y
= FOUR_BYTE_UINT(aKey
);
3549 return (i64
)*(int*)&y
;
3552 testcase( aKey
[0]&0x80 );
3553 return FOUR_BYTE_UINT(aKey
+2) + (((i64
)1)<<32)*TWO_BYTE_INT(aKey
);
3556 u64 x
= FOUR_BYTE_UINT(aKey
);
3557 testcase( aKey
[0]&0x80 );
3558 x
= (x
<<32) | FOUR_BYTE_UINT(aKey
+4);
3559 return (i64
)*(i64
*)&x
;
3563 return (serial_type
- 8);
3567 ** This function compares the two table rows or index records
3568 ** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero
3569 ** or positive integer if key1 is less than, equal to or
3570 ** greater than key2. The {nKey1, pKey1} key must be a blob
3571 ** created by the OP_MakeRecord opcode of the VDBE. The pPKey2
3572 ** key must be a parsed key such as obtained from
3573 ** sqlite3VdbeParseRecord.
3575 ** If argument bSkip is non-zero, it is assumed that the caller has already
3576 ** determined that the first fields of the keys are equal.
3578 ** Key1 and Key2 do not have to contain the same number of fields. If all
3579 ** fields that appear in both keys are equal, then pPKey2->default_rc is
3582 ** If database corruption is discovered, set pPKey2->errCode to
3583 ** SQLITE_CORRUPT and return 0. If an OOM error is encountered,
3584 ** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the
3585 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
3587 static int vdbeRecordCompareWithSkip(
3588 int nKey1
, const void *pKey1
, /* Left key */
3589 UnpackedRecord
*pPKey2
, /* Right key */
3590 int bSkip
/* If true, skip the first field */
3592 u32 d1
; /* Offset into aKey[] of next data element */
3593 int i
; /* Index of next field to compare */
3594 u32 szHdr1
; /* Size of record header in bytes */
3595 u32 idx1
; /* Offset of first type in header */
3596 int rc
= 0; /* Return value */
3597 Mem
*pRhs
= pPKey2
->aMem
; /* Next field of pPKey2 to compare */
3598 KeyInfo
*pKeyInfo
= pPKey2
->pKeyInfo
;
3599 const unsigned char *aKey1
= (const unsigned char *)pKey1
;
3602 /* If bSkip is true, then the caller has already determined that the first
3603 ** two elements in the keys are equal. Fix the various stack variables so
3604 ** that this routine begins comparing at the second field. */
3607 idx1
= 1 + getVarint32(&aKey1
[1], s1
);
3609 d1
= szHdr1
+ sqlite3VdbeSerialTypeLen(s1
);
3613 idx1
= getVarint32(aKey1
, szHdr1
);
3615 if( d1
>(unsigned)nKey1
){
3616 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
3617 return 0; /* Corruption */
3622 VVA_ONLY( mem1
.szMalloc
= 0; ) /* Only needed by assert() statements */
3623 assert( pPKey2
->pKeyInfo
->nField
+pPKey2
->pKeyInfo
->nXField
>=pPKey2
->nField
3625 assert( pPKey2
->pKeyInfo
->aSortOrder
!=0 );
3626 assert( pPKey2
->pKeyInfo
->nField
>0 );
3627 assert( idx1
<=szHdr1
|| CORRUPT_DB
);
3631 /* RHS is an integer */
3632 if( pRhs
->flags
& MEM_Int
){
3633 serial_type
= aKey1
[idx1
];
3634 testcase( serial_type
==12 );
3635 if( serial_type
>=12 ){
3637 }else if( serial_type
==0 ){
3639 }else if( serial_type
==7 ){
3640 double rhs
= (double)pRhs
->u
.i
;
3641 sqlite3VdbeSerialGet(&aKey1
[d1
], serial_type
, &mem1
);
3644 }else if( mem1
.u
.r
>rhs
){
3648 i64 lhs
= vdbeRecordDecodeInt(serial_type
, &aKey1
[d1
]);
3649 i64 rhs
= pRhs
->u
.i
;
3652 }else if( lhs
>rhs
){
3659 else if( pRhs
->flags
& MEM_Real
){
3660 serial_type
= aKey1
[idx1
];
3661 if( serial_type
>=12 ){
3663 }else if( serial_type
==0 ){
3666 double rhs
= pRhs
->u
.r
;
3668 sqlite3VdbeSerialGet(&aKey1
[d1
], serial_type
, &mem1
);
3669 if( serial_type
==7 ){
3672 lhs
= (double)mem1
.u
.i
;
3676 }else if( lhs
>rhs
){
3682 /* RHS is a string */
3683 else if( pRhs
->flags
& MEM_Str
){
3684 getVarint32(&aKey1
[idx1
], serial_type
);
3685 testcase( serial_type
==12 );
3686 if( serial_type
<12 ){
3688 }else if( !(serial_type
& 0x01) ){
3691 mem1
.n
= (serial_type
- 12) / 2;
3692 testcase( (d1
+mem1
.n
)==(unsigned)nKey1
);
3693 testcase( (d1
+mem1
.n
+1)==(unsigned)nKey1
);
3694 if( (d1
+mem1
.n
) > (unsigned)nKey1
){
3695 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
3696 return 0; /* Corruption */
3697 }else if( pKeyInfo
->aColl
[i
] ){
3698 mem1
.enc
= pKeyInfo
->enc
;
3699 mem1
.db
= pKeyInfo
->db
;
3700 mem1
.flags
= MEM_Str
;
3701 mem1
.z
= (char*)&aKey1
[d1
];
3702 rc
= vdbeCompareMemString(
3703 &mem1
, pRhs
, pKeyInfo
->aColl
[i
], &pPKey2
->errCode
3706 int nCmp
= MIN(mem1
.n
, pRhs
->n
);
3707 rc
= memcmp(&aKey1
[d1
], pRhs
->z
, nCmp
);
3708 if( rc
==0 ) rc
= mem1
.n
- pRhs
->n
;
3714 else if( pRhs
->flags
& MEM_Blob
){
3715 getVarint32(&aKey1
[idx1
], serial_type
);
3716 testcase( serial_type
==12 );
3717 if( serial_type
<12 || (serial_type
& 0x01) ){
3720 int nStr
= (serial_type
- 12) / 2;
3721 testcase( (d1
+nStr
)==(unsigned)nKey1
);
3722 testcase( (d1
+nStr
+1)==(unsigned)nKey1
);
3723 if( (d1
+nStr
) > (unsigned)nKey1
){
3724 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
3725 return 0; /* Corruption */
3727 int nCmp
= MIN(nStr
, pRhs
->n
);
3728 rc
= memcmp(&aKey1
[d1
], pRhs
->z
, nCmp
);
3729 if( rc
==0 ) rc
= nStr
- pRhs
->n
;
3736 serial_type
= aKey1
[idx1
];
3737 rc
= (serial_type
!=0);
3741 if( pKeyInfo
->aSortOrder
[i
] ){
3744 assert( vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, rc
) );
3745 assert( mem1
.szMalloc
==0 ); /* See comment below */
3751 d1
+= sqlite3VdbeSerialTypeLen(serial_type
);
3752 idx1
+= sqlite3VarintLen(serial_type
);
3753 }while( idx1
<(unsigned)szHdr1
&& i
<pPKey2
->nField
&& d1
<=(unsigned)nKey1
);
3755 /* No memory allocation is ever used on mem1. Prove this using
3756 ** the following assert(). If the assert() fails, it indicates a
3757 ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */
3758 assert( mem1
.szMalloc
==0 );
3760 /* rc==0 here means that one or both of the keys ran out of fields and
3761 ** all the fields up to that point were equal. Return the default_rc
3764 || vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, pPKey2
->default_rc
)
3765 || pKeyInfo
->db
->mallocFailed
3767 return pPKey2
->default_rc
;
3769 int sqlite3VdbeRecordCompare(
3770 int nKey1
, const void *pKey1
, /* Left key */
3771 UnpackedRecord
*pPKey2
/* Right key */
3773 return vdbeRecordCompareWithSkip(nKey1
, pKey1
, pPKey2
, 0);
3778 ** This function is an optimized version of sqlite3VdbeRecordCompare()
3779 ** that (a) the first field of pPKey2 is an integer, and (b) the
3780 ** size-of-header varint at the start of (pKey1/nKey1) fits in a single
3781 ** byte (i.e. is less than 128).
3783 ** To avoid concerns about buffer overreads, this routine is only used
3784 ** on schemas where the maximum valid header size is 63 bytes or less.
3786 static int vdbeRecordCompareInt(
3787 int nKey1
, const void *pKey1
, /* Left key */
3788 UnpackedRecord
*pPKey2
/* Right key */
3790 const u8
*aKey
= &((const u8
*)pKey1
)[*(const u8
*)pKey1
& 0x3F];
3791 int serial_type
= ((const u8
*)pKey1
)[1];
3795 i64 v
= pPKey2
->aMem
[0].u
.i
;
3798 vdbeAssertFieldCountWithinLimits(nKey1
, pKey1
, pPKey2
->pKeyInfo
);
3799 assert( (*(u8
*)pKey1
)<=0x3F || CORRUPT_DB
);
3800 switch( serial_type
){
3801 case 1: { /* 1-byte signed integer */
3802 lhs
= ONE_BYTE_INT(aKey
);
3806 case 2: { /* 2-byte signed integer */
3807 lhs
= TWO_BYTE_INT(aKey
);
3811 case 3: { /* 3-byte signed integer */
3812 lhs
= THREE_BYTE_INT(aKey
);
3816 case 4: { /* 4-byte signed integer */
3817 y
= FOUR_BYTE_UINT(aKey
);
3818 lhs
= (i64
)*(int*)&y
;
3822 case 5: { /* 6-byte signed integer */
3823 lhs
= FOUR_BYTE_UINT(aKey
+2) + (((i64
)1)<<32)*TWO_BYTE_INT(aKey
);
3827 case 6: { /* 8-byte signed integer */
3828 x
= FOUR_BYTE_UINT(aKey
);
3829 x
= (x
<<32) | FOUR_BYTE_UINT(aKey
+4);
3841 /* This case could be removed without changing the results of running
3842 ** this code. Including it causes gcc to generate a faster switch
3843 ** statement (since the range of switch targets now starts at zero and
3844 ** is contiguous) but does not cause any duplicate code to be generated
3845 ** (as gcc is clever enough to combine the two like cases). Other
3846 ** compilers might be similar. */
3848 return sqlite3VdbeRecordCompare(nKey1
, pKey1
, pPKey2
);
3851 return sqlite3VdbeRecordCompare(nKey1
, pKey1
, pPKey2
);
3858 }else if( pPKey2
->nField
>1 ){
3859 /* The first fields of the two keys are equal. Compare the trailing
3861 res
= vdbeRecordCompareWithSkip(nKey1
, pKey1
, pPKey2
, 1);
3863 /* The first fields of the two keys are equal and there are no trailing
3864 ** fields. Return pPKey2->default_rc in this case. */
3865 res
= pPKey2
->default_rc
;
3868 assert( vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, res
) );
3873 ** This function is an optimized version of sqlite3VdbeRecordCompare()
3874 ** that (a) the first field of pPKey2 is a string, that (b) the first field
3875 ** uses the collation sequence BINARY and (c) that the size-of-header varint
3876 ** at the start of (pKey1/nKey1) fits in a single byte.
3878 static int vdbeRecordCompareString(
3879 int nKey1
, const void *pKey1
, /* Left key */
3880 UnpackedRecord
*pPKey2
/* Right key */
3882 const u8
*aKey1
= (const u8
*)pKey1
;
3886 vdbeAssertFieldCountWithinLimits(nKey1
, pKey1
, pPKey2
->pKeyInfo
);
3887 getVarint32(&aKey1
[1], serial_type
);
3888 if( serial_type
<12 ){
3889 res
= pPKey2
->r1
; /* (pKey1/nKey1) is a number or a null */
3890 }else if( !(serial_type
& 0x01) ){
3891 res
= pPKey2
->r2
; /* (pKey1/nKey1) is a blob */
3895 int szHdr
= aKey1
[0];
3897 nStr
= (serial_type
-12) / 2;
3898 if( (szHdr
+ nStr
) > nKey1
){
3899 pPKey2
->errCode
= (u8
)SQLITE_CORRUPT_BKPT
;
3900 return 0; /* Corruption */
3902 nCmp
= MIN( pPKey2
->aMem
[0].n
, nStr
);
3903 res
= memcmp(&aKey1
[szHdr
], pPKey2
->aMem
[0].z
, nCmp
);
3906 res
= nStr
- pPKey2
->aMem
[0].n
;
3908 if( pPKey2
->nField
>1 ){
3909 res
= vdbeRecordCompareWithSkip(nKey1
, pKey1
, pPKey2
, 1);
3911 res
= pPKey2
->default_rc
;
3925 assert( vdbeRecordCompareDebug(nKey1
, pKey1
, pPKey2
, res
)
3927 || pPKey2
->pKeyInfo
->db
->mallocFailed
3933 ** Return a pointer to an sqlite3VdbeRecordCompare() compatible function
3934 ** suitable for comparing serialized records to the unpacked record passed
3935 ** as the only argument.
3937 RecordCompare
sqlite3VdbeFindCompare(UnpackedRecord
*p
){
3938 /* varintRecordCompareInt() and varintRecordCompareString() both assume
3939 ** that the size-of-header varint that occurs at the start of each record
3940 ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt()
3941 ** also assumes that it is safe to overread a buffer by at least the
3942 ** maximum possible legal header size plus 8 bytes. Because there is
3943 ** guaranteed to be at least 74 (but not 136) bytes of padding following each
3944 ** buffer passed to varintRecordCompareInt() this makes it convenient to
3945 ** limit the size of the header to 64 bytes in cases where the first field
3948 ** The easiest way to enforce this limit is to consider only records with
3949 ** 13 fields or less. If the first field is an integer, the maximum legal
3950 ** header size is (12*5 + 1 + 1) bytes. */
3951 if( (p
->pKeyInfo
->nField
+ p
->pKeyInfo
->nXField
)<=13 ){
3952 int flags
= p
->aMem
[0].flags
;
3953 if( p
->pKeyInfo
->aSortOrder
[0] ){
3960 if( (flags
& MEM_Int
) ){
3961 return vdbeRecordCompareInt
;
3963 testcase( flags
& MEM_Real
);
3964 testcase( flags
& MEM_Null
);
3965 testcase( flags
& MEM_Blob
);
3966 if( (flags
& (MEM_Real
|MEM_Null
|MEM_Blob
))==0 && p
->pKeyInfo
->aColl
[0]==0 ){
3967 assert( flags
& MEM_Str
);
3968 return vdbeRecordCompareString
;
3972 return sqlite3VdbeRecordCompare
;
3976 ** pCur points at an index entry created using the OP_MakeRecord opcode.
3977 ** Read the rowid (the last field in the record) and store it in *rowid.
3978 ** Return SQLITE_OK if everything works, or an error code otherwise.
3980 ** pCur might be pointing to text obtained from a corrupt database file.
3981 ** So the content cannot be trusted. Do appropriate checks on the content.
3983 int sqlite3VdbeIdxRowid(sqlite3
*db
, BtCursor
*pCur
, i64
*rowid
){
3986 u32 szHdr
; /* Size of the header */
3987 u32 typeRowid
; /* Serial type of the rowid */
3988 u32 lenRowid
; /* Size of the rowid */
3991 /* Get the size of the index entry. Only indices entries of less
3992 ** than 2GiB are support - anything large must be database corruption.
3993 ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so
3994 ** this code can safely assume that nCellKey is 32-bits
3996 assert( sqlite3BtreeCursorIsValid(pCur
) );
3997 VVA_ONLY(rc
=) sqlite3BtreeKeySize(pCur
, &nCellKey
);
3998 assert( rc
==SQLITE_OK
); /* pCur is always valid so KeySize cannot fail */
3999 assert( (nCellKey
& SQLITE_MAX_U32
)==(u64
)nCellKey
);
4001 /* Read in the complete content of the index entry */
4002 sqlite3VdbeMemInit(&m
, db
, 0);
4003 rc
= sqlite3VdbeMemFromBtree(pCur
, 0, (u32
)nCellKey
, 1, &m
);
4008 /* The index entry must begin with a header size */
4009 (void)getVarint32((u8
*)m
.z
, szHdr
);
4010 testcase( szHdr
==3 );
4011 testcase( szHdr
==m
.n
);
4012 if( unlikely(szHdr
<3 || (int)szHdr
>m
.n
) ){
4013 goto idx_rowid_corruption
;
4016 /* The last field of the index should be an integer - the ROWID.
4017 ** Verify that the last entry really is an integer. */
4018 (void)getVarint32((u8
*)&m
.z
[szHdr
-1], typeRowid
);
4019 testcase( typeRowid
==1 );
4020 testcase( typeRowid
==2 );
4021 testcase( typeRowid
==3 );
4022 testcase( typeRowid
==4 );
4023 testcase( typeRowid
==5 );
4024 testcase( typeRowid
==6 );
4025 testcase( typeRowid
==8 );
4026 testcase( typeRowid
==9 );
4027 if( unlikely(typeRowid
<1 || typeRowid
>9 || typeRowid
==7) ){
4028 goto idx_rowid_corruption
;
4030 lenRowid
= sqlite3VdbeSerialTypeLen(typeRowid
);
4031 testcase( (u32
)m
.n
==szHdr
+lenRowid
);
4032 if( unlikely((u32
)m
.n
<szHdr
+lenRowid
) ){
4033 goto idx_rowid_corruption
;
4036 /* Fetch the integer off the end of the index record */
4037 sqlite3VdbeSerialGet((u8
*)&m
.z
[m
.n
-lenRowid
], typeRowid
, &v
);
4039 sqlite3VdbeMemRelease(&m
);
4042 /* Jump here if database corruption is detected after m has been
4043 ** allocated. Free the m object and return SQLITE_CORRUPT. */
4044 idx_rowid_corruption
:
4045 testcase( m
.szMalloc
!=0 );
4046 sqlite3VdbeMemRelease(&m
);
4047 return SQLITE_CORRUPT_BKPT
;
4051 ** Compare the key of the index entry that cursor pC is pointing to against
4052 ** the key string in pUnpacked. Write into *pRes a number
4053 ** that is negative, zero, or positive if pC is less than, equal to,
4054 ** or greater than pUnpacked. Return SQLITE_OK on success.
4056 ** pUnpacked is either created without a rowid or is truncated so that it
4057 ** omits the rowid at the end. The rowid at the end of the index entry
4058 ** is ignored as well. Hence, this routine only compares the prefixes
4059 ** of the keys prior to the final rowid, not the entire key.
4061 int sqlite3VdbeIdxKeyCompare(
4062 sqlite3
*db
, /* Database connection */
4063 VdbeCursor
*pC
, /* The cursor to compare against */
4064 UnpackedRecord
*pUnpacked
, /* Unpacked version of key */
4065 int *res
/* Write the comparison result here */
4069 BtCursor
*pCur
= pC
->pCursor
;
4072 assert( sqlite3BtreeCursorIsValid(pCur
) );
4073 VVA_ONLY(rc
=) sqlite3BtreeKeySize(pCur
, &nCellKey
);
4074 assert( rc
==SQLITE_OK
); /* pCur is always valid so KeySize cannot fail */
4075 /* nCellKey will always be between 0 and 0xffffffff because of the way
4076 ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
4077 if( nCellKey
<=0 || nCellKey
>0x7fffffff ){
4079 return SQLITE_CORRUPT_BKPT
;
4081 sqlite3VdbeMemInit(&m
, db
, 0);
4082 rc
= sqlite3VdbeMemFromBtree(pC
->pCursor
, 0, (u32
)nCellKey
, 1, &m
);
4086 *res
= sqlite3VdbeRecordCompare(m
.n
, m
.z
, pUnpacked
);
4087 sqlite3VdbeMemRelease(&m
);
4092 ** This routine sets the value to be returned by subsequent calls to
4093 ** sqlite3_changes() on the database handle 'db'.
4095 void sqlite3VdbeSetChanges(sqlite3
*db
, int nChange
){
4096 assert( sqlite3_mutex_held(db
->mutex
) );
4097 db
->nChange
= nChange
;
4098 db
->nTotalChange
+= nChange
;
4102 ** Set a flag in the vdbe to update the change counter when it is finalised
4105 void sqlite3VdbeCountChanges(Vdbe
*v
){
4110 ** Mark every prepared statement associated with a database connection
4113 ** An expired statement means that recompilation of the statement is
4114 ** recommend. Statements expire when things happen that make their
4115 ** programs obsolete. Removing user-defined functions or collating
4116 ** sequences, or changing an authorization function are the types of
4117 ** things that make prepared statements obsolete.
4119 void sqlite3ExpirePreparedStatements(sqlite3
*db
){
4121 for(p
= db
->pVdbe
; p
; p
=p
->pNext
){
4127 ** Return the database associated with the Vdbe.
4129 sqlite3
*sqlite3VdbeDb(Vdbe
*v
){
4134 ** Return a pointer to an sqlite3_value structure containing the value bound
4135 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
4136 ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_*
4137 ** constants) to the value before returning it.
4139 ** The returned value must be freed by the caller using sqlite3ValueFree().
4141 sqlite3_value
*sqlite3VdbeGetBoundValue(Vdbe
*v
, int iVar
, u8 aff
){
4144 Mem
*pMem
= &v
->aVar
[iVar
-1];
4145 if( 0==(pMem
->flags
& MEM_Null
) ){
4146 sqlite3_value
*pRet
= sqlite3ValueNew(v
->db
);
4148 sqlite3VdbeMemCopy((Mem
*)pRet
, pMem
);
4149 sqlite3ValueApplyAffinity(pRet
, aff
, SQLITE_UTF8
);
4158 ** Configure SQL variable iVar so that binding a new value to it signals
4159 ** to sqlite3_reoptimize() that re-preparing the statement may result
4160 ** in a better query plan.
4162 void sqlite3VdbeSetVarmask(Vdbe
*v
, int iVar
){
4165 v
->expmask
= 0xffffffff;
4167 v
->expmask
|= ((u32
)1 << (iVar
-1));
4171 #ifndef SQLITE_OMIT_VIRTUALTABLE
4173 ** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored
4174 ** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored
4175 ** in memory obtained from sqlite3DbMalloc).
4177 void sqlite3VtabImportErrmsg(Vdbe
*p
, sqlite3_vtab
*pVtab
){
4178 sqlite3
*db
= p
->db
;
4179 sqlite3DbFree(db
, p
->zErrMsg
);
4180 p
->zErrMsg
= sqlite3DbStrDup(db
, pVtab
->zErrMsg
);
4181 sqlite3_free(pVtab
->zErrMsg
);
4184 #endif /* SQLITE_OMIT_VIRTUALTABLE */