1/*
2** 2001 September 15
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11*************************************************************************
12** The code in this file implements the function that runs the
13** bytecode of a prepared statement.
14**
15** Various scripts scan this source file in order to generate HTML
16** documentation, headers files, or other derived files. The formatting
17** of the code in this file is, therefore, important. See other comments
18** in this file for details. If in doubt, do not deviate from existing
19** commenting and indentation practices when changing or adding code.
20*/
21#include "sqliteInt.h"
22#include "vdbeInt.h"
23
24/*
25** Invoke this macro on memory cells just prior to changing the
26** value of the cell. This macro verifies that shallow copies are
27** not misused. A shallow copy of a string or blob just copies a
28** pointer to the string or blob, not the content. If the original
29** is changed while the copy is still in use, the string or blob might
30** be changed out from under the copy. This macro verifies that nothing
31** like that ever happens.
32*/
33#ifdef SQLITE_DEBUG
34# define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M)
35#else
36# define memAboutToChange(P,M)
37#endif
38
39/*
40** The following global variable is incremented every time a cursor
41** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes. The test
42** procedures use this information to make sure that indices are
43** working correctly. This variable has no function other than to
44** help verify the correct operation of the library.
45*/
46#ifdef SQLITE_TEST
47int sqlite3_search_count = 0;
48#endif
49
50/*
51** When this global variable is positive, it gets decremented once before
52** each instruction in the VDBE. When it reaches zero, the u1.isInterrupted
53** field of the sqlite3 structure is set in order to simulate an interrupt.
54**
55** This facility is used for testing purposes only. It does not function
56** in an ordinary build.
57*/
58#ifdef SQLITE_TEST
59int sqlite3_interrupt_count = 0;
60#endif
61
62/*
63** The next global variable is incremented each type the OP_Sort opcode
64** is executed. The test procedures use this information to make sure that
65** sorting is occurring or not occurring at appropriate times. This variable
66** has no function other than to help verify the correct operation of the
67** library.
68*/
69#ifdef SQLITE_TEST
70int sqlite3_sort_count = 0;
71#endif
72
73/*
74** The next global variable records the size of the largest MEM_Blob
75** or MEM_Str that has been used by a VDBE opcode. The test procedures
76** use this information to make sure that the zero-blob functionality
77** is working correctly. This variable has no function other than to
78** help verify the correct operation of the library.
79*/
80#ifdef SQLITE_TEST
81int sqlite3_max_blobsize = 0;
82static void updateMaxBlobsize(Mem *p){
83 if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
84 sqlite3_max_blobsize = p->n;
85 }
86}
87#endif
88
89/*
90** This macro evaluates to true if either the update hook or the preupdate
91** hook are enabled for database connect DB.
92*/
93#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
94# define HAS_UPDATE_HOOK(DB) ((DB)->xPreUpdateCallback||(DB)->xUpdateCallback)
95#else
96# define HAS_UPDATE_HOOK(DB) ((DB)->xUpdateCallback)
97#endif
98
99/*
100** The next global variable is incremented each time the OP_Found opcode
101** is executed. This is used to test whether or not the foreign key
102** operation implemented using OP_FkIsZero is working. This variable
103** has no function other than to help verify the correct operation of the
104** library.
105*/
106#ifdef SQLITE_TEST
107int sqlite3_found_count = 0;
108#endif
109
110/*
111** Test a register to see if it exceeds the current maximum blob size.
112** If it does, record the new maximum blob size.
113*/
114#if defined(SQLITE_TEST) && !defined(SQLITE_UNTESTABLE)
115# define UPDATE_MAX_BLOBSIZE(P) updateMaxBlobsize(P)
116#else
117# define UPDATE_MAX_BLOBSIZE(P)
118#endif
119
120#ifdef SQLITE_DEBUG
121/* This routine provides a convenient place to set a breakpoint during
122** tracing with PRAGMA vdbe_trace=on. The breakpoint fires right after
123** each opcode is printed. Variables "pc" (program counter) and pOp are
124** available to add conditionals to the breakpoint. GDB example:
125**
126** break test_trace_breakpoint if pc=22
127**
128** Other useful labels for breakpoints include:
129** test_addop_breakpoint(pc,pOp)
130** sqlite3CorruptError(lineno)
131** sqlite3MisuseError(lineno)
132** sqlite3CantopenError(lineno)
133*/
134static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){
135 static int n = 0;
136 n++;
137}
138#endif
139
140/*
141** Invoke the VDBE coverage callback, if that callback is defined. This
142** feature is used for test suite validation only and does not appear an
143** production builds.
144**
145** M is the type of branch. I is the direction taken for this instance of
146** the branch.
147**
148** M: 2 - two-way branch (I=0: fall-thru 1: jump )
149** 3 - two-way + NULL (I=0: fall-thru 1: jump 2: NULL )
150** 4 - OP_Jump (I=0: jump p1 1: jump p2 2: jump p3)
151**
152** In other words, if M is 2, then I is either 0 (for fall-through) or
153** 1 (for when the branch is taken). If M is 3, the I is 0 for an
154** ordinary fall-through, I is 1 if the branch was taken, and I is 2
155** if the result of comparison is NULL. For M=3, I=2 the jump may or
156** may not be taken, depending on the SQLITE_JUMPIFNULL flags in p5.
157** When M is 4, that means that an OP_Jump is being run. I is 0, 1, or 2
158** depending on if the operands are less than, equal, or greater than.
159**
160** iSrcLine is the source code line (from the __LINE__ macro) that
161** generated the VDBE instruction combined with flag bits. The source
162** code line number is in the lower 24 bits of iSrcLine and the upper
163** 8 bytes are flags. The lower three bits of the flags indicate
164** values for I that should never occur. For example, if the branch is
165** always taken, the flags should be 0x05 since the fall-through and
166** alternate branch are never taken. If a branch is never taken then
167** flags should be 0x06 since only the fall-through approach is allowed.
168**
169** Bit 0x08 of the flags indicates an OP_Jump opcode that is only
170** interested in equal or not-equal. In other words, I==0 and I==2
171** should be treated as equivalent
172**
173** Since only a line number is retained, not the filename, this macro
174** only works for amalgamation builds. But that is ok, since these macros
175** should be no-ops except for special builds used to measure test coverage.
176*/
177#if !defined(SQLITE_VDBE_COVERAGE)
178# define VdbeBranchTaken(I,M)
179#else
180# define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M)
181 static void vdbeTakeBranch(u32 iSrcLine, u8 I, u8 M){
182 u8 mNever;
183 assert( I<=2 ); /* 0: fall through, 1: taken, 2: alternate taken */
184 assert( M<=4 ); /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */
185 assert( I<M ); /* I can only be 2 if M is 3 or 4 */
186 /* Transform I from a integer [0,1,2] into a bitmask of [1,2,4] */
187 I = 1<<I;
188 /* The upper 8 bits of iSrcLine are flags. The lower three bits of
189 ** the flags indicate directions that the branch can never go. If
190 ** a branch really does go in one of those directions, assert right
191 ** away. */
192 mNever = iSrcLine >> 24;
193 assert( (I & mNever)==0 );
194 if( sqlite3GlobalConfig.xVdbeBranch==0 ) return; /*NO_TEST*/
195 /* Invoke the branch coverage callback with three arguments:
196 ** iSrcLine - the line number of the VdbeCoverage() macro, with
197 ** flags removed.
198 ** I - Mask of bits 0x07 indicating which cases are are
199 ** fulfilled by this instance of the jump. 0x01 means
200 ** fall-thru, 0x02 means taken, 0x04 means NULL. Any
201 ** impossible cases (ex: if the comparison is never NULL)
202 ** are filled in automatically so that the coverage
203 ** measurement logic does not flag those impossible cases
204 ** as missed coverage.
205 ** M - Type of jump. Same as M argument above
206 */
207 I |= mNever;
208 if( M==2 ) I |= 0x04;
209 if( M==4 ){
210 I |= 0x08;
211 if( (mNever&0x08)!=0 && (I&0x05)!=0) I |= 0x05; /*NO_TEST*/
212 }
213 sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg,
214 iSrcLine&0xffffff, I, M);
215 }
216#endif
217
218/*
219** An ephemeral string value (signified by the MEM_Ephem flag) contains
220** a pointer to a dynamically allocated string where some other entity
221** is responsible for deallocating that string. Because the register
222** does not control the string, it might be deleted without the register
223** knowing it.
224**
225** This routine converts an ephemeral string into a dynamically allocated
226** string that the register itself controls. In other words, it
227** converts an MEM_Ephem string into a string with P.z==P.zMalloc.
228*/
229#define Deephemeralize(P) \
230 if( ((P)->flags&MEM_Ephem)!=0 \
231 && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
232
233/* Return true if the cursor was opened using the OP_OpenSorter opcode. */
234#define isSorter(x) ((x)->eCurType==CURTYPE_SORTER)
235
236/*
237** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL
238** if we run out of memory.
239*/
240static VdbeCursor *allocateCursor(
241 Vdbe *p, /* The virtual machine */
242 int iCur, /* Index of the new VdbeCursor */
243 int nField, /* Number of fields in the table or index */
244 u8 eCurType /* Type of the new cursor */
245){
246 /* Find the memory cell that will be used to store the blob of memory
247 ** required for this VdbeCursor structure. It is convenient to use a
248 ** vdbe memory cell to manage the memory allocation required for a
249 ** VdbeCursor structure for the following reasons:
250 **
251 ** * Sometimes cursor numbers are used for a couple of different
252 ** purposes in a vdbe program. The different uses might require
253 ** different sized allocations. Memory cells provide growable
254 ** allocations.
255 **
256 ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
257 ** be freed lazily via the sqlite3_release_memory() API. This
258 ** minimizes the number of malloc calls made by the system.
259 **
260 ** The memory cell for cursor 0 is aMem[0]. The rest are allocated from
261 ** the top of the register space. Cursor 1 is at Mem[p->nMem-1].
262 ** Cursor 2 is at Mem[p->nMem-2]. And so forth.
263 */
264 Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem;
265
266 int nByte;
267 VdbeCursor *pCx = 0;
268 nByte =
269 ROUND8P(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
270 (eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0);
271
272 assert( iCur>=0 && iCur<p->nCursor );
273 if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/
274 sqlite3VdbeFreeCursorNN(p, p->apCsr[iCur]);
275 p->apCsr[iCur] = 0;
276 }
277
278 /* There used to be a call to sqlite3VdbeMemClearAndResize() to make sure
279 ** the pMem used to hold space for the cursor has enough storage available
280 ** in pMem->zMalloc. But for the special case of the aMem[] entries used
281 ** to hold cursors, it is faster to in-line the logic. */
282 assert( pMem->flags==MEM_Undefined );
283 assert( (pMem->flags & MEM_Dyn)==0 );
284 assert( pMem->szMalloc==0 || pMem->z==pMem->zMalloc );
285 if( pMem->szMalloc<nByte ){
286 if( pMem->szMalloc>0 ){
287 sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
288 }
289 pMem->z = pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, nByte);
290 if( pMem->zMalloc==0 ){
291 pMem->szMalloc = 0;
292 return 0;
293 }
294 pMem->szMalloc = nByte;
295 }
296
297 p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->zMalloc;
298 memset(pCx, 0, offsetof(VdbeCursor,pAltCursor));
299 pCx->eCurType = eCurType;
300 pCx->nField = nField;
301 pCx->aOffset = &pCx->aType[nField];
302 if( eCurType==CURTYPE_BTREE ){
303 pCx->uc.pCursor = (BtCursor*)
304 &pMem->z[ROUND8P(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
305 sqlite3BtreeCursorZero(pCx->uc.pCursor);
306 }
307 return pCx;
308}
309
310/*
311** The string in pRec is known to look like an integer and to have a
312** floating point value of rValue. Return true and set *piValue to the
313** integer value if the string is in range to be an integer. Otherwise,
314** return false.
315*/
316static int alsoAnInt(Mem *pRec, double rValue, i64 *piValue){
317 i64 iValue;
318 iValue = sqlite3RealToI64(rValue);
319 if( sqlite3RealSameAsInt(rValue,iValue) ){
320 *piValue = iValue;
321 return 1;
322 }
323 return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc);
324}
325
326/*
327** Try to convert a value into a numeric representation if we can
328** do so without loss of information. In other words, if the string
329** looks like a number, convert it into a number. If it does not
330** look like a number, leave it alone.
331**
332** If the bTryForInt flag is true, then extra effort is made to give
333** an integer representation. Strings that look like floating point
334** values but which have no fractional component (example: '48.00')
335** will have a MEM_Int representation when bTryForInt is true.
336**
337** If bTryForInt is false, then if the input string contains a decimal
338** point or exponential notation, the result is only MEM_Real, even
339** if there is an exact integer representation of the quantity.
340*/
341static void applyNumericAffinity(Mem *pRec, int bTryForInt){
342 double rValue;
343 u8 enc = pRec->enc;
344 int rc;
345 assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str );
346 rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc);
347 if( rc<=0 ) return;
348 if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){
349 pRec->flags |= MEM_Int;
350 }else{
351 pRec->u.r = rValue;
352 pRec->flags |= MEM_Real;
353 if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec);
354 }
355 /* TEXT->NUMERIC is many->one. Hence, it is important to invalidate the
356 ** string representation after computing a numeric equivalent, because the
357 ** string representation might not be the canonical representation for the
358 ** numeric value. Ticket [343634942dd54ab57b7024] 2018-01-31. */
359 pRec->flags &= ~MEM_Str;
360}
361
362/*
363** Processing is determine by the affinity parameter:
364**
365** SQLITE_AFF_INTEGER:
366** SQLITE_AFF_REAL:
367** SQLITE_AFF_NUMERIC:
368** Try to convert pRec to an integer representation or a
369** floating-point representation if an integer representation
370** is not possible. Note that the integer representation is
371** always preferred, even if the affinity is REAL, because
372** an integer representation is more space efficient on disk.
373**
374** SQLITE_AFF_TEXT:
375** Convert pRec to a text representation.
376**
377** SQLITE_AFF_BLOB:
378** SQLITE_AFF_NONE:
379** No-op. pRec is unchanged.
380*/
381static void applyAffinity(
382 Mem *pRec, /* The value to apply affinity to */
383 char affinity, /* The affinity to be applied */
384 u8 enc /* Use this text encoding */
385){
386 if( affinity>=SQLITE_AFF_NUMERIC ){
387 assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
388 || affinity==SQLITE_AFF_NUMERIC );
389 if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/
390 if( (pRec->flags & MEM_Real)==0 ){
391 if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1);
392 }else{
393 sqlite3VdbeIntegerAffinity(pRec);
394 }
395 }
396 }else if( affinity==SQLITE_AFF_TEXT ){
397 /* Only attempt the conversion to TEXT if there is an integer or real
398 ** representation (blob and NULL do not get converted) but no string
399 ** representation. It would be harmless to repeat the conversion if
400 ** there is already a string rep, but it is pointless to waste those
401 ** CPU cycles. */
402 if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/
403 if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){
404 testcase( pRec->flags & MEM_Int );
405 testcase( pRec->flags & MEM_Real );
406 testcase( pRec->flags & MEM_IntReal );
407 sqlite3VdbeMemStringify(pRec, enc, 1);
408 }
409 }
410 pRec->flags &= ~(MEM_Real|MEM_Int|MEM_IntReal);
411 }
412}
413
414/*
415** Try to convert the type of a function argument or a result column
416** into a numeric representation. Use either INTEGER or REAL whichever
417** is appropriate. But only do the conversion if it is possible without
418** loss of information and return the revised type of the argument.
419*/
420int sqlite3_value_numeric_type(sqlite3_value *pVal){
421 int eType = sqlite3_value_type(pVal);
422 if( eType==SQLITE_TEXT ){
423 Mem *pMem = (Mem*)pVal;
424 applyNumericAffinity(pMem, 0);
425 eType = sqlite3_value_type(pVal);
426 }
427 return eType;
428}
429
430/*
431** Exported version of applyAffinity(). This one works on sqlite3_value*,
432** not the internal Mem* type.
433*/
434void sqlite3ValueApplyAffinity(
435 sqlite3_value *pVal,
436 u8 affinity,
437 u8 enc
438){
439 applyAffinity((Mem *)pVal, affinity, enc);
440}
441
442/*
443** pMem currently only holds a string type (or maybe a BLOB that we can
444** interpret as a string if we want to). Compute its corresponding
445** numeric type, if has one. Set the pMem->u.r and pMem->u.i fields
446** accordingly.
447*/
448static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){
449 int rc;
450 sqlite3_int64 ix;
451 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 );
452 assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
453 if( ExpandBlob(pMem) ){
454 pMem->u.i = 0;
455 return MEM_Int;
456 }
457 rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
458 if( rc<=0 ){
459 if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
460 pMem->u.i = ix;
461 return MEM_Int;
462 }else{
463 return MEM_Real;
464 }
465 }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){
466 pMem->u.i = ix;
467 return MEM_Int;
468 }
469 return MEM_Real;
470}
471
472/*
473** Return the numeric type for pMem, either MEM_Int or MEM_Real or both or
474** none.
475**
476** Unlike applyNumericAffinity(), this routine does not modify pMem->flags.
477** But it does set pMem->u.r and pMem->u.i appropriately.
478*/
479static u16 numericType(Mem *pMem){
480 assert( (pMem->flags & MEM_Null)==0
481 || pMem->db==0 || pMem->db->mallocFailed );
482 if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null) ){
483 testcase( pMem->flags & MEM_Int );
484 testcase( pMem->flags & MEM_Real );
485 testcase( pMem->flags & MEM_IntReal );
486 return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null);
487 }
488 assert( pMem->flags & (MEM_Str|MEM_Blob) );
489 testcase( pMem->flags & MEM_Str );
490 testcase( pMem->flags & MEM_Blob );
491 return computeNumericType(pMem);
492 return 0;
493}
494
495#ifdef SQLITE_DEBUG
496/*
497** Write a nice string representation of the contents of cell pMem
498** into buffer zBuf, length nBuf.
499*/
500void sqlite3VdbeMemPrettyPrint(Mem *pMem, StrAccum *pStr){
501 int f = pMem->flags;
502 static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"};
503 if( f&MEM_Blob ){
504 int i;
505 char c;
506 if( f & MEM_Dyn ){
507 c = 'z';
508 assert( (f & (MEM_Static|MEM_Ephem))==0 );
509 }else if( f & MEM_Static ){
510 c = 't';
511 assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
512 }else if( f & MEM_Ephem ){
513 c = 'e';
514 assert( (f & (MEM_Static|MEM_Dyn))==0 );
515 }else{
516 c = 's';
517 }
518 sqlite3_str_appendf(pStr, "%cx[", c);
519 for(i=0; i<25 && i<pMem->n; i++){
520 sqlite3_str_appendf(pStr, "%02X", ((int)pMem->z[i] & 0xFF));
521 }
522 sqlite3_str_appendf(pStr, "|");
523 for(i=0; i<25 && i<pMem->n; i++){
524 char z = pMem->z[i];
525 sqlite3_str_appendchar(pStr, 1, (z<32||z>126)?'.':z);
526 }
527 sqlite3_str_appendf(pStr,"]");
528 if( f & MEM_Zero ){
529 sqlite3_str_appendf(pStr, "+%dz",pMem->u.nZero);
530 }
531 }else if( f & MEM_Str ){
532 int j;
533 u8 c;
534 if( f & MEM_Dyn ){
535 c = 'z';
536 assert( (f & (MEM_Static|MEM_Ephem))==0 );
537 }else if( f & MEM_Static ){
538 c = 't';
539 assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
540 }else if( f & MEM_Ephem ){
541 c = 'e';
542 assert( (f & (MEM_Static|MEM_Dyn))==0 );
543 }else{
544 c = 's';
545 }
546 sqlite3_str_appendf(pStr, " %c%d[", c, pMem->n);
547 for(j=0; j<25 && j<pMem->n; j++){
548 c = pMem->z[j];
549 sqlite3_str_appendchar(pStr, 1, (c>=0x20&&c<=0x7f) ? c : '.');
550 }
551 sqlite3_str_appendf(pStr, "]%s", encnames[pMem->enc]);
552 }
553}
554#endif
555
556#ifdef SQLITE_DEBUG
557/*
558** Print the value of a register for tracing purposes:
559*/
560static void memTracePrint(Mem *p){
561 if( p->flags & MEM_Undefined ){
562 printf(" undefined");
563 }else if( p->flags & MEM_Null ){
564 printf(p->flags & MEM_Zero ? " NULL-nochng" : " NULL");
565 }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
566 printf(" si:%lld", p->u.i);
567 }else if( (p->flags & (MEM_IntReal))!=0 ){
568 printf(" ir:%lld", p->u.i);
569 }else if( p->flags & MEM_Int ){
570 printf(" i:%lld", p->u.i);
571#ifndef SQLITE_OMIT_FLOATING_POINT
572 }else if( p->flags & MEM_Real ){
573 printf(" r:%.17g", p->u.r);
574#endif
575 }else if( sqlite3VdbeMemIsRowSet(p) ){
576 printf(" (rowset)");
577 }else{
578 StrAccum acc;
579 char zBuf[1000];
580 sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
581 sqlite3VdbeMemPrettyPrint(p, &acc);
582 printf(" %s", sqlite3StrAccumFinish(&acc));
583 }
584 if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x", p->eSubtype);
585}
586static void registerTrace(int iReg, Mem *p){
587 printf("R[%d] = ", iReg);
588 memTracePrint(p);
589 if( p->pScopyFrom ){
590 printf(" <== R[%d]", (int)(p->pScopyFrom - &p[-iReg]));
591 }
592 printf("\n");
593 sqlite3VdbeCheckMemInvariants(p);
594}
595/**/ void sqlite3PrintMem(Mem *pMem){
596 memTracePrint(pMem);
597 printf("\n");
598 fflush(stdout);
599}
600#endif
601
602#ifdef SQLITE_DEBUG
603/*
604** Show the values of all registers in the virtual machine. Used for
605** interactive debugging.
606*/
607void sqlite3VdbeRegisterDump(Vdbe *v){
608 int i;
609 for(i=1; i<v->nMem; i++) registerTrace(i, v->aMem+i);
610}
611#endif /* SQLITE_DEBUG */
612
613
614#ifdef SQLITE_DEBUG
615# define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M)
616#else
617# define REGISTER_TRACE(R,M)
618#endif
619
620
621#ifdef VDBE_PROFILE
622
623/*
624** hwtime.h contains inline assembler code for implementing
625** high-performance timing routines.
626*/
627#include "hwtime.h"
628
629#endif
630
631#ifndef NDEBUG
632/*
633** This function is only called from within an assert() expression. It
634** checks that the sqlite3.nTransaction variable is correctly set to
635** the number of non-transaction savepoints currently in the
636** linked list starting at sqlite3.pSavepoint.
637**
638** Usage:
639**
640** assert( checkSavepointCount(db) );
641*/
642static int checkSavepointCount(sqlite3 *db){
643 int n = 0;
644 Savepoint *p;
645 for(p=db->pSavepoint; p; p=p->pNext) n++;
646 assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
647 return 1;
648}
649#endif
650
651/*
652** Return the register of pOp->p2 after first preparing it to be
653** overwritten with an integer value.
654*/
655static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){
656 sqlite3VdbeMemSetNull(pOut);
657 pOut->flags = MEM_Int;
658 return pOut;
659}
660static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
661 Mem *pOut;
662 assert( pOp->p2>0 );
663 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
664 pOut = &p->aMem[pOp->p2];
665 memAboutToChange(p, pOut);
666 if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/
667 return out2PrereleaseWithClear(pOut);
668 }else{
669 pOut->flags = MEM_Int;
670 return pOut;
671 }
672}
673
674/*
675** Compute a bloom filter hash using pOp->p4.i registers from aMem[] beginning
676** with pOp->p3. Return the hash.
677*/
678static u64 filterHash(const Mem *aMem, const Op *pOp){
679 int i, mx;
680 u64 h = 0;
681
682 assert( pOp->p4type==P4_INT32 );
683 for(i=pOp->p3, mx=i+pOp->p4.i; i<mx; i++){
684 const Mem *p = &aMem[i];
685 if( p->flags & (MEM_Int|MEM_IntReal) ){
686 h += p->u.i;
687 }else if( p->flags & MEM_Real ){
688 h += sqlite3VdbeIntValue(p);
689 }else if( p->flags & (MEM_Str|MEM_Blob) ){
690 h += p->n;
691 if( p->flags & MEM_Zero ) h += p->u.nZero;
692 }
693 }
694 return h;
695}
696
697/*
698** Return the symbolic name for the data type of a pMem
699*/
700static const char *vdbeMemTypeName(Mem *pMem){
701 static const char *azTypes[] = {
702 /* SQLITE_INTEGER */ "INT",
703 /* SQLITE_FLOAT */ "REAL",
704 /* SQLITE_TEXT */ "TEXT",
705 /* SQLITE_BLOB */ "BLOB",
706 /* SQLITE_NULL */ "NULL"
707 };
708 return azTypes[sqlite3_value_type(pMem)-1];
709}
710
711/*
712** Execute as much of a VDBE program as we can.
713** This is the core of sqlite3_step().
714*/
715int sqlite3VdbeExec(
716 Vdbe *p /* The VDBE */
717){
718 Op *aOp = p->aOp; /* Copy of p->aOp */
719 Op *pOp = aOp; /* Current operation */
720#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
721 Op *pOrigOp; /* Value of pOp at the top of the loop */
722#endif
723#ifdef SQLITE_DEBUG
724 int nExtraDelete = 0; /* Verifies FORDELETE and AUXDELETE flags */
725#endif
726 int rc = SQLITE_OK; /* Value to return */
727 sqlite3 *db = p->db; /* The database */
728 u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */
729 u8 encoding = ENC(db); /* The database encoding */
730 int iCompare = 0; /* Result of last comparison */
731 u64 nVmStep = 0; /* Number of virtual machine steps */
732#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
733 u64 nProgressLimit; /* Invoke xProgress() when nVmStep reaches this */
734#endif
735 Mem *aMem = p->aMem; /* Copy of p->aMem */
736 Mem *pIn1 = 0; /* 1st input operand */
737 Mem *pIn2 = 0; /* 2nd input operand */
738 Mem *pIn3 = 0; /* 3rd input operand */
739 Mem *pOut = 0; /* Output operand */
740#ifdef VDBE_PROFILE
741 u64 start; /* CPU clock count at start of opcode */
742#endif
743 /*** INSERT STACK UNION HERE ***/
744
745 assert( p->eVdbeState==VDBE_RUN_STATE ); /* sqlite3_step() verifies this */
746 sqlite3VdbeEnter(p);
747#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
748 if( db->xProgress ){
749 u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP];
750 assert( 0 < db->nProgressOps );
751 nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps);
752 }else{
753 nProgressLimit = LARGEST_UINT64;
754 }
755#endif
756 if( p->rc==SQLITE_NOMEM ){
757 /* This happens if a malloc() inside a call to sqlite3_column_text() or
758 ** sqlite3_column_text16() failed. */
759 goto no_mem;
760 }
761 assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY );
762 testcase( p->rc!=SQLITE_OK );
763 p->rc = SQLITE_OK;
764 assert( p->bIsReader || p->readOnly!=0 );
765 p->iCurrentTime = 0;
766 assert( p->explain==0 );
767 p->pResultSet = 0;
768 db->busyHandler.nBusy = 0;
769 if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt;
770 sqlite3VdbeIOTraceSql(p);
771#ifdef SQLITE_DEBUG
772 sqlite3BeginBenignMalloc();
773 if( p->pc==0
774 && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
775 ){
776 int i;
777 int once = 1;
778 sqlite3VdbePrintSql(p);
779 if( p->db->flags & SQLITE_VdbeListing ){
780 printf("VDBE Program Listing:\n");
781 for(i=0; i<p->nOp; i++){
782 sqlite3VdbePrintOp(stdout, i, &aOp[i]);
783 }
784 }
785 if( p->db->flags & SQLITE_VdbeEQP ){
786 for(i=0; i<p->nOp; i++){
787 if( aOp[i].opcode==OP_Explain ){
788 if( once ) printf("VDBE Query Plan:\n");
789 printf("%s\n", aOp[i].p4.z);
790 once = 0;
791 }
792 }
793 }
794 if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n");
795 }
796 sqlite3EndBenignMalloc();
797#endif
798 for(pOp=&aOp[p->pc]; 1; pOp++){
799 /* Errors are detected by individual opcodes, with an immediate
800 ** jumps to abort_due_to_error. */
801 assert( rc==SQLITE_OK );
802
803 assert( pOp>=aOp && pOp<&aOp[p->nOp]);
804#ifdef VDBE_PROFILE
805 start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
806#endif
807 nVmStep++;
808#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
809 if( p->anExec ) p->anExec[(int)(pOp-aOp)]++;
810#endif
811
812 /* Only allow tracing if SQLITE_DEBUG is defined.
813 */
814#ifdef SQLITE_DEBUG
815 if( db->flags & SQLITE_VdbeTrace ){
816 sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp);
817 test_trace_breakpoint((int)(pOp - aOp),pOp,p);
818 }
819#endif
820
821
822 /* Check to see if we need to simulate an interrupt. This only happens
823 ** if we have a special test build.
824 */
825#ifdef SQLITE_TEST
826 if( sqlite3_interrupt_count>0 ){
827 sqlite3_interrupt_count--;
828 if( sqlite3_interrupt_count==0 ){
829 sqlite3_interrupt(db);
830 }
831 }
832#endif
833
834 /* Sanity checking on other operands */
835#ifdef SQLITE_DEBUG
836 {
837 u8 opProperty = sqlite3OpcodeProperty[pOp->opcode];
838 if( (opProperty & OPFLG_IN1)!=0 ){
839 assert( pOp->p1>0 );
840 assert( pOp->p1<=(p->nMem+1 - p->nCursor) );
841 assert( memIsValid(&aMem[pOp->p1]) );
842 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
843 REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
844 }
845 if( (opProperty & OPFLG_IN2)!=0 ){
846 assert( pOp->p2>0 );
847 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
848 assert( memIsValid(&aMem[pOp->p2]) );
849 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
850 REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
851 }
852 if( (opProperty & OPFLG_IN3)!=0 ){
853 assert( pOp->p3>0 );
854 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
855 assert( memIsValid(&aMem[pOp->p3]) );
856 assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
857 REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
858 }
859 if( (opProperty & OPFLG_OUT2)!=0 ){
860 assert( pOp->p2>0 );
861 assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
862 memAboutToChange(p, &aMem[pOp->p2]);
863 }
864 if( (opProperty & OPFLG_OUT3)!=0 ){
865 assert( pOp->p3>0 );
866 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
867 memAboutToChange(p, &aMem[pOp->p3]);
868 }
869 }
870#endif
871#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
872 pOrigOp = pOp;
873#endif
874
875 switch( pOp->opcode ){
876
877/*****************************************************************************
878** What follows is a massive switch statement where each case implements a
879** separate instruction in the virtual machine. If we follow the usual
880** indentation conventions, each case should be indented by 6 spaces. But
881** that is a lot of wasted space on the left margin. So the code within
882** the switch statement will break with convention and be flush-left. Another
883** big comment (similar to this one) will mark the point in the code where
884** we transition back to normal indentation.
885**
886** The formatting of each case is important. The makefile for SQLite
887** generates two C files "opcodes.h" and "opcodes.c" by scanning this
888** file looking for lines that begin with "case OP_". The opcodes.h files
889** will be filled with #defines that give unique integer values to each
890** opcode and the opcodes.c file is filled with an array of strings where
891** each string is the symbolic name for the corresponding opcode. If the
892** case statement is followed by a comment of the form "/# same as ... #/"
893** that comment is used to determine the particular value of the opcode.
894**
895** Other keywords in the comment that follows each case are used to
896** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
897** Keywords include: in1, in2, in3, out2, out3. See
898** the mkopcodeh.awk script for additional information.
899**
900** Documentation about VDBE opcodes is generated by scanning this file
901** for lines of that contain "Opcode:". That line and all subsequent
902** comment lines are used in the generation of the opcode.html documentation
903** file.
904**
905** SUMMARY:
906**
907** Formatting is important to scripts that scan this file.
908** Do not deviate from the formatting style currently in use.
909**
910*****************************************************************************/
911
912/* Opcode: Goto * P2 * * *
913**
914** An unconditional jump to address P2.
915** The next instruction executed will be
916** the one at index P2 from the beginning of
917** the program.
918**
919** The P1 parameter is not actually used by this opcode. However, it
920** is sometimes set to 1 instead of 0 as a hint to the command-line shell
921** that this Goto is the bottom of a loop and that the lines from P2 down
922** to the current line should be indented for EXPLAIN output.
923*/
924case OP_Goto: { /* jump */
925
926#ifdef SQLITE_DEBUG
927 /* In debuggging mode, when the p5 flags is set on an OP_Goto, that
928 ** means we should really jump back to the preceeding OP_ReleaseReg
929 ** instruction. */
930 if( pOp->p5 ){
931 assert( pOp->p2 < (int)(pOp - aOp) );
932 assert( pOp->p2 > 1 );
933 pOp = &aOp[pOp->p2 - 2];
934 assert( pOp[1].opcode==OP_ReleaseReg );
935 goto check_for_interrupt;
936 }
937#endif
938
939jump_to_p2_and_check_for_interrupt:
940 pOp = &aOp[pOp->p2 - 1];
941
942 /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev,
943 ** OP_VNext, or OP_SorterNext) all jump here upon
944 ** completion. Check to see if sqlite3_interrupt() has been called
945 ** or if the progress callback needs to be invoked.
946 **
947 ** This code uses unstructured "goto" statements and does not look clean.
948 ** But that is not due to sloppy coding habits. The code is written this
949 ** way for performance, to avoid having to run the interrupt and progress
950 ** checks on every opcode. This helps sqlite3_step() to run about 1.5%
951 ** faster according to "valgrind --tool=cachegrind" */
952check_for_interrupt:
953 if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt;
954#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
955 /* Call the progress callback if it is configured and the required number
956 ** of VDBE ops have been executed (either since this invocation of
957 ** sqlite3VdbeExec() or since last time the progress callback was called).
958 ** If the progress callback returns non-zero, exit the virtual machine with
959 ** a return code SQLITE_ABORT.
960 */
961 while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
962 assert( db->nProgressOps!=0 );
963 nProgressLimit += db->nProgressOps;
964 if( db->xProgress(db->pProgressArg) ){
965 nProgressLimit = LARGEST_UINT64;
966 rc = SQLITE_INTERRUPT;
967 goto abort_due_to_error;
968 }
969 }
970#endif
971
972 break;
973}
974
975/* Opcode: Gosub P1 P2 * * *
976**
977** Write the current address onto register P1
978** and then jump to address P2.
979*/
980case OP_Gosub: { /* jump */
981 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
982 pIn1 = &aMem[pOp->p1];
983 assert( VdbeMemDynamic(pIn1)==0 );
984 memAboutToChange(p, pIn1);
985 pIn1->flags = MEM_Int;
986 pIn1->u.i = (int)(pOp-aOp);
987 REGISTER_TRACE(pOp->p1, pIn1);
988 goto jump_to_p2_and_check_for_interrupt;
989}
990
991/* Opcode: Return P1 P2 P3 * *
992**
993** Jump to the address stored in register P1. If P1 is a return address
994** register, then this accomplishes a return from a subroutine.
995**
996** If P3 is 1, then the jump is only taken if register P1 holds an integer
997** values, otherwise execution falls through to the next opcode, and the
998** OP_Return becomes a no-op. If P3 is 0, then register P1 must hold an
999** integer or else an assert() is raised. P3 should be set to 1 when
1000** this opcode is used in combination with OP_BeginSubrtn, and set to 0
1001** otherwise.
1002**
1003** The value in register P1 is unchanged by this opcode.
1004**
1005** P2 is not used by the byte-code engine. However, if P2 is positive
1006** and also less than the current address, then the "EXPLAIN" output
1007** formatter in the CLI will indent all opcodes from the P2 opcode up
1008** to be not including the current Return. P2 should be the first opcode
1009** in the subroutine from which this opcode is returning. Thus the P2
1010** value is a byte-code indentation hint. See tag-20220407a in
1011** wherecode.c and shell.c.
1012*/
1013case OP_Return: { /* in1 */
1014 pIn1 = &aMem[pOp->p1];
1015 if( pIn1->flags & MEM_Int ){
1016 if( pOp->p3 ){ VdbeBranchTaken(1, 2); }
1017 pOp = &aOp[pIn1->u.i];
1018 }else if( ALWAYS(pOp->p3) ){
1019 VdbeBranchTaken(0, 2);
1020 }
1021 break;
1022}
1023
1024/* Opcode: InitCoroutine P1 P2 P3 * *
1025**
1026** Set up register P1 so that it will Yield to the coroutine
1027** located at address P3.
1028**
1029** If P2!=0 then the coroutine implementation immediately follows
1030** this opcode. So jump over the coroutine implementation to
1031** address P2.
1032**
1033** See also: EndCoroutine
1034*/
1035case OP_InitCoroutine: { /* jump */
1036 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
1037 assert( pOp->p2>=0 && pOp->p2<p->nOp );
1038 assert( pOp->p3>=0 && pOp->p3<p->nOp );
1039 pOut = &aMem[pOp->p1];
1040 assert( !VdbeMemDynamic(pOut) );
1041 pOut->u.i = pOp->p3 - 1;
1042 pOut->flags = MEM_Int;
1043 if( pOp->p2==0 ) break;
1044
1045 /* Most jump operations do a goto to this spot in order to update
1046 ** the pOp pointer. */
1047jump_to_p2:
1048 assert( pOp->p2>0 ); /* There are never any jumps to instruction 0 */
1049 assert( pOp->p2<p->nOp ); /* Jumps must be in range */
1050 pOp = &aOp[pOp->p2 - 1];
1051 break;
1052}
1053
1054/* Opcode: EndCoroutine P1 * * * *
1055**
1056** The instruction at the address in register P1 is a Yield.
1057** Jump to the P2 parameter of that Yield.
1058** After the jump, register P1 becomes undefined.
1059**
1060** See also: InitCoroutine
1061*/
1062case OP_EndCoroutine: { /* in1 */
1063 VdbeOp *pCaller;
1064 pIn1 = &aMem[pOp->p1];
1065 assert( pIn1->flags==MEM_Int );
1066 assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
1067 pCaller = &aOp[pIn1->u.i];
1068 assert( pCaller->opcode==OP_Yield );
1069 assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
1070 pOp = &aOp[pCaller->p2 - 1];
1071 pIn1->flags = MEM_Undefined;
1072 break;
1073}
1074
1075/* Opcode: Yield P1 P2 * * *
1076**
1077** Swap the program counter with the value in register P1. This
1078** has the effect of yielding to a coroutine.
1079**
1080** If the coroutine that is launched by this instruction ends with
1081** Yield or Return then continue to the next instruction. But if
1082** the coroutine launched by this instruction ends with
1083** EndCoroutine, then jump to P2 rather than continuing with the
1084** next instruction.
1085**
1086** See also: InitCoroutine
1087*/
1088case OP_Yield: { /* in1, jump */
1089 int pcDest;
1090 pIn1 = &aMem[pOp->p1];
1091 assert( VdbeMemDynamic(pIn1)==0 );
1092 pIn1->flags = MEM_Int;
1093 pcDest = (int)pIn1->u.i;
1094 pIn1->u.i = (int)(pOp - aOp);
1095 REGISTER_TRACE(pOp->p1, pIn1);
1096 pOp = &aOp[pcDest];
1097 break;
1098}
1099
1100/* Opcode: HaltIfNull P1 P2 P3 P4 P5
1101** Synopsis: if r[P3]=null halt
1102**
1103** Check the value in register P3. If it is NULL then Halt using
1104** parameter P1, P2, and P4 as if this were a Halt instruction. If the
1105** value in register P3 is not NULL, then this routine is a no-op.
1106** The P5 parameter should be 1.
1107*/
1108case OP_HaltIfNull: { /* in3 */
1109 pIn3 = &aMem[pOp->p3];
1110#ifdef SQLITE_DEBUG
1111 if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
1112#endif
1113 if( (pIn3->flags & MEM_Null)==0 ) break;
1114 /* Fall through into OP_Halt */
1115 /* no break */ deliberate_fall_through
1116}
1117
1118/* Opcode: Halt P1 P2 * P4 P5
1119**
1120** Exit immediately. All open cursors, etc are closed
1121** automatically.
1122**
1123** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
1124** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0).
1125** For errors, it can be some other value. If P1!=0 then P2 will determine
1126** whether or not to rollback the current transaction. Do not rollback
1127** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort,
1128** then back out all changes that have occurred during this execution of the
1129** VDBE, but do not rollback the transaction.
1130**
1131** If P4 is not null then it is an error message string.
1132**
1133** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
1134**
1135** 0: (no change)
1136** 1: NOT NULL contraint failed: P4
1137** 2: UNIQUE constraint failed: P4
1138** 3: CHECK constraint failed: P4
1139** 4: FOREIGN KEY constraint failed: P4
1140**
1141** If P5 is not zero and P4 is NULL, then everything after the ":" is
1142** omitted.
1143**
1144** There is an implied "Halt 0 0 0" instruction inserted at the very end of
1145** every program. So a jump past the last instruction of the program
1146** is the same as executing Halt.
1147*/
1148case OP_Halt: {
1149 VdbeFrame *pFrame;
1150 int pcx;
1151
1152#ifdef SQLITE_DEBUG
1153 if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
1154#endif
1155 if( p->pFrame && pOp->p1==SQLITE_OK ){
1156 /* Halt the sub-program. Return control to the parent frame. */
1157 pFrame = p->pFrame;
1158 p->pFrame = pFrame->pParent;
1159 p->nFrame--;
1160 sqlite3VdbeSetChanges(db, p->nChange);
1161 pcx = sqlite3VdbeFrameRestore(pFrame);
1162 if( pOp->p2==OE_Ignore ){
1163 /* Instruction pcx is the OP_Program that invoked the sub-program
1164 ** currently being halted. If the p2 instruction of this OP_Halt
1165 ** instruction is set to OE_Ignore, then the sub-program is throwing
1166 ** an IGNORE exception. In this case jump to the address specified
1167 ** as the p2 of the calling OP_Program. */
1168 pcx = p->aOp[pcx].p2-1;
1169 }
1170 aOp = p->aOp;
1171 aMem = p->aMem;
1172 pOp = &aOp[pcx];
1173 break;
1174 }
1175 p->rc = pOp->p1;
1176 p->errorAction = (u8)pOp->p2;
1177 assert( pOp->p5<=4 );
1178 if( p->rc ){
1179 if( pOp->p5 ){
1180 static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK",
1181 "FOREIGN KEY" };
1182 testcase( pOp->p5==1 );
1183 testcase( pOp->p5==2 );
1184 testcase( pOp->p5==3 );
1185 testcase( pOp->p5==4 );
1186 sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]);
1187 if( pOp->p4.z ){
1188 p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z);
1189 }
1190 }else{
1191 sqlite3VdbeError(p, "%s", pOp->p4.z);
1192 }
1193 pcx = (int)(pOp - aOp);
1194 sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pcx, p->zSql, p->zErrMsg);
1195 }
1196 rc = sqlite3VdbeHalt(p);
1197 assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
1198 if( rc==SQLITE_BUSY ){
1199 p->rc = SQLITE_BUSY;
1200 }else{
1201 assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
1202 assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
1203 rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
1204 }
1205 goto vdbe_return;
1206}
1207
1208/* Opcode: Integer P1 P2 * * *
1209** Synopsis: r[P2]=P1
1210**
1211** The 32-bit integer value P1 is written into register P2.
1212*/
1213case OP_Integer: { /* out2 */
1214 pOut = out2Prerelease(p, pOp);
1215 pOut->u.i = pOp->p1;
1216 break;
1217}
1218
1219/* Opcode: Int64 * P2 * P4 *
1220** Synopsis: r[P2]=P4
1221**
1222** P4 is a pointer to a 64-bit integer value.
1223** Write that value into register P2.
1224*/
1225case OP_Int64: { /* out2 */
1226 pOut = out2Prerelease(p, pOp);
1227 assert( pOp->p4.pI64!=0 );
1228 pOut->u.i = *pOp->p4.pI64;
1229 break;
1230}
1231
1232#ifndef SQLITE_OMIT_FLOATING_POINT
1233/* Opcode: Real * P2 * P4 *
1234** Synopsis: r[P2]=P4
1235**
1236** P4 is a pointer to a 64-bit floating point value.
1237** Write that value into register P2.
1238*/
1239case OP_Real: { /* same as TK_FLOAT, out2 */
1240 pOut = out2Prerelease(p, pOp);
1241 pOut->flags = MEM_Real;
1242 assert( !sqlite3IsNaN(*pOp->p4.pReal) );
1243 pOut->u.r = *pOp->p4.pReal;
1244 break;
1245}
1246#endif
1247
1248/* Opcode: String8 * P2 * P4 *
1249** Synopsis: r[P2]='P4'
1250**
1251** P4 points to a nul terminated UTF-8 string. This opcode is transformed
1252** into a String opcode before it is executed for the first time. During
1253** this transformation, the length of string P4 is computed and stored
1254** as the P1 parameter.
1255*/
1256case OP_String8: { /* same as TK_STRING, out2 */
1257 assert( pOp->p4.z!=0 );
1258 pOut = out2Prerelease(p, pOp);
1259 pOp->p1 = sqlite3Strlen30(pOp->p4.z);
1260
1261#ifndef SQLITE_OMIT_UTF16
1262 if( encoding!=SQLITE_UTF8 ){
1263 rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
1264 assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG );
1265 if( rc ) goto too_big;
1266 if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
1267 assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
1268 assert( VdbeMemDynamic(pOut)==0 );
1269 pOut->szMalloc = 0;
1270 pOut->flags |= MEM_Static;
1271 if( pOp->p4type==P4_DYNAMIC ){
1272 sqlite3DbFree(db, pOp->p4.z);
1273 }
1274 pOp->p4type = P4_DYNAMIC;
1275 pOp->p4.z = pOut->z;
1276 pOp->p1 = pOut->n;
1277 }
1278#endif
1279 if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
1280 goto too_big;
1281 }
1282 pOp->opcode = OP_String;
1283 assert( rc==SQLITE_OK );
1284 /* Fall through to the next case, OP_String */
1285 /* no break */ deliberate_fall_through
1286}
1287
1288/* Opcode: String P1 P2 P3 P4 P5
1289** Synopsis: r[P2]='P4' (len=P1)
1290**
1291** The string value P4 of length P1 (bytes) is stored in register P2.
1292**
1293** If P3 is not zero and the content of register P3 is equal to P5, then
1294** the datatype of the register P2 is converted to BLOB. The content is
1295** the same sequence of bytes, it is merely interpreted as a BLOB instead
1296** of a string, as if it had been CAST. In other words:
1297**
1298** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB)
1299*/
1300case OP_String: { /* out2 */
1301 assert( pOp->p4.z!=0 );
1302 pOut = out2Prerelease(p, pOp);
1303 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
1304 pOut->z = pOp->p4.z;
1305 pOut->n = pOp->p1;
1306 pOut->enc = encoding;
1307 UPDATE_MAX_BLOBSIZE(pOut);
1308#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS
1309 if( pOp->p3>0 ){
1310 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
1311 pIn3 = &aMem[pOp->p3];
1312 assert( pIn3->flags & MEM_Int );
1313 if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
1314 }
1315#endif
1316 break;
1317}
1318
1319/* Opcode: BeginSubrtn * P2 * * *
1320** Synopsis: r[P2]=NULL
1321**
1322** Mark the beginning of a subroutine that can be entered in-line
1323** or that can be called using OP_Gosub. The subroutine should
1324** be terminated by an OP_Return instruction that has a P1 operand that
1325** is the same as the P2 operand to this opcode and that has P3 set to 1.
1326** If the subroutine is entered in-line, then the OP_Return will simply
1327** fall through. But if the subroutine is entered using OP_Gosub, then
1328** the OP_Return will jump back to the first instruction after the OP_Gosub.
1329**
1330** This routine works by loading a NULL into the P2 register. When the
1331** return address register contains a NULL, the OP_Return instruction is
1332** a no-op that simply falls through to the next instruction (assuming that
1333** the OP_Return opcode has a P3 value of 1). Thus if the subroutine is
1334** entered in-line, then the OP_Return will cause in-line execution to
1335** continue. But if the subroutine is entered via OP_Gosub, then the
1336** OP_Return will cause a return to the address following the OP_Gosub.
1337**
1338** This opcode is identical to OP_Null. It has a different name
1339** only to make the byte code easier to read and verify.
1340*/
1341/* Opcode: Null P1 P2 P3 * *
1342** Synopsis: r[P2..P3]=NULL
1343**
1344** Write a NULL into registers P2. If P3 greater than P2, then also write
1345** NULL into register P3 and every register in between P2 and P3. If P3
1346** is less than P2 (typically P3 is zero) then only register P2 is
1347** set to NULL.
1348**
1349** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
1350** NULL values will not compare equal even if SQLITE_NULLEQ is set on
1351** OP_Ne or OP_Eq.
1352*/
1353case OP_BeginSubrtn:
1354case OP_Null: { /* out2 */
1355 int cnt;
1356 u16 nullFlag;
1357 pOut = out2Prerelease(p, pOp);
1358 cnt = pOp->p3-pOp->p2;
1359 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
1360 pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
1361 pOut->n = 0;
1362#ifdef SQLITE_DEBUG
1363 pOut->uTemp = 0;
1364#endif
1365 while( cnt>0 ){
1366 pOut++;
1367 memAboutToChange(p, pOut);
1368 sqlite3VdbeMemSetNull(pOut);
1369 pOut->flags = nullFlag;
1370 pOut->n = 0;
1371 cnt--;
1372 }
1373 break;
1374}
1375
1376/* Opcode: SoftNull P1 * * * *
1377** Synopsis: r[P1]=NULL
1378**
1379** Set register P1 to have the value NULL as seen by the OP_MakeRecord
1380** instruction, but do not free any string or blob memory associated with
1381** the register, so that if the value was a string or blob that was
1382** previously copied using OP_SCopy, the copies will continue to be valid.
1383*/
1384case OP_SoftNull: {
1385 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
1386 pOut = &aMem[pOp->p1];
1387 pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null;
1388 break;
1389}
1390
1391/* Opcode: Blob P1 P2 * P4 *
1392** Synopsis: r[P2]=P4 (len=P1)
1393**
1394** P4 points to a blob of data P1 bytes long. Store this
1395** blob in register P2. If P4 is a NULL pointer, then construct
1396** a zero-filled blob that is P1 bytes long in P2.
1397*/
1398case OP_Blob: { /* out2 */
1399 assert( pOp->p1 <= SQLITE_MAX_LENGTH );
1400 pOut = out2Prerelease(p, pOp);
1401 if( pOp->p4.z==0 ){
1402 sqlite3VdbeMemSetZeroBlob(pOut, pOp->p1);
1403 if( sqlite3VdbeMemExpandBlob(pOut) ) goto no_mem;
1404 }else{
1405 sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
1406 }
1407 pOut->enc = encoding;
1408 UPDATE_MAX_BLOBSIZE(pOut);
1409 break;
1410}
1411
1412/* Opcode: Variable P1 P2 * P4 *
1413** Synopsis: r[P2]=parameter(P1,P4)
1414**
1415** Transfer the values of bound parameter P1 into register P2
1416**
1417** If the parameter is named, then its name appears in P4.
1418** The P4 value is used by sqlite3_bind_parameter_name().
1419*/
1420case OP_Variable: { /* out2 */
1421 Mem *pVar; /* Value being transferred */
1422
1423 assert( pOp->p1>0 && pOp->p1<=p->nVar );
1424 assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) );
1425 pVar = &p->aVar[pOp->p1 - 1];
1426 if( sqlite3VdbeMemTooBig(pVar) ){
1427 goto too_big;
1428 }
1429 pOut = &aMem[pOp->p2];
1430 if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut);
1431 memcpy(pOut, pVar, MEMCELLSIZE);
1432 pOut->flags &= ~(MEM_Dyn|MEM_Ephem);
1433 pOut->flags |= MEM_Static|MEM_FromBind;
1434 UPDATE_MAX_BLOBSIZE(pOut);
1435 break;
1436}
1437
1438/* Opcode: Move P1 P2 P3 * *
1439** Synopsis: r[P2@P3]=r[P1@P3]
1440**
1441** Move the P3 values in register P1..P1+P3-1 over into
1442** registers P2..P2+P3-1. Registers P1..P1+P3-1 are
1443** left holding a NULL. It is an error for register ranges
1444** P1..P1+P3-1 and P2..P2+P3-1 to overlap. It is an error
1445** for P3 to be less than 1.
1446*/
1447case OP_Move: {
1448 int n; /* Number of registers left to copy */
1449 int p1; /* Register to copy from */
1450 int p2; /* Register to copy to */
1451
1452 n = pOp->p3;
1453 p1 = pOp->p1;
1454 p2 = pOp->p2;
1455 assert( n>0 && p1>0 && p2>0 );
1456 assert( p1+n<=p2 || p2+n<=p1 );
1457
1458 pIn1 = &aMem[p1];
1459 pOut = &aMem[p2];
1460 do{
1461 assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
1462 assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] );
1463 assert( memIsValid(pIn1) );
1464 memAboutToChange(p, pOut);
1465 sqlite3VdbeMemMove(pOut, pIn1);
1466#ifdef SQLITE_DEBUG
1467 pIn1->pScopyFrom = 0;
1468 { int i;
1469 for(i=1; i<p->nMem; i++){
1470 if( aMem[i].pScopyFrom==pIn1 ){
1471 aMem[i].pScopyFrom = pOut;
1472 }
1473 }
1474 }
1475#endif
1476 Deephemeralize(pOut);
1477 REGISTER_TRACE(p2++, pOut);
1478 pIn1++;
1479 pOut++;
1480 }while( --n );
1481 break;
1482}
1483
1484/* Opcode: Copy P1 P2 P3 * P5
1485** Synopsis: r[P2@P3+1]=r[P1@P3+1]
1486**
1487** Make a copy of registers P1..P1+P3 into registers P2..P2+P3.
1488**
1489** If the 0x0002 bit of P5 is set then also clear the MEM_Subtype flag in the
1490** destination. The 0x0001 bit of P5 indicates that this Copy opcode cannot
1491** be merged. The 0x0001 bit is used by the query planner and does not
1492** come into play during query execution.
1493**
1494** This instruction makes a deep copy of the value. A duplicate
1495** is made of any string or blob constant. See also OP_SCopy.
1496*/
1497case OP_Copy: {
1498 int n;
1499
1500 n = pOp->p3;
1501 pIn1 = &aMem[pOp->p1];
1502 pOut = &aMem[pOp->p2];
1503 assert( pOut!=pIn1 );
1504 while( 1 ){
1505 memAboutToChange(p, pOut);
1506 sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
1507 Deephemeralize(pOut);
1508 if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){
1509 pOut->flags &= ~MEM_Subtype;
1510 }
1511#ifdef SQLITE_DEBUG
1512 pOut->pScopyFrom = 0;
1513#endif
1514 REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
1515 if( (n--)==0 ) break;
1516 pOut++;
1517 pIn1++;
1518 }
1519 break;
1520}
1521
1522/* Opcode: SCopy P1 P2 * * *
1523** Synopsis: r[P2]=r[P1]
1524**
1525** Make a shallow copy of register P1 into register P2.
1526**
1527** This instruction makes a shallow copy of the value. If the value
1528** is a string or blob, then the copy is only a pointer to the
1529** original and hence if the original changes so will the copy.
1530** Worse, if the original is deallocated, the copy becomes invalid.
1531** Thus the program must guarantee that the original will not change
1532** during the lifetime of the copy. Use OP_Copy to make a complete
1533** copy.
1534*/
1535case OP_SCopy: { /* out2 */
1536 pIn1 = &aMem[pOp->p1];
1537 pOut = &aMem[pOp->p2];
1538 assert( pOut!=pIn1 );
1539 sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
1540#ifdef SQLITE_DEBUG
1541 pOut->pScopyFrom = pIn1;
1542 pOut->mScopyFlags = pIn1->flags;
1543#endif
1544 break;
1545}
1546
1547/* Opcode: IntCopy P1 P2 * * *
1548** Synopsis: r[P2]=r[P1]
1549**
1550** Transfer the integer value held in register P1 into register P2.
1551**
1552** This is an optimized version of SCopy that works only for integer
1553** values.
1554*/
1555case OP_IntCopy: { /* out2 */
1556 pIn1 = &aMem[pOp->p1];
1557 assert( (pIn1->flags & MEM_Int)!=0 );
1558 pOut = &aMem[pOp->p2];
1559 sqlite3VdbeMemSetInt64(pOut, pIn1->u.i);
1560 break;
1561}
1562
1563/* Opcode: FkCheck * * * * *
1564**
1565** Halt with an SQLITE_CONSTRAINT error if there are any unresolved
1566** foreign key constraint violations. If there are no foreign key
1567** constraint violations, this is a no-op.
1568**
1569** FK constraint violations are also checked when the prepared statement
1570** exits. This opcode is used to raise foreign key constraint errors prior
1571** to returning results such as a row change count or the result of a
1572** RETURNING clause.
1573*/
1574case OP_FkCheck: {
1575 if( (rc = sqlite3VdbeCheckFk(p,0))!=SQLITE_OK ){
1576 goto abort_due_to_error;
1577 }
1578 break;
1579}
1580
1581/* Opcode: ResultRow P1 P2 * * *
1582** Synopsis: output=r[P1@P2]
1583**
1584** The registers P1 through P1+P2-1 contain a single row of
1585** results. This opcode causes the sqlite3_step() call to terminate
1586** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
1587** structure to provide access to the r(P1)..r(P1+P2-1) values as
1588** the result row.
1589*/
1590case OP_ResultRow: {
1591 assert( p->nResColumn==pOp->p2 );
1592 assert( pOp->p1>0 || CORRUPT_DB );
1593 assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
1594
1595 p->cacheCtr = (p->cacheCtr + 2)|1;
1596 p->pResultSet = &aMem[pOp->p1];
1597#ifdef SQLITE_DEBUG
1598 {
1599 Mem *pMem = p->pResultSet;
1600 int i;
1601 for(i=0; i<pOp->p2; i++){
1602 assert( memIsValid(&pMem[i]) );
1603 REGISTER_TRACE(pOp->p1+i, &pMem[i]);
1604 /* The registers in the result will not be used again when the
1605 ** prepared statement restarts. This is because sqlite3_column()
1606 ** APIs might have caused type conversions of made other changes to
1607 ** the register values. Therefore, we can go ahead and break any
1608 ** OP_SCopy dependencies. */
1609 pMem[i].pScopyFrom = 0;
1610 }
1611 }
1612#endif
1613 if( db->mallocFailed ) goto no_mem;
1614 if( db->mTrace & SQLITE_TRACE_ROW ){
1615 db->trace.xV2(SQLITE_TRACE_ROW, db->pTraceArg, p, 0);
1616 }
1617 p->pc = (int)(pOp - aOp) + 1;
1618 rc = SQLITE_ROW;
1619 goto vdbe_return;
1620}
1621
1622/* Opcode: Concat P1 P2 P3 * *
1623** Synopsis: r[P3]=r[P2]+r[P1]
1624**
1625** Add the text in register P1 onto the end of the text in
1626** register P2 and store the result in register P3.
1627** If either the P1 or P2 text are NULL then store NULL in P3.
1628**
1629** P3 = P2 || P1
1630**
1631** It is illegal for P1 and P3 to be the same register. Sometimes,
1632** if P3 is the same register as P2, the implementation is able
1633** to avoid a memcpy().
1634*/
1635case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */
1636 i64 nByte; /* Total size of the output string or blob */
1637 u16 flags1; /* Initial flags for P1 */
1638 u16 flags2; /* Initial flags for P2 */
1639
1640 pIn1 = &aMem[pOp->p1];
1641 pIn2 = &aMem[pOp->p2];
1642 pOut = &aMem[pOp->p3];
1643 testcase( pOut==pIn2 );
1644 assert( pIn1!=pOut );
1645 flags1 = pIn1->flags;
1646 testcase( flags1 & MEM_Null );
1647 testcase( pIn2->flags & MEM_Null );
1648 if( (flags1 | pIn2->flags) & MEM_Null ){
1649 sqlite3VdbeMemSetNull(pOut);
1650 break;
1651 }
1652 if( (flags1 & (MEM_Str|MEM_Blob))==0 ){
1653 if( sqlite3VdbeMemStringify(pIn1,encoding,0) ) goto no_mem;
1654 flags1 = pIn1->flags & ~MEM_Str;
1655 }else if( (flags1 & MEM_Zero)!=0 ){
1656 if( sqlite3VdbeMemExpandBlob(pIn1) ) goto no_mem;
1657 flags1 = pIn1->flags & ~MEM_Str;
1658 }
1659 flags2 = pIn2->flags;
1660 if( (flags2 & (MEM_Str|MEM_Blob))==0 ){
1661 if( sqlite3VdbeMemStringify(pIn2,encoding,0) ) goto no_mem;
1662 flags2 = pIn2->flags & ~MEM_Str;
1663 }else if( (flags2 & MEM_Zero)!=0 ){
1664 if( sqlite3VdbeMemExpandBlob(pIn2) ) goto no_mem;
1665 flags2 = pIn2->flags & ~MEM_Str;
1666 }
1667 nByte = pIn1->n + pIn2->n;
1668 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
1669 goto too_big;
1670 }
1671 if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){
1672 goto no_mem;
1673 }
1674 MemSetTypeFlag(pOut, MEM_Str);
1675 if( pOut!=pIn2 ){
1676 memcpy(pOut->z, pIn2->z, pIn2->n);
1677 assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) );
1678 pIn2->flags = flags2;
1679 }
1680 memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
1681 assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
1682 pIn1->flags = flags1;
1683 if( encoding>SQLITE_UTF8 ) nByte &= ~1;
1684 pOut->z[nByte]=0;
1685 pOut->z[nByte+1] = 0;
1686 pOut->flags |= MEM_Term;
1687 pOut->n = (int)nByte;
1688 pOut->enc = encoding;
1689 UPDATE_MAX_BLOBSIZE(pOut);
1690 break;
1691}
1692
1693/* Opcode: Add P1 P2 P3 * *
1694** Synopsis: r[P3]=r[P1]+r[P2]
1695**
1696** Add the value in register P1 to the value in register P2
1697** and store the result in register P3.
1698** If either input is NULL, the result is NULL.
1699*/
1700/* Opcode: Multiply P1 P2 P3 * *
1701** Synopsis: r[P3]=r[P1]*r[P2]
1702**
1703**
1704** Multiply the value in register P1 by the value in register P2
1705** and store the result in register P3.
1706** If either input is NULL, the result is NULL.
1707*/
1708/* Opcode: Subtract P1 P2 P3 * *
1709** Synopsis: r[P3]=r[P2]-r[P1]
1710**
1711** Subtract the value in register P1 from the value in register P2
1712** and store the result in register P3.
1713** If either input is NULL, the result is NULL.
1714*/
1715/* Opcode: Divide P1 P2 P3 * *
1716** Synopsis: r[P3]=r[P2]/r[P1]
1717**
1718** Divide the value in register P1 by the value in register P2
1719** and store the result in register P3 (P3=P2/P1). If the value in
1720** register P1 is zero, then the result is NULL. If either input is
1721** NULL, the result is NULL.
1722*/
1723/* Opcode: Remainder P1 P2 P3 * *
1724** Synopsis: r[P3]=r[P2]%r[P1]
1725**
1726** Compute the remainder after integer register P2 is divided by
1727** register P1 and store the result in register P3.
1728** If the value in register P1 is zero the result is NULL.
1729** If either operand is NULL, the result is NULL.
1730*/
1731case OP_Add: /* same as TK_PLUS, in1, in2, out3 */
1732case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */
1733case OP_Multiply: /* same as TK_STAR, in1, in2, out3 */
1734case OP_Divide: /* same as TK_SLASH, in1, in2, out3 */
1735case OP_Remainder: { /* same as TK_REM, in1, in2, out3 */
1736 u16 type1; /* Numeric type of left operand */
1737 u16 type2; /* Numeric type of right operand */
1738 i64 iA; /* Integer value of left operand */
1739 i64 iB; /* Integer value of right operand */
1740 double rA; /* Real value of left operand */
1741 double rB; /* Real value of right operand */
1742
1743 pIn1 = &aMem[pOp->p1];
1744 type1 = pIn1->flags;
1745 pIn2 = &aMem[pOp->p2];
1746 type2 = pIn2->flags;
1747 pOut = &aMem[pOp->p3];
1748 if( (type1 & type2 & MEM_Int)!=0 ){
1749int_math:
1750 iA = pIn1->u.i;
1751 iB = pIn2->u.i;
1752 switch( pOp->opcode ){
1753 case OP_Add: if( sqlite3AddInt64(&iB,iA) ) goto fp_math; break;
1754 case OP_Subtract: if( sqlite3SubInt64(&iB,iA) ) goto fp_math; break;
1755 case OP_Multiply: if( sqlite3MulInt64(&iB,iA) ) goto fp_math; break;
1756 case OP_Divide: {
1757 if( iA==0 ) goto arithmetic_result_is_null;
1758 if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math;
1759 iB /= iA;
1760 break;
1761 }
1762 default: {
1763 if( iA==0 ) goto arithmetic_result_is_null;
1764 if( iA==-1 ) iA = 1;
1765 iB %= iA;
1766 break;
1767 }
1768 }
1769 pOut->u.i = iB;
1770 MemSetTypeFlag(pOut, MEM_Int);
1771 }else if( ((type1 | type2) & MEM_Null)!=0 ){
1772 goto arithmetic_result_is_null;
1773 }else{
1774 type1 = numericType(pIn1);
1775 type2 = numericType(pIn2);
1776 if( (type1 & type2 & MEM_Int)!=0 ) goto int_math;
1777fp_math:
1778 rA = sqlite3VdbeRealValue(pIn1);
1779 rB = sqlite3VdbeRealValue(pIn2);
1780 switch( pOp->opcode ){
1781 case OP_Add: rB += rA; break;
1782 case OP_Subtract: rB -= rA; break;
1783 case OP_Multiply: rB *= rA; break;
1784 case OP_Divide: {
1785 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
1786 if( rA==(double)0 ) goto arithmetic_result_is_null;
1787 rB /= rA;
1788 break;
1789 }
1790 default: {
1791 iA = sqlite3VdbeIntValue(pIn1);
1792 iB = sqlite3VdbeIntValue(pIn2);
1793 if( iA==0 ) goto arithmetic_result_is_null;
1794 if( iA==-1 ) iA = 1;
1795 rB = (double)(iB % iA);
1796 break;
1797 }
1798 }
1799#ifdef SQLITE_OMIT_FLOATING_POINT
1800 pOut->u.i = rB;
1801 MemSetTypeFlag(pOut, MEM_Int);
1802#else
1803 if( sqlite3IsNaN(rB) ){
1804 goto arithmetic_result_is_null;
1805 }
1806 pOut->u.r = rB;
1807 MemSetTypeFlag(pOut, MEM_Real);
1808#endif
1809 }
1810 break;
1811
1812arithmetic_result_is_null:
1813 sqlite3VdbeMemSetNull(pOut);
1814 break;
1815}
1816
1817/* Opcode: CollSeq P1 * * P4
1818**
1819** P4 is a pointer to a CollSeq object. If the next call to a user function
1820** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
1821** be returned. This is used by the built-in min(), max() and nullif()
1822** functions.
1823**
1824** If P1 is not zero, then it is a register that a subsequent min() or
1825** max() aggregate will set to 1 if the current row is not the minimum or
1826** maximum. The P1 register is initialized to 0 by this instruction.
1827**
1828** The interface used by the implementation of the aforementioned functions
1829** to retrieve the collation sequence set by this opcode is not available
1830** publicly. Only built-in functions have access to this feature.
1831*/
1832case OP_CollSeq: {
1833 assert( pOp->p4type==P4_COLLSEQ );
1834 if( pOp->p1 ){
1835 sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0);
1836 }
1837 break;
1838}
1839
1840/* Opcode: BitAnd P1 P2 P3 * *
1841** Synopsis: r[P3]=r[P1]&r[P2]
1842**
1843** Take the bit-wise AND of the values in register P1 and P2 and
1844** store the result in register P3.
1845** If either input is NULL, the result is NULL.
1846*/
1847/* Opcode: BitOr P1 P2 P3 * *
1848** Synopsis: r[P3]=r[P1]|r[P2]
1849**
1850** Take the bit-wise OR of the values in register P1 and P2 and
1851** store the result in register P3.
1852** If either input is NULL, the result is NULL.
1853*/
1854/* Opcode: ShiftLeft P1 P2 P3 * *
1855** Synopsis: r[P3]=r[P2]<<r[P1]
1856**
1857** Shift the integer value in register P2 to the left by the
1858** number of bits specified by the integer in register P1.
1859** Store the result in register P3.
1860** If either input is NULL, the result is NULL.
1861*/
1862/* Opcode: ShiftRight P1 P2 P3 * *
1863** Synopsis: r[P3]=r[P2]>>r[P1]
1864**
1865** Shift the integer value in register P2 to the right by the
1866** number of bits specified by the integer in register P1.
1867** Store the result in register P3.
1868** If either input is NULL, the result is NULL.
1869*/
1870case OP_BitAnd: /* same as TK_BITAND, in1, in2, out3 */
1871case OP_BitOr: /* same as TK_BITOR, in1, in2, out3 */
1872case OP_ShiftLeft: /* same as TK_LSHIFT, in1, in2, out3 */
1873case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */
1874 i64 iA;
1875 u64 uA;
1876 i64 iB;
1877 u8 op;
1878
1879 pIn1 = &aMem[pOp->p1];
1880 pIn2 = &aMem[pOp->p2];
1881 pOut = &aMem[pOp->p3];
1882 if( (pIn1->flags | pIn2->flags) & MEM_Null ){
1883 sqlite3VdbeMemSetNull(pOut);
1884 break;
1885 }
1886 iA = sqlite3VdbeIntValue(pIn2);
1887 iB = sqlite3VdbeIntValue(pIn1);
1888 op = pOp->opcode;
1889 if( op==OP_BitAnd ){
1890 iA &= iB;
1891 }else if( op==OP_BitOr ){
1892 iA |= iB;
1893 }else if( iB!=0 ){
1894 assert( op==OP_ShiftRight || op==OP_ShiftLeft );
1895
1896 /* If shifting by a negative amount, shift in the other direction */
1897 if( iB<0 ){
1898 assert( OP_ShiftRight==OP_ShiftLeft+1 );
1899 op = 2*OP_ShiftLeft + 1 - op;
1900 iB = iB>(-64) ? -iB : 64;
1901 }
1902
1903 if( iB>=64 ){
1904 iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1;
1905 }else{
1906 memcpy(&uA, &iA, sizeof(uA));
1907 if( op==OP_ShiftLeft ){
1908 uA <<= iB;
1909 }else{
1910 uA >>= iB;
1911 /* Sign-extend on a right shift of a negative number */
1912 if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB);
1913 }
1914 memcpy(&iA, &uA, sizeof(iA));
1915 }
1916 }
1917 pOut->u.i = iA;
1918 MemSetTypeFlag(pOut, MEM_Int);
1919 break;
1920}
1921
1922/* Opcode: AddImm P1 P2 * * *
1923** Synopsis: r[P1]=r[P1]+P2
1924**
1925** Add the constant P2 to the value in register P1.
1926** The result is always an integer.
1927**
1928** To force any register to be an integer, just add 0.
1929*/
1930case OP_AddImm: { /* in1 */
1931 pIn1 = &aMem[pOp->p1];
1932 memAboutToChange(p, pIn1);
1933 sqlite3VdbeMemIntegerify(pIn1);
1934 pIn1->u.i += pOp->p2;
1935 break;
1936}
1937
1938/* Opcode: MustBeInt P1 P2 * * *
1939**
1940** Force the value in register P1 to be an integer. If the value
1941** in P1 is not an integer and cannot be converted into an integer
1942** without data loss, then jump immediately to P2, or if P2==0
1943** raise an SQLITE_MISMATCH exception.
1944*/
1945case OP_MustBeInt: { /* jump, in1 */
1946 pIn1 = &aMem[pOp->p1];
1947 if( (pIn1->flags & MEM_Int)==0 ){
1948 applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
1949 if( (pIn1->flags & MEM_Int)==0 ){
1950 VdbeBranchTaken(1, 2);
1951 if( pOp->p2==0 ){
1952 rc = SQLITE_MISMATCH;
1953 goto abort_due_to_error;
1954 }else{
1955 goto jump_to_p2;
1956 }
1957 }
1958 }
1959 VdbeBranchTaken(0, 2);
1960 MemSetTypeFlag(pIn1, MEM_Int);
1961 break;
1962}
1963
1964#ifndef SQLITE_OMIT_FLOATING_POINT
1965/* Opcode: RealAffinity P1 * * * *
1966**
1967** If register P1 holds an integer convert it to a real value.
1968**
1969** This opcode is used when extracting information from a column that
1970** has REAL affinity. Such column values may still be stored as
1971** integers, for space efficiency, but after extraction we want them
1972** to have only a real value.
1973*/
1974case OP_RealAffinity: { /* in1 */
1975 pIn1 = &aMem[pOp->p1];
1976 if( pIn1->flags & (MEM_Int|MEM_IntReal) ){
1977 testcase( pIn1->flags & MEM_Int );
1978 testcase( pIn1->flags & MEM_IntReal );
1979 sqlite3VdbeMemRealify(pIn1);
1980 REGISTER_TRACE(pOp->p1, pIn1);
1981 }
1982 break;
1983}
1984#endif
1985
1986#ifndef SQLITE_OMIT_CAST
1987/* Opcode: Cast P1 P2 * * *
1988** Synopsis: affinity(r[P1])
1989**
1990** Force the value in register P1 to be the type defined by P2.
1991**
1992** <ul>
1993** <li> P2=='A' &rarr; BLOB
1994** <li> P2=='B' &rarr; TEXT
1995** <li> P2=='C' &rarr; NUMERIC
1996** <li> P2=='D' &rarr; INTEGER
1997** <li> P2=='E' &rarr; REAL
1998** </ul>
1999**
2000** A NULL value is not changed by this routine. It remains NULL.
2001*/
2002case OP_Cast: { /* in1 */
2003 assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL );
2004 testcase( pOp->p2==SQLITE_AFF_TEXT );
2005 testcase( pOp->p2==SQLITE_AFF_BLOB );
2006 testcase( pOp->p2==SQLITE_AFF_NUMERIC );
2007 testcase( pOp->p2==SQLITE_AFF_INTEGER );
2008 testcase( pOp->p2==SQLITE_AFF_REAL );
2009 pIn1 = &aMem[pOp->p1];
2010 memAboutToChange(p, pIn1);
2011 rc = ExpandBlob(pIn1);
2012 if( rc ) goto abort_due_to_error;
2013 rc = sqlite3VdbeMemCast(pIn1, pOp->p2, encoding);
2014 if( rc ) goto abort_due_to_error;
2015 UPDATE_MAX_BLOBSIZE(pIn1);
2016 REGISTER_TRACE(pOp->p1, pIn1);
2017 break;
2018}
2019#endif /* SQLITE_OMIT_CAST */
2020
2021/* Opcode: Eq P1 P2 P3 P4 P5
2022** Synopsis: IF r[P3]==r[P1]
2023**
2024** Compare the values in register P1 and P3. If reg(P3)==reg(P1) then
2025** jump to address P2.
2026**
2027** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
2028** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made
2029** to coerce both inputs according to this affinity before the
2030** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
2031** affinity is used. Note that the affinity conversions are stored
2032** back into the input registers P1 and P3. So this opcode can cause
2033** persistent changes to registers P1 and P3.
2034**
2035** Once any conversions have taken place, and neither value is NULL,
2036** the values are compared. If both values are blobs then memcmp() is
2037** used to determine the results of the comparison. If both values
2038** are text, then the appropriate collating function specified in
2039** P4 is used to do the comparison. If P4 is not specified then
2040** memcmp() is used to compare text string. If both values are
2041** numeric, then a numeric comparison is used. If the two values
2042** are of different types, then numbers are considered less than
2043** strings and strings are considered less than blobs.
2044**
2045** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
2046** true or false and is never NULL. If both operands are NULL then the result
2047** of comparison is true. If either operand is NULL then the result is false.
2048** If neither operand is NULL the result is the same as it would be if
2049** the SQLITE_NULLEQ flag were omitted from P5.
2050**
2051** This opcode saves the result of comparison for use by the new
2052** OP_Jump opcode.
2053*/
2054/* Opcode: Ne P1 P2 P3 P4 P5
2055** Synopsis: IF r[P3]!=r[P1]
2056**
2057** This works just like the Eq opcode except that the jump is taken if
2058** the operands in registers P1 and P3 are not equal. See the Eq opcode for
2059** additional information.
2060*/
2061/* Opcode: Lt P1 P2 P3 P4 P5
2062** Synopsis: IF r[P3]<r[P1]
2063**
2064** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then
2065** jump to address P2.
2066**
2067** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
2068** reg(P3) is NULL then the take the jump. If the SQLITE_JUMPIFNULL
2069** bit is clear then fall through if either operand is NULL.
2070**
2071** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
2072** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made
2073** to coerce both inputs according to this affinity before the
2074** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
2075** affinity is used. Note that the affinity conversions are stored
2076** back into the input registers P1 and P3. So this opcode can cause
2077** persistent changes to registers P1 and P3.
2078**
2079** Once any conversions have taken place, and neither value is NULL,
2080** the values are compared. If both values are blobs then memcmp() is
2081** used to determine the results of the comparison. If both values
2082** are text, then the appropriate collating function specified in
2083** P4 is used to do the comparison. If P4 is not specified then
2084** memcmp() is used to compare text string. If both values are
2085** numeric, then a numeric comparison is used. If the two values
2086** are of different types, then numbers are considered less than
2087** strings and strings are considered less than blobs.
2088**
2089** This opcode saves the result of comparison for use by the new
2090** OP_Jump opcode.
2091*/
2092/* Opcode: Le P1 P2 P3 P4 P5
2093** Synopsis: IF r[P3]<=r[P1]
2094**
2095** This works just like the Lt opcode except that the jump is taken if
2096** the content of register P3 is less than or equal to the content of
2097** register P1. See the Lt opcode for additional information.
2098*/
2099/* Opcode: Gt P1 P2 P3 P4 P5
2100** Synopsis: IF r[P3]>r[P1]
2101**
2102** This works just like the Lt opcode except that the jump is taken if
2103** the content of register P3 is greater than the content of
2104** register P1. See the Lt opcode for additional information.
2105*/
2106/* Opcode: Ge P1 P2 P3 P4 P5
2107** Synopsis: IF r[P3]>=r[P1]
2108**
2109** This works just like the Lt opcode except that the jump is taken if
2110** the content of register P3 is greater than or equal to the content of
2111** register P1. See the Lt opcode for additional information.
2112*/
2113case OP_Eq: /* same as TK_EQ, jump, in1, in3 */
2114case OP_Ne: /* same as TK_NE, jump, in1, in3 */
2115case OP_Lt: /* same as TK_LT, jump, in1, in3 */
2116case OP_Le: /* same as TK_LE, jump, in1, in3 */
2117case OP_Gt: /* same as TK_GT, jump, in1, in3 */
2118case OP_Ge: { /* same as TK_GE, jump, in1, in3 */
2119 int res, res2; /* Result of the comparison of pIn1 against pIn3 */
2120 char affinity; /* Affinity to use for comparison */
2121 u16 flags1; /* Copy of initial value of pIn1->flags */
2122 u16 flags3; /* Copy of initial value of pIn3->flags */
2123
2124 pIn1 = &aMem[pOp->p1];
2125 pIn3 = &aMem[pOp->p3];
2126 flags1 = pIn1->flags;
2127 flags3 = pIn3->flags;
2128 if( (flags1 & flags3 & MEM_Int)!=0 ){
2129 assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT || CORRUPT_DB );
2130 /* Common case of comparison of two integers */
2131 if( pIn3->u.i > pIn1->u.i ){
2132 if( sqlite3aGTb[pOp->opcode] ){
2133 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
2134 goto jump_to_p2;
2135 }
2136 iCompare = +1;
2137 }else if( pIn3->u.i < pIn1->u.i ){
2138 if( sqlite3aLTb[pOp->opcode] ){
2139 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
2140 goto jump_to_p2;
2141 }
2142 iCompare = -1;
2143 }else{
2144 if( sqlite3aEQb[pOp->opcode] ){
2145 VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
2146 goto jump_to_p2;
2147 }
2148 iCompare = 0;
2149 }
2150 VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
2151 break;
2152 }
2153 if( (flags1 | flags3)&MEM_Null ){
2154 /* One or both operands are NULL */
2155 if( pOp->p5 & SQLITE_NULLEQ ){
2156 /* If SQLITE_NULLEQ is set (which will only happen if the operator is
2157 ** OP_Eq or OP_Ne) then take the jump or not depending on whether
2158 ** or not both operands are null.
2159 */
2160 assert( (flags1 & MEM_Cleared)==0 );
2161 assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB );
2162 testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 );
2163 if( (flags1&flags3&MEM_Null)!=0
2164 && (flags3&MEM_Cleared)==0
2165 ){
2166 res = 0; /* Operands are equal */
2167 }else{
2168 res = ((flags3 & MEM_Null) ? -1 : +1); /* Operands are not equal */
2169 }
2170 }else{
2171 /* SQLITE_NULLEQ is clear and at least one operand is NULL,
2172 ** then the result is always NULL.
2173 ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
2174 */
2175 VdbeBranchTaken(2,3);
2176 if( pOp->p5 & SQLITE_JUMPIFNULL ){
2177 goto jump_to_p2;
2178 }
2179 iCompare = 1; /* Operands are not equal */
2180 break;
2181 }
2182 }else{
2183 /* Neither operand is NULL and we couldn't do the special high-speed
2184 ** integer comparison case. So do a general-case comparison. */
2185 affinity = pOp->p5 & SQLITE_AFF_MASK;
2186 if( affinity>=SQLITE_AFF_NUMERIC ){
2187 if( (flags1 | flags3)&MEM_Str ){
2188 if( (flags1 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){
2189 applyNumericAffinity(pIn1,0);
2190 testcase( flags3==pIn3->flags );
2191 flags3 = pIn3->flags;
2192 }
2193 if( (flags3 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){
2194 applyNumericAffinity(pIn3,0);
2195 }
2196 }
2197 }else if( affinity==SQLITE_AFF_TEXT ){
2198 if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
2199 testcase( pIn1->flags & MEM_Int );
2200 testcase( pIn1->flags & MEM_Real );
2201 testcase( pIn1->flags & MEM_IntReal );
2202 sqlite3VdbeMemStringify(pIn1, encoding, 1);
2203 testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
2204 flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
2205 if( pIn1==pIn3 ) flags3 = flags1 | MEM_Str;
2206 }
2207 if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
2208 testcase( pIn3->flags & MEM_Int );
2209 testcase( pIn3->flags & MEM_Real );
2210 testcase( pIn3->flags & MEM_IntReal );
2211 sqlite3VdbeMemStringify(pIn3, encoding, 1);
2212 testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
2213 flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
2214 }
2215 }
2216 assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
2217 res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
2218 }
2219
2220 /* At this point, res is negative, zero, or positive if reg[P1] is
2221 ** less than, equal to, or greater than reg[P3], respectively. Compute
2222 ** the answer to this operator in res2, depending on what the comparison
2223 ** operator actually is. The next block of code depends on the fact
2224 ** that the 6 comparison operators are consecutive integers in this
2225 ** order: NE, EQ, GT, LE, LT, GE */
2226 assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 );
2227 assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 );
2228 if( res<0 ){
2229 res2 = sqlite3aLTb[pOp->opcode];
2230 }else if( res==0 ){
2231 res2 = sqlite3aEQb[pOp->opcode];
2232 }else{
2233 res2 = sqlite3aGTb[pOp->opcode];
2234 }
2235 iCompare = res;
2236
2237 /* Undo any changes made by applyAffinity() to the input registers. */
2238 assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
2239 pIn3->flags = flags3;
2240 assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
2241 pIn1->flags = flags1;
2242
2243 VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
2244 if( res2 ){
2245 goto jump_to_p2;
2246 }
2247 break;
2248}
2249
2250/* Opcode: ElseEq * P2 * * *
2251**
2252** This opcode must follow an OP_Lt or OP_Gt comparison operator. There
2253** can be zero or more OP_ReleaseReg opcodes intervening, but no other
2254** opcodes are allowed to occur between this instruction and the previous
2255** OP_Lt or OP_Gt.
2256**
2257** If result of an OP_Eq comparison on the same two operands as the
2258** prior OP_Lt or OP_Gt would have been true, then jump to P2.
2259** If the result of an OP_Eq comparison on the two previous
2260** operands would have been false or NULL, then fall through.
2261*/
2262case OP_ElseEq: { /* same as TK_ESCAPE, jump */
2263
2264#ifdef SQLITE_DEBUG
2265 /* Verify the preconditions of this opcode - that it follows an OP_Lt or
2266 ** OP_Gt with zero or more intervening OP_ReleaseReg opcodes */
2267 int iAddr;
2268 for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){
2269 if( aOp[iAddr].opcode==OP_ReleaseReg ) continue;
2270 assert( aOp[iAddr].opcode==OP_Lt || aOp[iAddr].opcode==OP_Gt );
2271 break;
2272 }
2273#endif /* SQLITE_DEBUG */
2274 VdbeBranchTaken(iCompare==0, 2);
2275 if( iCompare==0 ) goto jump_to_p2;
2276 break;
2277}
2278
2279
2280/* Opcode: Permutation * * * P4 *
2281**
2282** Set the permutation used by the OP_Compare operator in the next
2283** instruction. The permutation is stored in the P4 operand.
2284**
2285** The permutation is only valid for the next opcode which must be
2286** an OP_Compare that has the OPFLAG_PERMUTE bit set in P5.
2287**
2288** The first integer in the P4 integer array is the length of the array
2289** and does not become part of the permutation.
2290*/
2291case OP_Permutation: {
2292 assert( pOp->p4type==P4_INTARRAY );
2293 assert( pOp->p4.ai );
2294 assert( pOp[1].opcode==OP_Compare );
2295 assert( pOp[1].p5 & OPFLAG_PERMUTE );
2296 break;
2297}
2298
2299/* Opcode: Compare P1 P2 P3 P4 P5
2300** Synopsis: r[P1@P3] <-> r[P2@P3]
2301**
2302** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
2303** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
2304** the comparison for use by the next OP_Jump instruct.
2305**
2306** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
2307** determined by the most recent OP_Permutation operator. If the
2308** OPFLAG_PERMUTE bit is clear, then register are compared in sequential
2309** order.
2310**
2311** P4 is a KeyInfo structure that defines collating sequences and sort
2312** orders for the comparison. The permutation applies to registers
2313** only. The KeyInfo elements are used sequentially.
2314**
2315** The comparison is a sort comparison, so NULLs compare equal,
2316** NULLs are less than numbers, numbers are less than strings,
2317** and strings are less than blobs.
2318**
2319** This opcode must be immediately followed by an OP_Jump opcode.
2320*/
2321case OP_Compare: {
2322 int n;
2323 int i;
2324 int p1;
2325 int p2;
2326 const KeyInfo *pKeyInfo;
2327 u32 idx;
2328 CollSeq *pColl; /* Collating sequence to use on this term */
2329 int bRev; /* True for DESCENDING sort order */
2330 u32 *aPermute; /* The permutation */
2331
2332 if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){
2333 aPermute = 0;
2334 }else{
2335 assert( pOp>aOp );
2336 assert( pOp[-1].opcode==OP_Permutation );
2337 assert( pOp[-1].p4type==P4_INTARRAY );
2338 aPermute = pOp[-1].p4.ai + 1;
2339 assert( aPermute!=0 );
2340 }
2341 n = pOp->p3;
2342 pKeyInfo = pOp->p4.pKeyInfo;
2343 assert( n>0 );
2344 assert( pKeyInfo!=0 );
2345 p1 = pOp->p1;
2346 p2 = pOp->p2;
2347#ifdef SQLITE_DEBUG
2348 if( aPermute ){
2349 int k, mx = 0;
2350 for(k=0; k<n; k++) if( aPermute[k]>(u32)mx ) mx = aPermute[k];
2351 assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
2352 assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
2353 }else{
2354 assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 );
2355 assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 );
2356 }
2357#endif /* SQLITE_DEBUG */
2358 for(i=0; i<n; i++){
2359 idx = aPermute ? aPermute[i] : (u32)i;
2360 assert( memIsValid(&aMem[p1+idx]) );
2361 assert( memIsValid(&aMem[p2+idx]) );
2362 REGISTER_TRACE(p1+idx, &aMem[p1+idx]);
2363 REGISTER_TRACE(p2+idx, &aMem[p2+idx]);
2364 assert( i<pKeyInfo->nKeyField );
2365 pColl = pKeyInfo->aColl[i];
2366 bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC);
2367 iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl);
2368 if( iCompare ){
2369 if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
2370 && ((aMem[p1+idx].flags & MEM_Null) || (aMem[p2+idx].flags & MEM_Null))
2371 ){
2372 iCompare = -iCompare;
2373 }
2374 if( bRev ) iCompare = -iCompare;
2375 break;
2376 }
2377 }
2378 assert( pOp[1].opcode==OP_Jump );
2379 break;
2380}
2381
2382/* Opcode: Jump P1 P2 P3 * *
2383**
2384** Jump to the instruction at address P1, P2, or P3 depending on whether
2385** in the most recent OP_Compare instruction the P1 vector was less than
2386** equal to, or greater than the P2 vector, respectively.
2387**
2388** This opcode must immediately follow an OP_Compare opcode.
2389*/
2390case OP_Jump: { /* jump */
2391 assert( pOp>aOp && pOp[-1].opcode==OP_Compare );
2392 if( iCompare<0 ){
2393 VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1];
2394 }else if( iCompare==0 ){
2395 VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1];
2396 }else{
2397 VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1];
2398 }
2399 break;
2400}
2401
2402/* Opcode: And P1 P2 P3 * *
2403** Synopsis: r[P3]=(r[P1] && r[P2])
2404**
2405** Take the logical AND of the values in registers P1 and P2 and
2406** write the result into register P3.
2407**
2408** If either P1 or P2 is 0 (false) then the result is 0 even if
2409** the other input is NULL. A NULL and true or two NULLs give
2410** a NULL output.
2411*/
2412/* Opcode: Or P1 P2 P3 * *
2413** Synopsis: r[P3]=(r[P1] || r[P2])
2414**
2415** Take the logical OR of the values in register P1 and P2 and
2416** store the answer in register P3.
2417**
2418** If either P1 or P2 is nonzero (true) then the result is 1 (true)
2419** even if the other input is NULL. A NULL and false or two NULLs
2420** give a NULL output.
2421*/
2422case OP_And: /* same as TK_AND, in1, in2, out3 */
2423case OP_Or: { /* same as TK_OR, in1, in2, out3 */
2424 int v1; /* Left operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
2425 int v2; /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
2426
2427 v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2);
2428 v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2);
2429 if( pOp->opcode==OP_And ){
2430 static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
2431 v1 = and_logic[v1*3+v2];
2432 }else{
2433 static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
2434 v1 = or_logic[v1*3+v2];
2435 }
2436 pOut = &aMem[pOp->p3];
2437 if( v1==2 ){
2438 MemSetTypeFlag(pOut, MEM_Null);
2439 }else{
2440 pOut->u.i = v1;
2441 MemSetTypeFlag(pOut, MEM_Int);
2442 }
2443 break;
2444}
2445
2446/* Opcode: IsTrue P1 P2 P3 P4 *
2447** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4
2448**
2449** This opcode implements the IS TRUE, IS FALSE, IS NOT TRUE, and
2450** IS NOT FALSE operators.
2451**
2452** Interpret the value in register P1 as a boolean value. Store that
2453** boolean (a 0 or 1) in register P2. Or if the value in register P1 is
2454** NULL, then the P3 is stored in register P2. Invert the answer if P4
2455** is 1.
2456**
2457** The logic is summarized like this:
2458**
2459** <ul>
2460** <li> If P3==0 and P4==0 then r[P2] := r[P1] IS TRUE
2461** <li> If P3==1 and P4==1 then r[P2] := r[P1] IS FALSE
2462** <li> If P3==0 and P4==1 then r[P2] := r[P1] IS NOT TRUE
2463** <li> If P3==1 and P4==0 then r[P2] := r[P1] IS NOT FALSE
2464** </ul>
2465*/
2466case OP_IsTrue: { /* in1, out2 */
2467 assert( pOp->p4type==P4_INT32 );
2468 assert( pOp->p4.i==0 || pOp->p4.i==1 );
2469 assert( pOp->p3==0 || pOp->p3==1 );
2470 sqlite3VdbeMemSetInt64(&aMem[pOp->p2],
2471 sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i);
2472 break;
2473}
2474
2475/* Opcode: Not P1 P2 * * *
2476** Synopsis: r[P2]= !r[P1]
2477**
2478** Interpret the value in register P1 as a boolean value. Store the
2479** boolean complement in register P2. If the value in register P1 is
2480** NULL, then a NULL is stored in P2.
2481*/
2482case OP_Not: { /* same as TK_NOT, in1, out2 */
2483 pIn1 = &aMem[pOp->p1];
2484 pOut = &aMem[pOp->p2];
2485 if( (pIn1->flags & MEM_Null)==0 ){
2486 sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0));
2487 }else{
2488 sqlite3VdbeMemSetNull(pOut);
2489 }
2490 break;
2491}
2492
2493/* Opcode: BitNot P1 P2 * * *
2494** Synopsis: r[P2]= ~r[P1]
2495**
2496** Interpret the content of register P1 as an integer. Store the
2497** ones-complement of the P1 value into register P2. If P1 holds
2498** a NULL then store a NULL in P2.
2499*/
2500case OP_BitNot: { /* same as TK_BITNOT, in1, out2 */
2501 pIn1 = &aMem[pOp->p1];
2502 pOut = &aMem[pOp->p2];
2503 sqlite3VdbeMemSetNull(pOut);
2504 if( (pIn1->flags & MEM_Null)==0 ){
2505 pOut->flags = MEM_Int;
2506 pOut->u.i = ~sqlite3VdbeIntValue(pIn1);
2507 }
2508 break;
2509}
2510
2511/* Opcode: Once P1 P2 * * *
2512**
2513** Fall through to the next instruction the first time this opcode is
2514** encountered on each invocation of the byte-code program. Jump to P2
2515** on the second and all subsequent encounters during the same invocation.
2516**
2517** Top-level programs determine first invocation by comparing the P1
2518** operand against the P1 operand on the OP_Init opcode at the beginning
2519** of the program. If the P1 values differ, then fall through and make
2520** the P1 of this opcode equal to the P1 of OP_Init. If P1 values are
2521** the same then take the jump.
2522**
2523** For subprograms, there is a bitmask in the VdbeFrame that determines
2524** whether or not the jump should be taken. The bitmask is necessary
2525** because the self-altering code trick does not work for recursive
2526** triggers.
2527*/
2528case OP_Once: { /* jump */
2529 u32 iAddr; /* Address of this instruction */
2530 assert( p->aOp[0].opcode==OP_Init );
2531 if( p->pFrame ){
2532 iAddr = (int)(pOp - p->aOp);
2533 if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){
2534 VdbeBranchTaken(1, 2);
2535 goto jump_to_p2;
2536 }
2537 p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7);
2538 }else{
2539 if( p->aOp[0].p1==pOp->p1 ){
2540 VdbeBranchTaken(1, 2);
2541 goto jump_to_p2;
2542 }
2543 }
2544 VdbeBranchTaken(0, 2);
2545 pOp->p1 = p->aOp[0].p1;
2546 break;
2547}
2548
2549/* Opcode: If P1 P2 P3 * *
2550**
2551** Jump to P2 if the value in register P1 is true. The value
2552** is considered true if it is numeric and non-zero. If the value
2553** in P1 is NULL then take the jump if and only if P3 is non-zero.
2554*/
2555case OP_If: { /* jump, in1 */
2556 int c;
2557 c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3);
2558 VdbeBranchTaken(c!=0, 2);
2559 if( c ) goto jump_to_p2;
2560 break;
2561}
2562
2563/* Opcode: IfNot P1 P2 P3 * *
2564**
2565** Jump to P2 if the value in register P1 is False. The value
2566** is considered false if it has a numeric value of zero. If the value
2567** in P1 is NULL then take the jump if and only if P3 is non-zero.
2568*/
2569case OP_IfNot: { /* jump, in1 */
2570 int c;
2571 c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3);
2572 VdbeBranchTaken(c!=0, 2);
2573 if( c ) goto jump_to_p2;
2574 break;
2575}
2576
2577/* Opcode: IsNull P1 P2 * * *
2578** Synopsis: if r[P1]==NULL goto P2
2579**
2580** Jump to P2 if the value in register P1 is NULL.
2581*/
2582case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */
2583 pIn1 = &aMem[pOp->p1];
2584 VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2);
2585 if( (pIn1->flags & MEM_Null)!=0 ){
2586 goto jump_to_p2;
2587 }
2588 break;
2589}
2590
2591/* Opcode: IsType P1 P2 P3 P4 P5
2592** Synopsis: if typeof(P1.P3) in P5 goto P2
2593**
2594** Jump to P2 if the type of a column in a btree is one of the types specified
2595** by the P5 bitmask.
2596**
2597** P1 is normally a cursor on a btree for which the row decode cache is
2598** valid through at least column P3. In other words, there should have been
2599** a prior OP_Column for column P3 or greater. If the cursor is not valid,
2600** then this opcode might give spurious results.
2601** The the btree row has fewer than P3 columns, then use P4 as the
2602** datatype.
2603**
2604** If P1 is -1, then P3 is a register number and the datatype is taken
2605** from the value in that register.
2606**
2607** P5 is a bitmask of data types. SQLITE_INTEGER is the least significant
2608** (0x01) bit. SQLITE_FLOAT is the 0x02 bit. SQLITE_TEXT is 0x04.
2609** SQLITE_BLOB is 0x08. SQLITE_NULL is 0x10.
2610**
2611** Take the jump to address P2 if and only if the datatype of the
2612** value determined by P1 and P3 corresponds to one of the bits in the
2613** P5 bitmask.
2614**
2615*/
2616case OP_IsType: { /* jump */
2617 VdbeCursor *pC;
2618 u16 typeMask;
2619 u32 serialType;
2620
2621 assert( pOp->p1>=(-1) && pOp->p1<p->nCursor );
2622 assert( pOp->p1>=0 || (pOp->p3>=0 && pOp->p3<=(p->nMem+1 - p->nCursor)) );
2623 if( pOp->p1>=0 ){
2624 pC = p->apCsr[pOp->p1];
2625 assert( pC!=0 );
2626 assert( pOp->p3>=0 );
2627 if( pOp->p3<pC->nHdrParsed ){
2628 serialType = pC->aType[pOp->p3];
2629 if( serialType>=12 ){
2630 if( serialType&1 ){
2631 typeMask = 0x04; /* SQLITE_TEXT */
2632 }else{
2633 typeMask = 0x08; /* SQLITE_BLOB */
2634 }
2635 }else{
2636 static const unsigned char aMask[] = {
2637 0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2,
2638 0x01, 0x01, 0x10, 0x10
2639 };
2640 testcase( serialType==0 );
2641 testcase( serialType==1 );
2642 testcase( serialType==2 );
2643 testcase( serialType==3 );
2644 testcase( serialType==4 );
2645 testcase( serialType==5 );
2646 testcase( serialType==6 );
2647 testcase( serialType==7 );
2648 testcase( serialType==8 );
2649 testcase( serialType==9 );
2650 testcase( serialType==10 );
2651 testcase( serialType==11 );
2652 typeMask = aMask[serialType];
2653 }
2654 }else{
2655 typeMask = 1 << (pOp->p4.i - 1);
2656 testcase( typeMask==0x01 );
2657 testcase( typeMask==0x02 );
2658 testcase( typeMask==0x04 );
2659 testcase( typeMask==0x08 );
2660 testcase( typeMask==0x10 );
2661 }
2662 }else{
2663 assert( memIsValid(&aMem[pOp->p3]) );
2664 typeMask = 1 << (sqlite3_value_type((sqlite3_value*)&aMem[pOp->p3])-1);
2665 testcase( typeMask==0x01 );
2666 testcase( typeMask==0x02 );
2667 testcase( typeMask==0x04 );
2668 testcase( typeMask==0x08 );
2669 testcase( typeMask==0x10 );
2670 }
2671 VdbeBranchTaken( (typeMask & pOp->p5)!=0, 2);
2672 if( typeMask & pOp->p5 ){
2673 goto jump_to_p2;
2674 }
2675 break;
2676}
2677
2678/* Opcode: ZeroOrNull P1 P2 P3 * *
2679** Synopsis: r[P2] = 0 OR NULL
2680**
2681** If all both registers P1 and P3 are NOT NULL, then store a zero in
2682** register P2. If either registers P1 or P3 are NULL then put
2683** a NULL in register P2.
2684*/
2685case OP_ZeroOrNull: { /* in1, in2, out2, in3 */
2686 if( (aMem[pOp->p1].flags & MEM_Null)!=0
2687 || (aMem[pOp->p3].flags & MEM_Null)!=0
2688 ){
2689 sqlite3VdbeMemSetNull(aMem + pOp->p2);
2690 }else{
2691 sqlite3VdbeMemSetInt64(aMem + pOp->p2, 0);
2692 }
2693 break;
2694}
2695
2696/* Opcode: NotNull P1 P2 * * *
2697** Synopsis: if r[P1]!=NULL goto P2
2698**
2699** Jump to P2 if the value in register P1 is not NULL.
2700*/
2701case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */
2702 pIn1 = &aMem[pOp->p1];
2703 VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2);
2704 if( (pIn1->flags & MEM_Null)==0 ){
2705 goto jump_to_p2;
2706 }
2707 break;
2708}
2709
2710/* Opcode: IfNullRow P1 P2 P3 * *
2711** Synopsis: if P1.nullRow then r[P3]=NULL, goto P2
2712**
2713** Check the cursor P1 to see if it is currently pointing at a NULL row.
2714** If it is, then set register P3 to NULL and jump immediately to P2.
2715** If P1 is not on a NULL row, then fall through without making any
2716** changes.
2717**
2718** If P1 is not an open cursor, then this opcode is a no-op.
2719*/
2720case OP_IfNullRow: { /* jump */
2721 VdbeCursor *pC;
2722 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
2723 pC = p->apCsr[pOp->p1];
2724 if( ALWAYS(pC) && pC->nullRow ){
2725 sqlite3VdbeMemSetNull(aMem + pOp->p3);
2726 goto jump_to_p2;
2727 }
2728 break;
2729}
2730
2731#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
2732/* Opcode: Offset P1 P2 P3 * *
2733** Synopsis: r[P3] = sqlite_offset(P1)
2734**
2735** Store in register r[P3] the byte offset into the database file that is the
2736** start of the payload for the record at which that cursor P1 is currently
2737** pointing.
2738**
2739** P2 is the column number for the argument to the sqlite_offset() function.
2740** This opcode does not use P2 itself, but the P2 value is used by the
2741** code generator. The P1, P2, and P3 operands to this opcode are the
2742** same as for OP_Column.
2743**
2744** This opcode is only available if SQLite is compiled with the
2745** -DSQLITE_ENABLE_OFFSET_SQL_FUNC option.
2746*/
2747case OP_Offset: { /* out3 */
2748 VdbeCursor *pC; /* The VDBE cursor */
2749 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
2750 pC = p->apCsr[pOp->p1];
2751 pOut = &p->aMem[pOp->p3];
2752 if( pC==0 || pC->eCurType!=CURTYPE_BTREE ){
2753 sqlite3VdbeMemSetNull(pOut);
2754 }else{
2755 if( pC->deferredMoveto ){
2756 rc = sqlite3VdbeFinishMoveto(pC);
2757 if( rc ) goto abort_due_to_error;
2758 }
2759 if( sqlite3BtreeEof(pC->uc.pCursor) ){
2760 sqlite3VdbeMemSetNull(pOut);
2761 }else{
2762 sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
2763 }
2764 }
2765 break;
2766}
2767#endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */
2768
2769/* Opcode: Column P1 P2 P3 P4 P5
2770** Synopsis: r[P3]=PX cursor P1 column P2
2771**
2772** Interpret the data that cursor P1 points to as a structure built using
2773** the MakeRecord instruction. (See the MakeRecord opcode for additional
2774** information about the format of the data.) Extract the P2-th column
2775** from this record. If there are less than (P2+1)
2776** values in the record, extract a NULL.
2777**
2778** The value extracted is stored in register P3.
2779**
2780** If the record contains fewer than P2 fields, then extract a NULL. Or,
2781** if the P4 argument is a P4_MEM use the value of the P4 argument as
2782** the result.
2783**
2784** If the OPFLAG_LENGTHARG bit is set in P5 then the result is guaranteed
2785** to only be used by the length() function or the equivalent. The content
2786** of large blobs is not loaded, thus saving CPU cycles. If the
2787** OPFLAG_TYPEOFARG bit is set then the result will only be used by the
2788** typeof() function or the IS NULL or IS NOT NULL operators or the
2789** equivalent. In this case, all content loading can be omitted.
2790*/
2791case OP_Column: {
2792 u32 p2; /* column number to retrieve */
2793 VdbeCursor *pC; /* The VDBE cursor */
2794 BtCursor *pCrsr; /* The B-Tree cursor corresponding to pC */
2795 u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
2796 int len; /* The length of the serialized data for the column */
2797 int i; /* Loop counter */
2798 Mem *pDest; /* Where to write the extracted value */
2799 Mem sMem; /* For storing the record being decoded */
2800 const u8 *zData; /* Part of the record being decoded */
2801 const u8 *zHdr; /* Next unparsed byte of the header */
2802 const u8 *zEndHdr; /* Pointer to first byte after the header */
2803 u64 offset64; /* 64-bit offset */
2804 u32 t; /* A type code from the record header */
2805 Mem *pReg; /* PseudoTable input register */
2806
2807 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
2808 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
2809 pC = p->apCsr[pOp->p1];
2810 p2 = (u32)pOp->p2;
2811
2812op_column_restart:
2813 assert( pC!=0 );
2814 assert( p2<(u32)pC->nField
2815 || (pC->eCurType==CURTYPE_PSEUDO && pC->seekResult==0) );
2816 aOffset = pC->aOffset;
2817 assert( aOffset==pC->aType+pC->nField );
2818 assert( pC->eCurType!=CURTYPE_VTAB );
2819 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
2820 assert( pC->eCurType!=CURTYPE_SORTER );
2821
2822 if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/
2823 if( pC->nullRow ){
2824 if( pC->eCurType==CURTYPE_PSEUDO && pC->seekResult>0 ){
2825 /* For the special case of as pseudo-cursor, the seekResult field
2826 ** identifies the register that holds the record */
2827 pReg = &aMem[pC->seekResult];
2828 assert( pReg->flags & MEM_Blob );
2829 assert( memIsValid(pReg) );
2830 pC->payloadSize = pC->szRow = pReg->n;
2831 pC->aRow = (u8*)pReg->z;
2832 }else{
2833 pDest = &aMem[pOp->p3];
2834 memAboutToChange(p, pDest);
2835 sqlite3VdbeMemSetNull(pDest);
2836 goto op_column_out;
2837 }
2838 }else{
2839 pCrsr = pC->uc.pCursor;
2840 if( pC->deferredMoveto ){
2841 u32 iMap;
2842 assert( !pC->isEphemeral );
2843 if( pC->ub.aAltMap && (iMap = pC->ub.aAltMap[1+p2])>0 ){
2844 pC = pC->pAltCursor;
2845 p2 = iMap - 1;
2846 goto op_column_restart;
2847 }
2848 rc = sqlite3VdbeFinishMoveto(pC);
2849 if( rc ) goto abort_due_to_error;
2850 }else if( sqlite3BtreeCursorHasMoved(pCrsr) ){
2851 rc = sqlite3VdbeHandleMovedCursor(pC);
2852 if( rc ) goto abort_due_to_error;
2853 goto op_column_restart;
2854 }
2855 assert( pC->eCurType==CURTYPE_BTREE );
2856 assert( pCrsr );
2857 assert( sqlite3BtreeCursorIsValid(pCrsr) );
2858 pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
2859 pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
2860 assert( pC->szRow<=pC->payloadSize );
2861 assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */
2862 }
2863 pC->cacheStatus = p->cacheCtr;
2864 if( (aOffset[0] = pC->aRow[0])<0x80 ){
2865 pC->iHdrOffset = 1;
2866 }else{
2867 pC->iHdrOffset = sqlite3GetVarint32(pC->aRow, aOffset);
2868 }
2869 pC->nHdrParsed = 0;
2870
2871 if( pC->szRow<aOffset[0] ){ /*OPTIMIZATION-IF-FALSE*/
2872 /* pC->aRow does not have to hold the entire row, but it does at least
2873 ** need to cover the header of the record. If pC->aRow does not contain
2874 ** the complete header, then set it to zero, forcing the header to be
2875 ** dynamically allocated. */
2876 pC->aRow = 0;
2877 pC->szRow = 0;
2878
2879 /* Make sure a corrupt database has not given us an oversize header.
2880 ** Do this now to avoid an oversize memory allocation.
2881 **
2882 ** Type entries can be between 1 and 5 bytes each. But 4 and 5 byte
2883 ** types use so much data space that there can only be 4096 and 32 of
2884 ** them, respectively. So the maximum header length results from a
2885 ** 3-byte type for each of the maximum of 32768 columns plus three
2886 ** extra bytes for the header length itself. 32768*3 + 3 = 98307.
2887 */
2888 if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){
2889 goto op_column_corrupt;
2890 }
2891 }else{
2892 /* This is an optimization. By skipping over the first few tests
2893 ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
2894 ** measurable performance gain.
2895 **
2896 ** This branch is taken even if aOffset[0]==0. Such a record is never
2897 ** generated by SQLite, and could be considered corruption, but we
2898 ** accept it for historical reasons. When aOffset[0]==0, the code this
2899 ** branch jumps to reads past the end of the record, but never more
2900 ** than a few bytes. Even if the record occurs at the end of the page
2901 ** content area, the "page header" comes after the page content and so
2902 ** this overread is harmless. Similar overreads can occur for a corrupt
2903 ** database file.
2904 */
2905 zData = pC->aRow;
2906 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
2907 testcase( aOffset[0]==0 );
2908 goto op_column_read_header;
2909 }
2910 }else if( sqlite3BtreeCursorHasMoved(pC->uc.pCursor) ){
2911 rc = sqlite3VdbeHandleMovedCursor(pC);
2912 if( rc ) goto abort_due_to_error;
2913 goto op_column_restart;
2914 }
2915
2916 /* Make sure at least the first p2+1 entries of the header have been
2917 ** parsed and valid information is in aOffset[] and pC->aType[].
2918 */
2919 if( pC->nHdrParsed<=p2 ){
2920 /* If there is more header available for parsing in the record, try
2921 ** to extract additional fields up through the p2+1-th field
2922 */
2923 if( pC->iHdrOffset<aOffset[0] ){
2924 /* Make sure zData points to enough of the record to cover the header. */
2925 if( pC->aRow==0 ){
2926 memset(&sMem, 0, sizeof(sMem));
2927 rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem);
2928 if( rc!=SQLITE_OK ) goto abort_due_to_error;
2929 zData = (u8*)sMem.z;
2930 }else{
2931 zData = pC->aRow;
2932 }
2933
2934 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
2935 op_column_read_header:
2936 i = pC->nHdrParsed;
2937 offset64 = aOffset[i];
2938 zHdr = zData + pC->iHdrOffset;
2939 zEndHdr = zData + aOffset[0];
2940 testcase( zHdr>=zEndHdr );
2941 do{
2942 if( (pC->aType[i] = t = zHdr[0])<0x80 ){
2943 zHdr++;
2944 offset64 += sqlite3VdbeOneByteSerialTypeLen(t);
2945 }else{
2946 zHdr += sqlite3GetVarint32(zHdr, &t);
2947 pC->aType[i] = t;
2948 offset64 += sqlite3VdbeSerialTypeLen(t);
2949 }
2950 aOffset[++i] = (u32)(offset64 & 0xffffffff);
2951 }while( (u32)i<=p2 && zHdr<zEndHdr );
2952
2953 /* The record is corrupt if any of the following are true:
2954 ** (1) the bytes of the header extend past the declared header size
2955 ** (2) the entire header was used but not all data was used
2956 ** (3) the end of the data extends beyond the end of the record.
2957 */
2958 if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
2959 || (offset64 > pC->payloadSize)
2960 ){
2961 if( aOffset[0]==0 ){
2962 i = 0;
2963 zHdr = zEndHdr;
2964 }else{
2965 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
2966 goto op_column_corrupt;
2967 }
2968 }
2969
2970 pC->nHdrParsed = i;
2971 pC->iHdrOffset = (u32)(zHdr - zData);
2972 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
2973 }else{
2974 t = 0;
2975 }
2976
2977 /* If after trying to extract new entries from the header, nHdrParsed is
2978 ** still not up to p2, that means that the record has fewer than p2
2979 ** columns. So the result will be either the default value or a NULL.
2980 */
2981 if( pC->nHdrParsed<=p2 ){
2982 pDest = &aMem[pOp->p3];
2983 memAboutToChange(p, pDest);
2984 if( pOp->p4type==P4_MEM ){
2985 sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
2986 }else{
2987 sqlite3VdbeMemSetNull(pDest);
2988 }
2989 goto op_column_out;
2990 }
2991 }else{
2992 t = pC->aType[p2];
2993 }
2994
2995 /* Extract the content for the p2+1-th column. Control can only
2996 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
2997 ** all valid.
2998 */
2999 assert( p2<pC->nHdrParsed );
3000 assert( rc==SQLITE_OK );
3001 pDest = &aMem[pOp->p3];
3002 memAboutToChange(p, pDest);
3003 assert( sqlite3VdbeCheckMemInvariants(pDest) );
3004 if( VdbeMemDynamic(pDest) ){
3005 sqlite3VdbeMemSetNull(pDest);
3006 }
3007 assert( t==pC->aType[p2] );
3008 if( pC->szRow>=aOffset[p2+1] ){
3009 /* This is the common case where the desired content fits on the original
3010 ** page - where the content is not on an overflow page */
3011 zData = pC->aRow + aOffset[p2];
3012 if( t<12 ){
3013 sqlite3VdbeSerialGet(zData, t, pDest);
3014 }else{
3015 /* If the column value is a string, we need a persistent value, not
3016 ** a MEM_Ephem value. This branch is a fast short-cut that is equivalent
3017 ** to calling sqlite3VdbeSerialGet() and sqlite3VdbeDeephemeralize().
3018 */
3019 static const u16 aFlag[] = { MEM_Blob, MEM_Str|MEM_Term };
3020 pDest->n = len = (t-12)/2;
3021 pDest->enc = encoding;
3022 if( pDest->szMalloc < len+2 ){
3023 if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) goto too_big;
3024 pDest->flags = MEM_Null;
3025 if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem;
3026 }else{
3027 pDest->z = pDest->zMalloc;
3028 }
3029 memcpy(pDest->z, zData, len);
3030 pDest->z[len] = 0;
3031 pDest->z[len+1] = 0;
3032 pDest->flags = aFlag[t&1];
3033 }
3034 }else{
3035 pDest->enc = encoding;
3036 /* This branch happens only when content is on overflow pages */
3037 if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0
3038 && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0))
3039 || (len = sqlite3VdbeSerialTypeLen(t))==0
3040 ){
3041 /* Content is irrelevant for
3042 ** 1. the typeof() function,
3043 ** 2. the length(X) function if X is a blob, and
3044 ** 3. if the content length is zero.
3045 ** So we might as well use bogus content rather than reading
3046 ** content from disk.
3047 **
3048 ** Although sqlite3VdbeSerialGet() may read at most 8 bytes from the
3049 ** buffer passed to it, debugging function VdbeMemPrettyPrint() may
3050 ** read more. Use the global constant sqlite3CtypeMap[] as the array,
3051 ** as that array is 256 bytes long (plenty for VdbeMemPrettyPrint())
3052 ** and it begins with a bunch of zeros.
3053 */
3054 sqlite3VdbeSerialGet((u8*)sqlite3CtypeMap, t, pDest);
3055 }else{
3056 if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) goto too_big;
3057 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
3058 if( rc!=SQLITE_OK ) goto abort_due_to_error;
3059 sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
3060 pDest->flags &= ~MEM_Ephem;
3061 }
3062 }
3063
3064op_column_out:
3065 UPDATE_MAX_BLOBSIZE(pDest);
3066 REGISTER_TRACE(pOp->p3, pDest);
3067 break;
3068
3069op_column_corrupt:
3070 if( aOp[0].p3>0 ){
3071 pOp = &aOp[aOp[0].p3-1];
3072 break;
3073 }else{
3074 rc = SQLITE_CORRUPT_BKPT;
3075 goto abort_due_to_error;
3076 }
3077}
3078
3079/* Opcode: TypeCheck P1 P2 P3 P4 *
3080** Synopsis: typecheck(r[P1@P2])
3081**
3082** Apply affinities to the range of P2 registers beginning with P1.
3083** Take the affinities from the Table object in P4. If any value
3084** cannot be coerced into the correct type, then raise an error.
3085**
3086** This opcode is similar to OP_Affinity except that this opcode
3087** forces the register type to the Table column type. This is used
3088** to implement "strict affinity".
3089**
3090** GENERATED ALWAYS AS ... STATIC columns are only checked if P3
3091** is zero. When P3 is non-zero, no type checking occurs for
3092** static generated columns. Virtual columns are computed at query time
3093** and so they are never checked.
3094**
3095** Preconditions:
3096**
3097** <ul>
3098** <li> P2 should be the number of non-virtual columns in the
3099** table of P4.
3100** <li> Table P4 should be a STRICT table.
3101** </ul>
3102**
3103** If any precondition is false, an assertion fault occurs.
3104*/
3105case OP_TypeCheck: {
3106 Table *pTab;
3107 Column *aCol;
3108 int i;
3109
3110 assert( pOp->p4type==P4_TABLE );
3111 pTab = pOp->p4.pTab;
3112 assert( pTab->tabFlags & TF_Strict );
3113 assert( pTab->nNVCol==pOp->p2 );
3114 aCol = pTab->aCol;
3115 pIn1 = &aMem[pOp->p1];
3116 for(i=0; i<pTab->nCol; i++){
3117 if( aCol[i].colFlags & COLFLAG_GENERATED ){
3118 if( aCol[i].colFlags & COLFLAG_VIRTUAL ) continue;
3119 if( pOp->p3 ){ pIn1++; continue; }
3120 }
3121 assert( pIn1 < &aMem[pOp->p1+pOp->p2] );
3122 applyAffinity(pIn1, aCol[i].affinity, encoding);
3123 if( (pIn1->flags & MEM_Null)==0 ){
3124 switch( aCol[i].eCType ){
3125 case COLTYPE_BLOB: {
3126 if( (pIn1->flags & MEM_Blob)==0 ) goto vdbe_type_error;
3127 break;
3128 }
3129 case COLTYPE_INTEGER:
3130 case COLTYPE_INT: {
3131 if( (pIn1->flags & MEM_Int)==0 ) goto vdbe_type_error;
3132 break;
3133 }
3134 case COLTYPE_TEXT: {
3135 if( (pIn1->flags & MEM_Str)==0 ) goto vdbe_type_error;
3136 break;
3137 }
3138 case COLTYPE_REAL: {
3139 testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_Real );
3140 testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_IntReal );
3141 if( pIn1->flags & MEM_Int ){
3142 /* When applying REAL affinity, if the result is still an MEM_Int
3143 ** that will fit in 6 bytes, then change the type to MEM_IntReal
3144 ** so that we keep the high-resolution integer value but know that
3145 ** the type really wants to be REAL. */
3146 testcase( pIn1->u.i==140737488355328LL );
3147 testcase( pIn1->u.i==140737488355327LL );
3148 testcase( pIn1->u.i==-140737488355328LL );
3149 testcase( pIn1->u.i==-140737488355329LL );
3150 if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL){
3151 pIn1->flags |= MEM_IntReal;
3152 pIn1->flags &= ~MEM_Int;
3153 }else{
3154 pIn1->u.r = (double)pIn1->u.i;
3155 pIn1->flags |= MEM_Real;
3156 pIn1->flags &= ~MEM_Int;
3157 }
3158 }else if( (pIn1->flags & (MEM_Real|MEM_IntReal))==0 ){
3159 goto vdbe_type_error;
3160 }
3161 break;
3162 }
3163 default: {
3164 /* COLTYPE_ANY. Accept anything. */
3165 break;
3166 }
3167 }
3168 }
3169 REGISTER_TRACE((int)(pIn1-aMem), pIn1);
3170 pIn1++;
3171 }
3172 assert( pIn1 == &aMem[pOp->p1+pOp->p2] );
3173 break;
3174
3175vdbe_type_error:
3176 sqlite3VdbeError(p, "cannot store %s value in %s column %s.%s",
3177 vdbeMemTypeName(pIn1), sqlite3StdType[aCol[i].eCType-1],
3178 pTab->zName, aCol[i].zCnName);
3179 rc = SQLITE_CONSTRAINT_DATATYPE;
3180 goto abort_due_to_error;
3181}
3182
3183/* Opcode: Affinity P1 P2 * P4 *
3184** Synopsis: affinity(r[P1@P2])
3185**
3186** Apply affinities to a range of P2 registers starting with P1.
3187**
3188** P4 is a string that is P2 characters long. The N-th character of the
3189** string indicates the column affinity that should be used for the N-th
3190** memory cell in the range.
3191*/
3192case OP_Affinity: {
3193 const char *zAffinity; /* The affinity to be applied */
3194
3195 zAffinity = pOp->p4.z;
3196 assert( zAffinity!=0 );
3197 assert( pOp->p2>0 );
3198 assert( zAffinity[pOp->p2]==0 );
3199 pIn1 = &aMem[pOp->p1];
3200 while( 1 /*exit-by-break*/ ){
3201 assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] );
3202 assert( zAffinity[0]==SQLITE_AFF_NONE || memIsValid(pIn1) );
3203 applyAffinity(pIn1, zAffinity[0], encoding);
3204 if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){
3205 /* When applying REAL affinity, if the result is still an MEM_Int
3206 ** that will fit in 6 bytes, then change the type to MEM_IntReal
3207 ** so that we keep the high-resolution integer value but know that
3208 ** the type really wants to be REAL. */
3209 testcase( pIn1->u.i==140737488355328LL );
3210 testcase( pIn1->u.i==140737488355327LL );
3211 testcase( pIn1->u.i==-140737488355328LL );
3212 testcase( pIn1->u.i==-140737488355329LL );
3213 if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL ){
3214 pIn1->flags |= MEM_IntReal;
3215 pIn1->flags &= ~MEM_Int;
3216 }else{
3217 pIn1->u.r = (double)pIn1->u.i;
3218 pIn1->flags |= MEM_Real;
3219 pIn1->flags &= ~MEM_Int;
3220 }
3221 }
3222 REGISTER_TRACE((int)(pIn1-aMem), pIn1);
3223 zAffinity++;
3224 if( zAffinity[0]==0 ) break;
3225 pIn1++;
3226 }
3227 break;
3228}
3229
3230/* Opcode: MakeRecord P1 P2 P3 P4 *
3231** Synopsis: r[P3]=mkrec(r[P1@P2])
3232**
3233** Convert P2 registers beginning with P1 into the [record format]
3234** use as a data record in a database table or as a key
3235** in an index. The OP_Column opcode can decode the record later.
3236**
3237** P4 may be a string that is P2 characters long. The N-th character of the
3238** string indicates the column affinity that should be used for the N-th
3239** field of the index key.
3240**
3241** The mapping from character to affinity is given by the SQLITE_AFF_
3242** macros defined in sqliteInt.h.
3243**
3244** If P4 is NULL then all index fields have the affinity BLOB.
3245**
3246** The meaning of P5 depends on whether or not the SQLITE_ENABLE_NULL_TRIM
3247** compile-time option is enabled:
3248**
3249** * If SQLITE_ENABLE_NULL_TRIM is enabled, then the P5 is the index
3250** of the right-most table that can be null-trimmed.
3251**
3252** * If SQLITE_ENABLE_NULL_TRIM is omitted, then P5 has the value
3253** OPFLAG_NOCHNG_MAGIC if the OP_MakeRecord opcode is allowed to
3254** accept no-change records with serial_type 10. This value is
3255** only used inside an assert() and does not affect the end result.
3256*/
3257case OP_MakeRecord: {
3258 Mem *pRec; /* The new record */
3259 u64 nData; /* Number of bytes of data space */
3260 int nHdr; /* Number of bytes of header space */
3261 i64 nByte; /* Data space required for this record */
3262 i64 nZero; /* Number of zero bytes at the end of the record */
3263 int nVarint; /* Number of bytes in a varint */
3264 u32 serial_type; /* Type field */
3265 Mem *pData0; /* First field to be combined into the record */
3266 Mem *pLast; /* Last field of the record */
3267 int nField; /* Number of fields in the record */
3268 char *zAffinity; /* The affinity string for the record */
3269 u32 len; /* Length of a field */
3270 u8 *zHdr; /* Where to write next byte of the header */
3271 u8 *zPayload; /* Where to write next byte of the payload */
3272
3273 /* Assuming the record contains N fields, the record format looks
3274 ** like this:
3275 **
3276 ** ------------------------------------------------------------------------
3277 ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
3278 ** ------------------------------------------------------------------------
3279 **
3280 ** Data(0) is taken from register P1. Data(1) comes from register P1+1
3281 ** and so forth.
3282 **
3283 ** Each type field is a varint representing the serial type of the
3284 ** corresponding data element (see sqlite3VdbeSerialType()). The
3285 ** hdr-size field is also a varint which is the offset from the beginning
3286 ** of the record to data0.
3287 */
3288 nData = 0; /* Number of bytes of data space */
3289 nHdr = 0; /* Number of bytes of header space */
3290 nZero = 0; /* Number of zero bytes at the end of the record */
3291 nField = pOp->p1;
3292 zAffinity = pOp->p4.z;
3293 assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
3294 pData0 = &aMem[nField];
3295 nField = pOp->p2;
3296 pLast = &pData0[nField-1];
3297
3298 /* Identify the output register */
3299 assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
3300 pOut = &aMem[pOp->p3];
3301 memAboutToChange(p, pOut);
3302
3303 /* Apply the requested affinity to all inputs
3304 */
3305 assert( pData0<=pLast );
3306 if( zAffinity ){
3307 pRec = pData0;
3308 do{
3309 applyAffinity(pRec, zAffinity[0], encoding);
3310 if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){
3311 pRec->flags |= MEM_IntReal;
3312 pRec->flags &= ~(MEM_Int);
3313 }
3314 REGISTER_TRACE((int)(pRec-aMem), pRec);
3315 zAffinity++;
3316 pRec++;
3317 assert( zAffinity[0]==0 || pRec<=pLast );
3318 }while( zAffinity[0] );
3319 }
3320
3321#ifdef SQLITE_ENABLE_NULL_TRIM
3322 /* NULLs can be safely trimmed from the end of the record, as long as
3323 ** as the schema format is 2 or more and none of the omitted columns
3324 ** have a non-NULL default value. Also, the record must be left with
3325 ** at least one field. If P5>0 then it will be one more than the
3326 ** index of the right-most column with a non-NULL default value */
3327 if( pOp->p5 ){
3328 while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){
3329 pLast--;
3330 nField--;
3331 }
3332 }
3333#endif
3334
3335 /* Loop through the elements that will make up the record to figure
3336 ** out how much space is required for the new record. After this loop,
3337 ** the Mem.uTemp field of each term should hold the serial-type that will
3338 ** be used for that term in the generated record:
3339 **
3340 ** Mem.uTemp value type
3341 ** --------------- ---------------
3342 ** 0 NULL
3343 ** 1 1-byte signed integer
3344 ** 2 2-byte signed integer
3345 ** 3 3-byte signed integer
3346 ** 4 4-byte signed integer
3347 ** 5 6-byte signed integer
3348 ** 6 8-byte signed integer
3349 ** 7 IEEE float
3350 ** 8 Integer constant 0
3351 ** 9 Integer constant 1
3352 ** 10,11 reserved for expansion
3353 ** N>=12 and even BLOB
3354 ** N>=13 and odd text
3355 **
3356 ** The following additional values are computed:
3357 ** nHdr Number of bytes needed for the record header
3358 ** nData Number of bytes of data space needed for the record
3359 ** nZero Zero bytes at the end of the record
3360 */
3361 pRec = pLast;
3362 do{
3363 assert( memIsValid(pRec) );
3364 if( pRec->flags & MEM_Null ){
3365 if( pRec->flags & MEM_Zero ){
3366 /* Values with MEM_Null and MEM_Zero are created by xColumn virtual
3367 ** table methods that never invoke sqlite3_result_xxxxx() while
3368 ** computing an unchanging column value in an UPDATE statement.
3369 ** Give such values a special internal-use-only serial-type of 10
3370 ** so that they can be passed through to xUpdate and have
3371 ** a true sqlite3_value_nochange(). */
3372#ifndef SQLITE_ENABLE_NULL_TRIM
3373 assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB );
3374#endif
3375 pRec->uTemp = 10;
3376 }else{
3377 pRec->uTemp = 0;
3378 }
3379 nHdr++;
3380 }else if( pRec->flags & (MEM_Int|MEM_IntReal) ){
3381 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
3382 i64 i = pRec->u.i;
3383 u64 uu;
3384 testcase( pRec->flags & MEM_Int );
3385 testcase( pRec->flags & MEM_IntReal );
3386 if( i<0 ){
3387 uu = ~i;
3388 }else{
3389 uu = i;
3390 }
3391 nHdr++;
3392 testcase( uu==127 ); testcase( uu==128 );
3393 testcase( uu==32767 ); testcase( uu==32768 );
3394 testcase( uu==8388607 ); testcase( uu==8388608 );
3395 testcase( uu==2147483647 ); testcase( uu==2147483648LL );
3396 testcase( uu==140737488355327LL ); testcase( uu==140737488355328LL );
3397 if( uu<=127 ){
3398 if( (i&1)==i && p->minWriteFileFormat>=4 ){
3399 pRec->uTemp = 8+(u32)uu;
3400 }else{
3401 nData++;
3402 pRec->uTemp = 1;
3403 }
3404 }else if( uu<=32767 ){
3405 nData += 2;
3406 pRec->uTemp = 2;
3407 }else if( uu<=8388607 ){
3408 nData += 3;
3409 pRec->uTemp = 3;
3410 }else if( uu<=2147483647 ){
3411 nData += 4;
3412 pRec->uTemp = 4;
3413 }else if( uu<=140737488355327LL ){
3414 nData += 6;
3415 pRec->uTemp = 5;
3416 }else{
3417 nData += 8;
3418 if( pRec->flags & MEM_IntReal ){
3419 /* If the value is IntReal and is going to take up 8 bytes to store
3420 ** as an integer, then we might as well make it an 8-byte floating
3421 ** point value */
3422 pRec->u.r = (double)pRec->u.i;
3423 pRec->flags &= ~MEM_IntReal;
3424 pRec->flags |= MEM_Real;
3425 pRec->uTemp = 7;
3426 }else{
3427 pRec->uTemp = 6;
3428 }
3429 }
3430 }else if( pRec->flags & MEM_Real ){
3431 nHdr++;
3432 nData += 8;
3433 pRec->uTemp = 7;
3434 }else{
3435 assert( db->mallocFailed || pRec->flags&(MEM_Str|MEM_Blob) );
3436 assert( pRec->n>=0 );
3437 len = (u32)pRec->n;
3438 serial_type = (len*2) + 12 + ((pRec->flags & MEM_Str)!=0);
3439 if( pRec->flags & MEM_Zero ){
3440 serial_type += pRec->u.nZero*2;
3441 if( nData ){
3442 if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem;
3443 len += pRec->u.nZero;
3444 }else{
3445 nZero += pRec->u.nZero;
3446 }
3447 }
3448 nData += len;
3449 nHdr += sqlite3VarintLen(serial_type);
3450 pRec->uTemp = serial_type;
3451 }
3452 if( pRec==pData0 ) break;
3453 pRec--;
3454 }while(1);
3455
3456 /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint
3457 ** which determines the total number of bytes in the header. The varint
3458 ** value is the size of the header in bytes including the size varint
3459 ** itself. */
3460 testcase( nHdr==126 );
3461 testcase( nHdr==127 );
3462 if( nHdr<=126 ){
3463 /* The common case */
3464 nHdr += 1;
3465 }else{
3466 /* Rare case of a really large header */
3467 nVarint = sqlite3VarintLen(nHdr);
3468 nHdr += nVarint;
3469 if( nVarint<sqlite3VarintLen(nHdr) ) nHdr++;
3470 }
3471 nByte = nHdr+nData;
3472
3473 /* Make sure the output register has a buffer large enough to store
3474 ** the new record. The output register (pOp->p3) is not allowed to
3475 ** be one of the input registers (because the following call to
3476 ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used).
3477 */
3478 if( nByte+nZero<=pOut->szMalloc ){
3479 /* The output register is already large enough to hold the record.
3480 ** No error checks or buffer enlargement is required */
3481 pOut->z = pOut->zMalloc;
3482 }else{
3483 /* Need to make sure that the output is not too big and then enlarge
3484 ** the output register to hold the full result */
3485 if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){
3486 goto too_big;
3487 }
3488 if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){
3489 goto no_mem;
3490 }
3491 }
3492 pOut->n = (int)nByte;
3493 pOut->flags = MEM_Blob;
3494 if( nZero ){
3495 pOut->u.nZero = nZero;
3496 pOut->flags |= MEM_Zero;
3497 }
3498 UPDATE_MAX_BLOBSIZE(pOut);
3499 zHdr = (u8 *)pOut->z;
3500 zPayload = zHdr + nHdr;
3501
3502 /* Write the record */
3503 if( nHdr<0x80 ){
3504 *(zHdr++) = nHdr;
3505 }else{
3506 zHdr += sqlite3PutVarint(zHdr,nHdr);
3507 }
3508 assert( pData0<=pLast );
3509 pRec = pData0;
3510 while( 1 /*exit-by-break*/ ){
3511 serial_type = pRec->uTemp;
3512 /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more
3513 ** additional varints, one per column.
3514 ** EVIDENCE-OF: R-64536-51728 The values for each column in the record
3515 ** immediately follow the header. */
3516 if( serial_type<=7 ){
3517 *(zHdr++) = serial_type;
3518 if( serial_type==0 ){
3519 /* NULL value. No change in zPayload */
3520 }else{
3521 u64 v;
3522 u32 i;
3523 if( serial_type==7 ){
3524 assert( sizeof(v)==sizeof(pRec->u.r) );
3525 memcpy(&v, &pRec->u.r, sizeof(v));
3526 swapMixedEndianFloat(v);
3527 }else{
3528 v = pRec->u.i;
3529 }
3530 len = i = sqlite3SmallTypeSizes[serial_type];
3531 assert( i>0 );
3532 while( 1 /*exit-by-break*/ ){
3533 zPayload[--i] = (u8)(v&0xFF);
3534 if( i==0 ) break;
3535 v >>= 8;
3536 }
3537 zPayload += len;
3538 }
3539 }else if( serial_type<0x80 ){
3540 *(zHdr++) = serial_type;
3541 if( serial_type>=14 && pRec->n>0 ){
3542 assert( pRec->z!=0 );
3543 memcpy(zPayload, pRec->z, pRec->n);
3544 zPayload += pRec->n;
3545 }
3546 }else{
3547 zHdr += sqlite3PutVarint(zHdr, serial_type);
3548 if( pRec->n ){
3549 assert( pRec->z!=0 );
3550 memcpy(zPayload, pRec->z, pRec->n);
3551 zPayload += pRec->n;
3552 }
3553 }
3554 if( pRec==pLast ) break;
3555 pRec++;
3556 }
3557 assert( nHdr==(int)(zHdr - (u8*)pOut->z) );
3558 assert( nByte==(int)(zPayload - (u8*)pOut->z) );
3559
3560 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
3561 REGISTER_TRACE(pOp->p3, pOut);
3562 break;
3563}
3564
3565/* Opcode: Count P1 P2 P3 * *
3566** Synopsis: r[P2]=count()
3567**
3568** Store the number of entries (an integer value) in the table or index
3569** opened by cursor P1 in register P2.
3570**
3571** If P3==0, then an exact count is obtained, which involves visiting
3572** every btree page of the table. But if P3 is non-zero, an estimate
3573** is returned based on the current cursor position.
3574*/
3575case OP_Count: { /* out2 */
3576 i64 nEntry;
3577 BtCursor *pCrsr;
3578
3579 assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE );
3580 pCrsr = p->apCsr[pOp->p1]->uc.pCursor;
3581 assert( pCrsr );
3582 if( pOp->p3 ){
3583 nEntry = sqlite3BtreeRowCountEst(pCrsr);
3584 }else{
3585 nEntry = 0; /* Not needed. Only used to silence a warning. */
3586 rc = sqlite3BtreeCount(db, pCrsr, &nEntry);
3587 if( rc ) goto abort_due_to_error;
3588 }
3589 pOut = out2Prerelease(p, pOp);
3590 pOut->u.i = nEntry;
3591 goto check_for_interrupt;
3592}
3593
3594/* Opcode: Savepoint P1 * * P4 *
3595**
3596** Open, release or rollback the savepoint named by parameter P4, depending
3597** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN).
3598** To release (commit) an existing savepoint set P1==1 (SAVEPOINT_RELEASE).
3599** To rollback an existing savepoint set P1==2 (SAVEPOINT_ROLLBACK).
3600*/
3601case OP_Savepoint: {
3602 int p1; /* Value of P1 operand */
3603 char *zName; /* Name of savepoint */
3604 int nName;
3605 Savepoint *pNew;
3606 Savepoint *pSavepoint;
3607 Savepoint *pTmp;
3608 int iSavepoint;
3609 int ii;
3610
3611 p1 = pOp->p1;
3612 zName = pOp->p4.z;
3613
3614 /* Assert that the p1 parameter is valid. Also that if there is no open
3615 ** transaction, then there cannot be any savepoints.
3616 */
3617 assert( db->pSavepoint==0 || db->autoCommit==0 );
3618 assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK );
3619 assert( db->pSavepoint || db->isTransactionSavepoint==0 );
3620 assert( checkSavepointCount(db) );
3621 assert( p->bIsReader );
3622
3623 if( p1==SAVEPOINT_BEGIN ){
3624 if( db->nVdbeWrite>0 ){
3625 /* A new savepoint cannot be created if there are active write
3626 ** statements (i.e. open read/write incremental blob handles).
3627 */
3628 sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress");
3629 rc = SQLITE_BUSY;
3630 }else{
3631 nName = sqlite3Strlen30(zName);
3632
3633#ifndef SQLITE_OMIT_VIRTUALTABLE
3634 /* This call is Ok even if this savepoint is actually a transaction
3635 ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
3636 ** If this is a transaction savepoint being opened, it is guaranteed
3637 ** that the db->aVTrans[] array is empty. */
3638 assert( db->autoCommit==0 || db->nVTrans==0 );
3639 rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN,
3640 db->nStatement+db->nSavepoint);
3641 if( rc!=SQLITE_OK ) goto abort_due_to_error;
3642#endif
3643
3644 /* Create a new savepoint structure. */
3645 pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1);
3646 if( pNew ){
3647 pNew->zName = (char *)&pNew[1];
3648 memcpy(pNew->zName, zName, nName+1);
3649
3650 /* If there is no open transaction, then mark this as a special
3651 ** "transaction savepoint". */
3652 if( db->autoCommit ){
3653 db->autoCommit = 0;
3654 db->isTransactionSavepoint = 1;
3655 }else{
3656 db->nSavepoint++;
3657 }
3658
3659 /* Link the new savepoint into the database handle's list. */
3660 pNew->pNext = db->pSavepoint;
3661 db->pSavepoint = pNew;
3662 pNew->nDeferredCons = db->nDeferredCons;
3663 pNew->nDeferredImmCons = db->nDeferredImmCons;
3664 }
3665 }
3666 }else{
3667 assert( p1==SAVEPOINT_RELEASE || p1==SAVEPOINT_ROLLBACK );
3668 iSavepoint = 0;
3669
3670 /* Find the named savepoint. If there is no such savepoint, then an
3671 ** an error is returned to the user. */
3672 for(
3673 pSavepoint = db->pSavepoint;
3674 pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
3675 pSavepoint = pSavepoint->pNext
3676 ){
3677 iSavepoint++;
3678 }
3679 if( !pSavepoint ){
3680 sqlite3VdbeError(p, "no such savepoint: %s", zName);
3681 rc = SQLITE_ERROR;
3682 }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){
3683 /* It is not possible to release (commit) a savepoint if there are
3684 ** active write statements.
3685 */
3686 sqlite3VdbeError(p, "cannot release savepoint - "
3687 "SQL statements in progress");
3688 rc = SQLITE_BUSY;
3689 }else{
3690
3691 /* Determine whether or not this is a transaction savepoint. If so,
3692 ** and this is a RELEASE command, then the current transaction
3693 ** is committed.
3694 */
3695 int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint;
3696 if( isTransaction && p1==SAVEPOINT_RELEASE ){
3697 if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
3698 goto vdbe_return;
3699 }
3700 db->autoCommit = 1;
3701 if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
3702 p->pc = (int)(pOp - aOp);
3703 db->autoCommit = 0;
3704 p->rc = rc = SQLITE_BUSY;
3705 goto vdbe_return;
3706 }
3707 rc = p->rc;
3708 if( rc ){
3709 db->autoCommit = 0;
3710 }else{
3711 db->isTransactionSavepoint = 0;
3712 }
3713 }else{
3714 int isSchemaChange;
3715 iSavepoint = db->nSavepoint - iSavepoint - 1;
3716 if( p1==SAVEPOINT_ROLLBACK ){
3717 isSchemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0;
3718 for(ii=0; ii<db->nDb; ii++){
3719 rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt,
3720 SQLITE_ABORT_ROLLBACK,
3721 isSchemaChange==0);
3722 if( rc!=SQLITE_OK ) goto abort_due_to_error;
3723 }
3724 }else{
3725 assert( p1==SAVEPOINT_RELEASE );
3726 isSchemaChange = 0;
3727 }
3728 for(ii=0; ii<db->nDb; ii++){
3729 rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
3730 if( rc!=SQLITE_OK ){
3731 goto abort_due_to_error;
3732 }
3733 }
3734 if( isSchemaChange ){
3735 sqlite3ExpirePreparedStatements(db, 0);
3736 sqlite3ResetAllSchemasOfConnection(db);
3737 db->mDbFlags |= DBFLAG_SchemaChange;
3738 }
3739 }
3740 if( rc ) goto abort_due_to_error;
3741
3742 /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
3743 ** savepoints nested inside of the savepoint being operated on. */
3744 while( db->pSavepoint!=pSavepoint ){
3745 pTmp = db->pSavepoint;
3746 db->pSavepoint = pTmp->pNext;
3747 sqlite3DbFree(db, pTmp);
3748 db->nSavepoint--;
3749 }
3750
3751 /* If it is a RELEASE, then destroy the savepoint being operated on
3752 ** too. If it is a ROLLBACK TO, then set the number of deferred
3753 ** constraint violations present in the database to the value stored
3754 ** when the savepoint was created. */
3755 if( p1==SAVEPOINT_RELEASE ){
3756 assert( pSavepoint==db->pSavepoint );
3757 db->pSavepoint = pSavepoint->pNext;
3758 sqlite3DbFree(db, pSavepoint);
3759 if( !isTransaction ){
3760 db->nSavepoint--;
3761 }
3762 }else{
3763 assert( p1==SAVEPOINT_ROLLBACK );
3764 db->nDeferredCons = pSavepoint->nDeferredCons;
3765 db->nDeferredImmCons = pSavepoint->nDeferredImmCons;
3766 }
3767
3768 if( !isTransaction || p1==SAVEPOINT_ROLLBACK ){
3769 rc = sqlite3VtabSavepoint(db, p1, iSavepoint);
3770 if( rc!=SQLITE_OK ) goto abort_due_to_error;
3771 }
3772 }
3773 }
3774 if( rc ) goto abort_due_to_error;
3775 if( p->eVdbeState==VDBE_HALT_STATE ){
3776 rc = SQLITE_DONE;
3777 goto vdbe_return;
3778 }
3779 break;
3780}
3781
3782/* Opcode: AutoCommit P1 P2 * * *
3783**
3784** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
3785** back any currently active btree transactions. If there are any active
3786** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if
3787** there are active writing VMs or active VMs that use shared cache.
3788**
3789** This instruction causes the VM to halt.
3790*/
3791case OP_AutoCommit: {
3792 int desiredAutoCommit;
3793 int iRollback;
3794
3795 desiredAutoCommit = pOp->p1;
3796 iRollback = pOp->p2;
3797 assert( desiredAutoCommit==1 || desiredAutoCommit==0 );
3798 assert( desiredAutoCommit==1 || iRollback==0 );
3799 assert( db->nVdbeActive>0 ); /* At least this one VM is active */
3800 assert( p->bIsReader );
3801
3802 if( desiredAutoCommit!=db->autoCommit ){
3803 if( iRollback ){
3804 assert( desiredAutoCommit==1 );
3805 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
3806 db->autoCommit = 1;
3807 }else if( desiredAutoCommit && db->nVdbeWrite>0 ){
3808 /* If this instruction implements a COMMIT and other VMs are writing
3809 ** return an error indicating that the other VMs must complete first.
3810 */
3811 sqlite3VdbeError(p, "cannot commit transaction - "
3812 "SQL statements in progress");
3813 rc = SQLITE_BUSY;
3814 goto abort_due_to_error;
3815 }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
3816 goto vdbe_return;
3817 }else{
3818 db->autoCommit = (u8)desiredAutoCommit;
3819 }
3820 if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
3821 p->pc = (int)(pOp - aOp);
3822 db->autoCommit = (u8)(1-desiredAutoCommit);
3823 p->rc = rc = SQLITE_BUSY;
3824 goto vdbe_return;
3825 }
3826 sqlite3CloseSavepoints(db);
3827 if( p->rc==SQLITE_OK ){
3828 rc = SQLITE_DONE;
3829 }else{
3830 rc = SQLITE_ERROR;
3831 }
3832 goto vdbe_return;
3833 }else{
3834 sqlite3VdbeError(p,
3835 (!desiredAutoCommit)?"cannot start a transaction within a transaction":(
3836 (iRollback)?"cannot rollback - no transaction is active":
3837 "cannot commit - no transaction is active"));
3838
3839 rc = SQLITE_ERROR;
3840 goto abort_due_to_error;
3841 }
3842 /*NOTREACHED*/ assert(0);
3843}
3844
3845/* Opcode: Transaction P1 P2 P3 P4 P5
3846**
3847** Begin a transaction on database P1 if a transaction is not already
3848** active.
3849** If P2 is non-zero, then a write-transaction is started, or if a
3850** read-transaction is already active, it is upgraded to a write-transaction.
3851** If P2 is zero, then a read-transaction is started. If P2 is 2 or more
3852** then an exclusive transaction is started.
3853**
3854** P1 is the index of the database file on which the transaction is
3855** started. Index 0 is the main database file and index 1 is the
3856** file used for temporary tables. Indices of 2 or more are used for
3857** attached databases.
3858**
3859** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
3860** true (this flag is set if the Vdbe may modify more than one row and may
3861** throw an ABORT exception), a statement transaction may also be opened.
3862** More specifically, a statement transaction is opened iff the database
3863** connection is currently not in autocommit mode, or if there are other
3864** active statements. A statement transaction allows the changes made by this
3865** VDBE to be rolled back after an error without having to roll back the
3866** entire transaction. If no error is encountered, the statement transaction
3867** will automatically commit when the VDBE halts.
3868**
3869** If P5!=0 then this opcode also checks the schema cookie against P3
3870** and the schema generation counter against P4.
3871** The cookie changes its value whenever the database schema changes.
3872** This operation is used to detect when that the cookie has changed
3873** and that the current process needs to reread the schema. If the schema
3874** cookie in P3 differs from the schema cookie in the database header or
3875** if the schema generation counter in P4 differs from the current
3876** generation counter, then an SQLITE_SCHEMA error is raised and execution
3877** halts. The sqlite3_step() wrapper function might then reprepare the
3878** statement and rerun it from the beginning.
3879*/
3880case OP_Transaction: {
3881 Btree *pBt;
3882 Db *pDb;
3883 int iMeta = 0;
3884
3885 assert( p->bIsReader );
3886 assert( p->readOnly==0 || pOp->p2==0 );
3887 assert( pOp->p2>=0 && pOp->p2<=2 );
3888 assert( pOp->p1>=0 && pOp->p1<db->nDb );
3889 assert( DbMaskTest(p->btreeMask, pOp->p1) );
3890 assert( rc==SQLITE_OK );
3891 if( pOp->p2 && (db->flags & (SQLITE_QueryOnly|SQLITE_CorruptRdOnly))!=0 ){
3892 if( db->flags & SQLITE_QueryOnly ){
3893 /* Writes prohibited by the "PRAGMA query_only=TRUE" statement */
3894 rc = SQLITE_READONLY;
3895 }else{
3896 /* Writes prohibited due to a prior SQLITE_CORRUPT in the current
3897 ** transaction */
3898 rc = SQLITE_CORRUPT;
3899 }
3900 goto abort_due_to_error;
3901 }
3902 pDb = &db->aDb[pOp->p1];
3903 pBt = pDb->pBt;
3904
3905 if( pBt ){
3906 rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta);
3907 testcase( rc==SQLITE_BUSY_SNAPSHOT );
3908 testcase( rc==SQLITE_BUSY_RECOVERY );
3909 if( rc!=SQLITE_OK ){
3910 if( (rc&0xff)==SQLITE_BUSY ){
3911 p->pc = (int)(pOp - aOp);
3912 p->rc = rc;
3913 goto vdbe_return;
3914 }
3915 goto abort_due_to_error;
3916 }
3917
3918 if( p->usesStmtJournal
3919 && pOp->p2
3920 && (db->autoCommit==0 || db->nVdbeRead>1)
3921 ){
3922 assert( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE );
3923 if( p->iStatement==0 ){
3924 assert( db->nStatement>=0 && db->nSavepoint>=0 );
3925 db->nStatement++;
3926 p->iStatement = db->nSavepoint + db->nStatement;
3927 }
3928
3929 rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
3930 if( rc==SQLITE_OK ){
3931 rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
3932 }
3933
3934 /* Store the current value of the database handles deferred constraint
3935 ** counter. If the statement transaction needs to be rolled back,
3936 ** the value of this counter needs to be restored too. */
3937 p->nStmtDefCons = db->nDeferredCons;
3938 p->nStmtDefImmCons = db->nDeferredImmCons;
3939 }
3940 }
3941 assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
3942 if( rc==SQLITE_OK
3943 && pOp->p5
3944 && (iMeta!=pOp->p3 || pDb->pSchema->iGeneration!=pOp->p4.i)
3945 ){
3946 /*
3947 ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema
3948 ** version is checked to ensure that the schema has not changed since the
3949 ** SQL statement was prepared.
3950 */
3951 sqlite3DbFree(db, p->zErrMsg);
3952 p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
3953 /* If the schema-cookie from the database file matches the cookie
3954 ** stored with the in-memory representation of the schema, do
3955 ** not reload the schema from the database file.
3956 **
3957 ** If virtual-tables are in use, this is not just an optimization.
3958 ** Often, v-tables store their data in other SQLite tables, which
3959 ** are queried from within xNext() and other v-table methods using
3960 ** prepared queries. If such a query is out-of-date, we do not want to
3961 ** discard the database schema, as the user code implementing the
3962 ** v-table would have to be ready for the sqlite3_vtab structure itself
3963 ** to be invalidated whenever sqlite3_step() is called from within
3964 ** a v-table method.
3965 */
3966 if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
3967 sqlite3ResetOneSchema(db, pOp->p1);
3968 }
3969 p->expired = 1;
3970 rc = SQLITE_SCHEMA;
3971
3972 /* Set changeCntOn to 0 to prevent the value returned by sqlite3_changes()
3973 ** from being modified in sqlite3VdbeHalt(). If this statement is
3974 ** reprepared, changeCntOn will be set again. */
3975 p->changeCntOn = 0;
3976 }
3977 if( rc ) goto abort_due_to_error;
3978 break;
3979}
3980
3981/* Opcode: ReadCookie P1 P2 P3 * *
3982**
3983** Read cookie number P3 from database P1 and write it into register P2.
3984** P3==1 is the schema version. P3==2 is the database format.
3985** P3==3 is the recommended pager cache size, and so forth. P1==0 is
3986** the main database file and P1==1 is the database file used to store
3987** temporary tables.
3988**
3989** There must be a read-lock on the database (either a transaction
3990** must be started or there must be an open cursor) before
3991** executing this instruction.
3992*/
3993case OP_ReadCookie: { /* out2 */
3994 int iMeta;
3995 int iDb;
3996 int iCookie;
3997
3998 assert( p->bIsReader );
3999 iDb = pOp->p1;
4000 iCookie = pOp->p3;
4001 assert( pOp->p3<SQLITE_N_BTREE_META );
4002 assert( iDb>=0 && iDb<db->nDb );
4003 assert( db->aDb[iDb].pBt!=0 );
4004 assert( DbMaskTest(p->btreeMask, iDb) );
4005
4006 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
4007 pOut = out2Prerelease(p, pOp);
4008 pOut->u.i = iMeta;
4009 break;
4010}
4011
4012/* Opcode: SetCookie P1 P2 P3 * P5
4013**
4014** Write the integer value P3 into cookie number P2 of database P1.
4015** P2==1 is the schema version. P2==2 is the database format.
4016** P2==3 is the recommended pager cache
4017** size, and so forth. P1==0 is the main database file and P1==1 is the
4018** database file used to store temporary tables.
4019**
4020** A transaction must be started before executing this opcode.
4021**
4022** If P2 is the SCHEMA_VERSION cookie (cookie number 1) then the internal
4023** schema version is set to P3-P5. The "PRAGMA schema_version=N" statement
4024** has P5 set to 1, so that the internal schema version will be different
4025** from the database schema version, resulting in a schema reset.
4026*/
4027case OP_SetCookie: {
4028 Db *pDb;
4029
4030 sqlite3VdbeIncrWriteCounter(p, 0);
4031 assert( pOp->p2<SQLITE_N_BTREE_META );
4032 assert( pOp->p1>=0 && pOp->p1<db->nDb );
4033 assert( DbMaskTest(p->btreeMask, pOp->p1) );
4034 assert( p->readOnly==0 );
4035 pDb = &db->aDb[pOp->p1];
4036 assert( pDb->pBt!=0 );
4037 assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
4038 /* See note about index shifting on OP_ReadCookie */
4039 rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3);
4040 if( pOp->p2==BTREE_SCHEMA_VERSION ){
4041 /* When the schema cookie changes, record the new cookie internally */
4042 *(u32*)&pDb->pSchema->schema_cookie = *(u32*)&pOp->p3 - pOp->p5;
4043 db->mDbFlags |= DBFLAG_SchemaChange;
4044 sqlite3FkClearTriggerCache(db, pOp->p1);
4045 }else if( pOp->p2==BTREE_FILE_FORMAT ){
4046 /* Record changes in the file format */
4047 pDb->pSchema->file_format = pOp->p3;
4048 }
4049 if( pOp->p1==1 ){
4050 /* Invalidate all prepared statements whenever the TEMP database
4051 ** schema is changed. Ticket #1644 */
4052 sqlite3ExpirePreparedStatements(db, 0);
4053 p->expired = 0;
4054 }
4055 if( rc ) goto abort_due_to_error;
4056 break;
4057}
4058
4059/* Opcode: OpenRead P1 P2 P3 P4 P5
4060** Synopsis: root=P2 iDb=P3
4061**
4062** Open a read-only cursor for the database table whose root page is
4063** P2 in a database file. The database file is determined by P3.
4064** P3==0 means the main database, P3==1 means the database used for
4065** temporary tables, and P3>1 means used the corresponding attached
4066** database. Give the new cursor an identifier of P1. The P1
4067** values need not be contiguous but all P1 values should be small integers.
4068** It is an error for P1 to be negative.
4069**
4070** Allowed P5 bits:
4071** <ul>
4072** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
4073** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
4074** of OP_SeekLE/OP_IdxLT)
4075** </ul>
4076**
4077** The P4 value may be either an integer (P4_INT32) or a pointer to
4078** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
4079** object, then table being opened must be an [index b-tree] where the
4080** KeyInfo object defines the content and collating
4081** sequence of that index b-tree. Otherwise, if P4 is an integer
4082** value, then the table being opened must be a [table b-tree] with a
4083** number of columns no less than the value of P4.
4084**
4085** See also: OpenWrite, ReopenIdx
4086*/
4087/* Opcode: ReopenIdx P1 P2 P3 P4 P5
4088** Synopsis: root=P2 iDb=P3
4089**
4090** The ReopenIdx opcode works like OP_OpenRead except that it first
4091** checks to see if the cursor on P1 is already open on the same
4092** b-tree and if it is this opcode becomes a no-op. In other words,
4093** if the cursor is already open, do not reopen it.
4094**
4095** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ
4096** and with P4 being a P4_KEYINFO object. Furthermore, the P3 value must
4097** be the same as every other ReopenIdx or OpenRead for the same cursor
4098** number.
4099**
4100** Allowed P5 bits:
4101** <ul>
4102** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
4103** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
4104** of OP_SeekLE/OP_IdxLT)
4105** </ul>
4106**
4107** See also: OP_OpenRead, OP_OpenWrite
4108*/
4109/* Opcode: OpenWrite P1 P2 P3 P4 P5
4110** Synopsis: root=P2 iDb=P3
4111**
4112** Open a read/write cursor named P1 on the table or index whose root
4113** page is P2 (or whose root page is held in register P2 if the
4114** OPFLAG_P2ISREG bit is set in P5 - see below).
4115**
4116** The P4 value may be either an integer (P4_INT32) or a pointer to
4117** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
4118** object, then table being opened must be an [index b-tree] where the
4119** KeyInfo object defines the content and collating
4120** sequence of that index b-tree. Otherwise, if P4 is an integer
4121** value, then the table being opened must be a [table b-tree] with a
4122** number of columns no less than the value of P4.
4123**
4124** Allowed P5 bits:
4125** <ul>
4126** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
4127** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
4128** of OP_SeekLE/OP_IdxLT)
4129** <li> <b>0x08 OPFLAG_FORDELETE</b>: This cursor is used only to seek
4130** and subsequently delete entries in an index btree. This is a
4131** hint to the storage engine that the storage engine is allowed to
4132** ignore. The hint is not used by the official SQLite b*tree storage
4133** engine, but is used by COMDB2.
4134** <li> <b>0x10 OPFLAG_P2ISREG</b>: Use the content of register P2
4135** as the root page, not the value of P2 itself.
4136** </ul>
4137**
4138** This instruction works like OpenRead except that it opens the cursor
4139** in read/write mode.
4140**
4141** See also: OP_OpenRead, OP_ReopenIdx
4142*/
4143case OP_ReopenIdx: {
4144 int nField;
4145 KeyInfo *pKeyInfo;
4146 u32 p2;
4147 int iDb;
4148 int wrFlag;
4149 Btree *pX;
4150 VdbeCursor *pCur;
4151 Db *pDb;
4152
4153 assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
4154 assert( pOp->p4type==P4_KEYINFO );
4155 pCur = p->apCsr[pOp->p1];
4156 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
4157 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
4158 assert( pCur->eCurType==CURTYPE_BTREE );
4159 sqlite3BtreeClearCursor(pCur->uc.pCursor);
4160 goto open_cursor_set_hints;
4161 }
4162 /* If the cursor is not currently open or is open on a different
4163 ** index, then fall through into OP_OpenRead to force a reopen */
4164case OP_OpenRead:
4165case OP_OpenWrite:
4166
4167 assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
4168 assert( p->bIsReader );
4169 assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
4170 || p->readOnly==0 );
4171
4172 if( p->expired==1 ){
4173 rc = SQLITE_ABORT_ROLLBACK;
4174 goto abort_due_to_error;
4175 }
4176
4177 nField = 0;
4178 pKeyInfo = 0;
4179 p2 = (u32)pOp->p2;
4180 iDb = pOp->p3;
4181 assert( iDb>=0 && iDb<db->nDb );
4182 assert( DbMaskTest(p->btreeMask, iDb) );
4183 pDb = &db->aDb[iDb];
4184 pX = pDb->pBt;
4185 assert( pX!=0 );
4186 if( pOp->opcode==OP_OpenWrite ){
4187 assert( OPFLAG_FORDELETE==BTREE_FORDELETE );
4188 wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE);
4189 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
4190 if( pDb->pSchema->file_format < p->minWriteFileFormat ){
4191 p->minWriteFileFormat = pDb->pSchema->file_format;
4192 }
4193 }else{
4194 wrFlag = 0;
4195 }
4196 if( pOp->p5 & OPFLAG_P2ISREG ){
4197 assert( p2>0 );
4198 assert( p2<=(u32)(p->nMem+1 - p->nCursor) );
4199 assert( pOp->opcode==OP_OpenWrite );
4200 pIn2 = &aMem[p2];
4201 assert( memIsValid(pIn2) );
4202 assert( (pIn2->flags & MEM_Int)!=0 );
4203 sqlite3VdbeMemIntegerify(pIn2);
4204 p2 = (int)pIn2->u.i;
4205 /* The p2 value always comes from a prior OP_CreateBtree opcode and
4206 ** that opcode will always set the p2 value to 2 or more or else fail.
4207 ** If there were a failure, the prepared statement would have halted
4208 ** before reaching this instruction. */
4209 assert( p2>=2 );
4210 }
4211 if( pOp->p4type==P4_KEYINFO ){
4212 pKeyInfo = pOp->p4.pKeyInfo;
4213 assert( pKeyInfo->enc==ENC(db) );
4214 assert( pKeyInfo->db==db );
4215 nField = pKeyInfo->nAllField;
4216 }else if( pOp->p4type==P4_INT32 ){
4217 nField = pOp->p4.i;
4218 }
4219 assert( pOp->p1>=0 );
4220 assert( nField>=0 );
4221 testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */
4222 pCur = allocateCursor(p, pOp->p1, nField, CURTYPE_BTREE);
4223 if( pCur==0 ) goto no_mem;
4224 pCur->iDb = iDb;
4225 pCur->nullRow = 1;
4226 pCur->isOrdered = 1;
4227 pCur->pgnoRoot = p2;
4228#ifdef SQLITE_DEBUG
4229 pCur->wrFlag = wrFlag;
4230#endif
4231 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
4232 pCur->pKeyInfo = pKeyInfo;
4233 /* Set the VdbeCursor.isTable variable. Previous versions of
4234 ** SQLite used to check if the root-page flags were sane at this point
4235 ** and report database corruption if they were not, but this check has
4236 ** since moved into the btree layer. */
4237 pCur->isTable = pOp->p4type!=P4_KEYINFO;
4238
4239open_cursor_set_hints:
4240 assert( OPFLAG_BULKCSR==BTREE_BULKLOAD );
4241 assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ );
4242 testcase( pOp->p5 & OPFLAG_BULKCSR );
4243 testcase( pOp->p2 & OPFLAG_SEEKEQ );
4244 sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
4245 (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ)));
4246 if( rc ) goto abort_due_to_error;
4247 break;
4248}
4249
4250/* Opcode: OpenDup P1 P2 * * *
4251**
4252** Open a new cursor P1 that points to the same ephemeral table as
4253** cursor P2. The P2 cursor must have been opened by a prior OP_OpenEphemeral
4254** opcode. Only ephemeral cursors may be duplicated.
4255**
4256** Duplicate ephemeral cursors are used for self-joins of materialized views.
4257*/
4258case OP_OpenDup: {
4259 VdbeCursor *pOrig; /* The original cursor to be duplicated */
4260 VdbeCursor *pCx; /* The new cursor */
4261
4262 pOrig = p->apCsr[pOp->p2];
4263 assert( pOrig );
4264 assert( pOrig->isEphemeral ); /* Only ephemeral cursors can be duplicated */
4265
4266 pCx = allocateCursor(p, pOp->p1, pOrig->nField, CURTYPE_BTREE);
4267 if( pCx==0 ) goto no_mem;
4268 pCx->nullRow = 1;
4269 pCx->isEphemeral = 1;
4270 pCx->pKeyInfo = pOrig->pKeyInfo;
4271 pCx->isTable = pOrig->isTable;
4272 pCx->pgnoRoot = pOrig->pgnoRoot;
4273 pCx->isOrdered = pOrig->isOrdered;
4274 pCx->ub.pBtx = pOrig->ub.pBtx;
4275 pCx->noReuse = 1;
4276 pOrig->noReuse = 1;
4277 rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR,
4278 pCx->pKeyInfo, pCx->uc.pCursor);
4279 /* The sqlite3BtreeCursor() routine can only fail for the first cursor
4280 ** opened for a database. Since there is already an open cursor when this
4281 ** opcode is run, the sqlite3BtreeCursor() cannot fail */
4282 assert( rc==SQLITE_OK );
4283 break;
4284}
4285
4286
4287/* Opcode: OpenEphemeral P1 P2 P3 P4 P5
4288** Synopsis: nColumn=P2
4289**
4290** Open a new cursor P1 to a transient table.
4291** The cursor is always opened read/write even if
4292** the main database is read-only. The ephemeral
4293** table is deleted automatically when the cursor is closed.
4294**
4295** If the cursor P1 is already opened on an ephemeral table, the table
4296** is cleared (all content is erased).
4297**
4298** P2 is the number of columns in the ephemeral table.
4299** The cursor points to a BTree table if P4==0 and to a BTree index
4300** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
4301** that defines the format of keys in the index.
4302**
4303** The P5 parameter can be a mask of the BTREE_* flags defined
4304** in btree.h. These flags control aspects of the operation of
4305** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
4306** added automatically.
4307**
4308** If P3 is positive, then reg[P3] is modified slightly so that it
4309** can be used as zero-length data for OP_Insert. This is an optimization
4310** that avoids an extra OP_Blob opcode to initialize that register.
4311*/
4312/* Opcode: OpenAutoindex P1 P2 * P4 *
4313** Synopsis: nColumn=P2
4314**
4315** This opcode works the same as OP_OpenEphemeral. It has a
4316** different name to distinguish its use. Tables created using
4317** by this opcode will be used for automatically created transient
4318** indices in joins.
4319*/
4320case OP_OpenAutoindex:
4321case OP_OpenEphemeral: {
4322 VdbeCursor *pCx;
4323 KeyInfo *pKeyInfo;
4324
4325 static const int vfsFlags =
4326 SQLITE_OPEN_READWRITE |
4327 SQLITE_OPEN_CREATE |
4328 SQLITE_OPEN_EXCLUSIVE |
4329 SQLITE_OPEN_DELETEONCLOSE |
4330 SQLITE_OPEN_TRANSIENT_DB;
4331 assert( pOp->p1>=0 );
4332 assert( pOp->p2>=0 );
4333 if( pOp->p3>0 ){
4334 /* Make register reg[P3] into a value that can be used as the data
4335 ** form sqlite3BtreeInsert() where the length of the data is zero. */
4336 assert( pOp->p2==0 ); /* Only used when number of columns is zero */
4337 assert( pOp->opcode==OP_OpenEphemeral );
4338 assert( aMem[pOp->p3].flags & MEM_Null );
4339 aMem[pOp->p3].n = 0;
4340 aMem[pOp->p3].z = "";
4341 }
4342 pCx = p->apCsr[pOp->p1];
4343 if( pCx && !pCx->noReuse && ALWAYS(pOp->p2<=pCx->nField) ){
4344 /* If the ephermeral table is already open and has no duplicates from
4345 ** OP_OpenDup, then erase all existing content so that the table is
4346 ** empty again, rather than creating a new table. */
4347 assert( pCx->isEphemeral );
4348 pCx->seqCount = 0;
4349 pCx->cacheStatus = CACHE_STALE;
4350 rc = sqlite3BtreeClearTable(pCx->ub.pBtx, pCx->pgnoRoot, 0);
4351 }else{
4352 pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_BTREE);
4353 if( pCx==0 ) goto no_mem;
4354 pCx->isEphemeral = 1;
4355 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->ub.pBtx,
4356 BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5,
4357 vfsFlags);
4358 if( rc==SQLITE_OK ){
4359 rc = sqlite3BtreeBeginTrans(pCx->ub.pBtx, 1, 0);
4360 if( rc==SQLITE_OK ){
4361 /* If a transient index is required, create it by calling
4362 ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
4363 ** opening it. If a transient table is required, just use the
4364 ** automatically created table with root-page 1 (an BLOB_INTKEY table).
4365 */
4366 if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
4367 assert( pOp->p4type==P4_KEYINFO );
4368 rc = sqlite3BtreeCreateTable(pCx->ub.pBtx, &pCx->pgnoRoot,
4369 BTREE_BLOBKEY | pOp->p5);
4370 if( rc==SQLITE_OK ){
4371 assert( pCx->pgnoRoot==SCHEMA_ROOT+1 );
4372 assert( pKeyInfo->db==db );
4373 assert( pKeyInfo->enc==ENC(db) );
4374 rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR,
4375 pKeyInfo, pCx->uc.pCursor);
4376 }
4377 pCx->isTable = 0;
4378 }else{
4379 pCx->pgnoRoot = SCHEMA_ROOT;
4380 rc = sqlite3BtreeCursor(pCx->ub.pBtx, SCHEMA_ROOT, BTREE_WRCSR,
4381 0, pCx->uc.pCursor);
4382 pCx->isTable = 1;
4383 }
4384 }
4385 pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
4386 if( rc ){
4387 sqlite3BtreeClose(pCx->ub.pBtx);
4388 }
4389 }
4390 }
4391 if( rc ) goto abort_due_to_error;
4392 pCx->nullRow = 1;
4393 break;
4394}
4395
4396/* Opcode: SorterOpen P1 P2 P3 P4 *
4397**
4398** This opcode works like OP_OpenEphemeral except that it opens
4399** a transient index that is specifically designed to sort large
4400** tables using an external merge-sort algorithm.
4401**
4402** If argument P3 is non-zero, then it indicates that the sorter may
4403** assume that a stable sort considering the first P3 fields of each
4404** key is sufficient to produce the required results.
4405*/
4406case OP_SorterOpen: {
4407 VdbeCursor *pCx;
4408
4409 assert( pOp->p1>=0 );
4410 assert( pOp->p2>=0 );
4411 pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_SORTER);
4412 if( pCx==0 ) goto no_mem;
4413 pCx->pKeyInfo = pOp->p4.pKeyInfo;
4414 assert( pCx->pKeyInfo->db==db );
4415 assert( pCx->pKeyInfo->enc==ENC(db) );
4416 rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx);
4417 if( rc ) goto abort_due_to_error;
4418 break;
4419}
4420
4421/* Opcode: SequenceTest P1 P2 * * *
4422** Synopsis: if( cursor[P1].ctr++ ) pc = P2
4423**
4424** P1 is a sorter cursor. If the sequence counter is currently zero, jump
4425** to P2. Regardless of whether or not the jump is taken, increment the
4426** the sequence value.
4427*/
4428case OP_SequenceTest: {
4429 VdbeCursor *pC;
4430 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4431 pC = p->apCsr[pOp->p1];
4432 assert( isSorter(pC) );
4433 if( (pC->seqCount++)==0 ){
4434 goto jump_to_p2;
4435 }
4436 break;
4437}
4438
4439/* Opcode: OpenPseudo P1 P2 P3 * *
4440** Synopsis: P3 columns in r[P2]
4441**
4442** Open a new cursor that points to a fake table that contains a single
4443** row of data. The content of that one row is the content of memory
4444** register P2. In other words, cursor P1 becomes an alias for the
4445** MEM_Blob content contained in register P2.
4446**
4447** A pseudo-table created by this opcode is used to hold a single
4448** row output from the sorter so that the row can be decomposed into
4449** individual columns using the OP_Column opcode. The OP_Column opcode
4450** is the only cursor opcode that works with a pseudo-table.
4451**
4452** P3 is the number of fields in the records that will be stored by
4453** the pseudo-table.
4454*/
4455case OP_OpenPseudo: {
4456 VdbeCursor *pCx;
4457
4458 assert( pOp->p1>=0 );
4459 assert( pOp->p3>=0 );
4460 pCx = allocateCursor(p, pOp->p1, pOp->p3, CURTYPE_PSEUDO);
4461 if( pCx==0 ) goto no_mem;
4462 pCx->nullRow = 1;
4463 pCx->seekResult = pOp->p2;
4464 pCx->isTable = 1;
4465 /* Give this pseudo-cursor a fake BtCursor pointer so that pCx
4466 ** can be safely passed to sqlite3VdbeCursorMoveto(). This avoids a test
4467 ** for pCx->eCurType==CURTYPE_BTREE inside of sqlite3VdbeCursorMoveto()
4468 ** which is a performance optimization */
4469 pCx->uc.pCursor = sqlite3BtreeFakeValidCursor();
4470 assert( pOp->p5==0 );
4471 break;
4472}
4473
4474/* Opcode: Close P1 * * * *
4475**
4476** Close a cursor previously opened as P1. If P1 is not
4477** currently open, this instruction is a no-op.
4478*/
4479case OP_Close: {
4480 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4481 sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
4482 p->apCsr[pOp->p1] = 0;
4483 break;
4484}
4485
4486#ifdef SQLITE_ENABLE_COLUMN_USED_MASK
4487/* Opcode: ColumnsUsed P1 * * P4 *
4488**
4489** This opcode (which only exists if SQLite was compiled with
4490** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the
4491** table or index for cursor P1 are used. P4 is a 64-bit integer
4492** (P4_INT64) in which the first 63 bits are one for each of the
4493** first 63 columns of the table or index that are actually used
4494** by the cursor. The high-order bit is set if any column after
4495** the 64th is used.
4496*/
4497case OP_ColumnsUsed: {
4498 VdbeCursor *pC;
4499 pC = p->apCsr[pOp->p1];
4500 assert( pC->eCurType==CURTYPE_BTREE );
4501 pC->maskUsed = *(u64*)pOp->p4.pI64;
4502 break;
4503}
4504#endif
4505
4506/* Opcode: SeekGE P1 P2 P3 P4 *
4507** Synopsis: key=r[P3@P4]
4508**
4509** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
4510** use the value in register P3 as the key. If cursor P1 refers
4511** to an SQL index, then P3 is the first in an array of P4 registers
4512** that are used as an unpacked index key.
4513**
4514** Reposition cursor P1 so that it points to the smallest entry that
4515** is greater than or equal to the key value. If there are no records
4516** greater than or equal to the key and P2 is not zero, then jump to P2.
4517**
4518** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
4519** opcode will either land on a record that exactly matches the key, or
4520** else it will cause a jump to P2. When the cursor is OPFLAG_SEEKEQ,
4521** this opcode must be followed by an IdxLE opcode with the same arguments.
4522** The IdxGT opcode will be skipped if this opcode succeeds, but the
4523** IdxGT opcode will be used on subsequent loop iterations. The
4524** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this
4525** is an equality search.
4526**
4527** This opcode leaves the cursor configured to move in forward order,
4528** from the beginning toward the end. In other words, the cursor is
4529** configured to use Next, not Prev.
4530**
4531** See also: Found, NotFound, SeekLt, SeekGt, SeekLe
4532*/
4533/* Opcode: SeekGT P1 P2 P3 P4 *
4534** Synopsis: key=r[P3@P4]
4535**
4536** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
4537** use the value in register P3 as a key. If cursor P1 refers
4538** to an SQL index, then P3 is the first in an array of P4 registers
4539** that are used as an unpacked index key.
4540**
4541** Reposition cursor P1 so that it points to the smallest entry that
4542** is greater than the key value. If there are no records greater than
4543** the key and P2 is not zero, then jump to P2.
4544**
4545** This opcode leaves the cursor configured to move in forward order,
4546** from the beginning toward the end. In other words, the cursor is
4547** configured to use Next, not Prev.
4548**
4549** See also: Found, NotFound, SeekLt, SeekGe, SeekLe
4550*/
4551/* Opcode: SeekLT P1 P2 P3 P4 *
4552** Synopsis: key=r[P3@P4]
4553**
4554** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
4555** use the value in register P3 as a key. If cursor P1 refers
4556** to an SQL index, then P3 is the first in an array of P4 registers
4557** that are used as an unpacked index key.
4558**
4559** Reposition cursor P1 so that it points to the largest entry that
4560** is less than the key value. If there are no records less than
4561** the key and P2 is not zero, then jump to P2.
4562**
4563** This opcode leaves the cursor configured to move in reverse order,
4564** from the end toward the beginning. In other words, the cursor is
4565** configured to use Prev, not Next.
4566**
4567** See also: Found, NotFound, SeekGt, SeekGe, SeekLe
4568*/
4569/* Opcode: SeekLE P1 P2 P3 P4 *
4570** Synopsis: key=r[P3@P4]
4571**
4572** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
4573** use the value in register P3 as a key. If cursor P1 refers
4574** to an SQL index, then P3 is the first in an array of P4 registers
4575** that are used as an unpacked index key.
4576**
4577** Reposition cursor P1 so that it points to the largest entry that
4578** is less than or equal to the key value. If there are no records
4579** less than or equal to the key and P2 is not zero, then jump to P2.
4580**
4581** This opcode leaves the cursor configured to move in reverse order,
4582** from the end toward the beginning. In other words, the cursor is
4583** configured to use Prev, not Next.
4584**
4585** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
4586** opcode will either land on a record that exactly matches the key, or
4587** else it will cause a jump to P2. When the cursor is OPFLAG_SEEKEQ,
4588** this opcode must be followed by an IdxLE opcode with the same arguments.
4589** The IdxGE opcode will be skipped if this opcode succeeds, but the
4590** IdxGE opcode will be used on subsequent loop iterations. The
4591** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this
4592** is an equality search.
4593**
4594** See also: Found, NotFound, SeekGt, SeekGe, SeekLt
4595*/
4596case OP_SeekLT: /* jump, in3, group */
4597case OP_SeekLE: /* jump, in3, group */
4598case OP_SeekGE: /* jump, in3, group */
4599case OP_SeekGT: { /* jump, in3, group */
4600 int res; /* Comparison result */
4601 int oc; /* Opcode */
4602 VdbeCursor *pC; /* The cursor to seek */
4603 UnpackedRecord r; /* The key to seek for */
4604 int nField; /* Number of columns or fields in the key */
4605 i64 iKey; /* The rowid we are to seek to */
4606 int eqOnly; /* Only interested in == results */
4607
4608 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4609 assert( pOp->p2!=0 );
4610 pC = p->apCsr[pOp->p1];
4611 assert( pC!=0 );
4612 assert( pC->eCurType==CURTYPE_BTREE );
4613 assert( OP_SeekLE == OP_SeekLT+1 );
4614 assert( OP_SeekGE == OP_SeekLT+2 );
4615 assert( OP_SeekGT == OP_SeekLT+3 );
4616 assert( pC->isOrdered );
4617 assert( pC->uc.pCursor!=0 );
4618 oc = pOp->opcode;
4619 eqOnly = 0;
4620 pC->nullRow = 0;
4621#ifdef SQLITE_DEBUG
4622 pC->seekOp = pOp->opcode;
4623#endif
4624
4625 pC->deferredMoveto = 0;
4626 pC->cacheStatus = CACHE_STALE;
4627 if( pC->isTable ){
4628 u16 flags3, newType;
4629 /* The OPFLAG_SEEKEQ/BTREE_SEEK_EQ flag is only set on index cursors */
4630 assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
4631 || CORRUPT_DB );
4632
4633 /* The input value in P3 might be of any type: integer, real, string,
4634 ** blob, or NULL. But it needs to be an integer before we can do
4635 ** the seek, so convert it. */
4636 pIn3 = &aMem[pOp->p3];
4637 flags3 = pIn3->flags;
4638 if( (flags3 & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Str))==MEM_Str ){
4639 applyNumericAffinity(pIn3, 0);
4640 }
4641 iKey = sqlite3VdbeIntValue(pIn3); /* Get the integer key value */
4642 newType = pIn3->flags; /* Record the type after applying numeric affinity */
4643 pIn3->flags = flags3; /* But convert the type back to its original */
4644
4645 /* If the P3 value could not be converted into an integer without
4646 ** loss of information, then special processing is required... */
4647 if( (newType & (MEM_Int|MEM_IntReal))==0 ){
4648 int c;
4649 if( (newType & MEM_Real)==0 ){
4650 if( (newType & MEM_Null) || oc>=OP_SeekGE ){
4651 VdbeBranchTaken(1,2);
4652 goto jump_to_p2;
4653 }else{
4654 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
4655 if( rc!=SQLITE_OK ) goto abort_due_to_error;
4656 goto seek_not_found;
4657 }
4658 }
4659 c = sqlite3IntFloatCompare(iKey, pIn3->u.r);
4660
4661 /* If the approximation iKey is larger than the actual real search
4662 ** term, substitute >= for > and < for <=. e.g. if the search term
4663 ** is 4.9 and the integer approximation 5:
4664 **
4665 ** (x > 4.9) -> (x >= 5)
4666 ** (x <= 4.9) -> (x < 5)
4667 */
4668 if( c>0 ){
4669 assert( OP_SeekGE==(OP_SeekGT-1) );
4670 assert( OP_SeekLT==(OP_SeekLE-1) );
4671 assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) );
4672 if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--;
4673 }
4674
4675 /* If the approximation iKey is smaller than the actual real search
4676 ** term, substitute <= for < and > for >=. */
4677 else if( c<0 ){
4678 assert( OP_SeekLE==(OP_SeekLT+1) );
4679 assert( OP_SeekGT==(OP_SeekGE+1) );
4680 assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) );
4681 if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++;
4682 }
4683 }
4684 rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)iKey, 0, &res);
4685 pC->movetoTarget = iKey; /* Used by OP_Delete */
4686 if( rc!=SQLITE_OK ){
4687 goto abort_due_to_error;
4688 }
4689 }else{
4690 /* For a cursor with the OPFLAG_SEEKEQ/BTREE_SEEK_EQ hint, only the
4691 ** OP_SeekGE and OP_SeekLE opcodes are allowed, and these must be
4692 ** immediately followed by an OP_IdxGT or OP_IdxLT opcode, respectively,
4693 ** with the same key.
4694 */
4695 if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
4696 eqOnly = 1;
4697 assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE );
4698 assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
4699 assert( pOp->opcode==OP_SeekGE || pOp[1].opcode==OP_IdxLT );
4700 assert( pOp->opcode==OP_SeekLE || pOp[1].opcode==OP_IdxGT );
4701 assert( pOp[1].p1==pOp[0].p1 );
4702 assert( pOp[1].p2==pOp[0].p2 );
4703 assert( pOp[1].p3==pOp[0].p3 );
4704 assert( pOp[1].p4.i==pOp[0].p4.i );
4705 }
4706
4707 nField = pOp->p4.i;
4708 assert( pOp->p4type==P4_INT32 );
4709 assert( nField>0 );
4710 r.pKeyInfo = pC->pKeyInfo;
4711 r.nField = (u16)nField;
4712
4713 /* The next line of code computes as follows, only faster:
4714 ** if( oc==OP_SeekGT || oc==OP_SeekLE ){
4715 ** r.default_rc = -1;
4716 ** }else{
4717 ** r.default_rc = +1;
4718 ** }
4719 */
4720 r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1);
4721 assert( oc!=OP_SeekGT || r.default_rc==-1 );
4722 assert( oc!=OP_SeekLE || r.default_rc==-1 );
4723 assert( oc!=OP_SeekGE || r.default_rc==+1 );
4724 assert( oc!=OP_SeekLT || r.default_rc==+1 );
4725
4726 r.aMem = &aMem[pOp->p3];
4727#ifdef SQLITE_DEBUG
4728 {
4729 int i;
4730 for(i=0; i<r.nField; i++){
4731 assert( memIsValid(&r.aMem[i]) );
4732 if( i>0 ) REGISTER_TRACE(pOp->p3+i, &r.aMem[i]);
4733 }
4734 }
4735#endif
4736 r.eqSeen = 0;
4737 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &res);
4738 if( rc!=SQLITE_OK ){
4739 goto abort_due_to_error;
4740 }
4741 if( eqOnly && r.eqSeen==0 ){
4742 assert( res!=0 );
4743 goto seek_not_found;
4744 }
4745 }
4746#ifdef SQLITE_TEST
4747 sqlite3_search_count++;
4748#endif
4749 if( oc>=OP_SeekGE ){ assert( oc==OP_SeekGE || oc==OP_SeekGT );
4750 if( res<0 || (res==0 && oc==OP_SeekGT) ){
4751 res = 0;
4752 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
4753 if( rc!=SQLITE_OK ){
4754 if( rc==SQLITE_DONE ){
4755 rc = SQLITE_OK;
4756 res = 1;
4757 }else{
4758 goto abort_due_to_error;
4759 }
4760 }
4761 }else{
4762 res = 0;
4763 }
4764 }else{
4765 assert( oc==OP_SeekLT || oc==OP_SeekLE );
4766 if( res>0 || (res==0 && oc==OP_SeekLT) ){
4767 res = 0;
4768 rc = sqlite3BtreePrevious(pC->uc.pCursor, 0);
4769 if( rc!=SQLITE_OK ){
4770 if( rc==SQLITE_DONE ){
4771 rc = SQLITE_OK;
4772 res = 1;
4773 }else{
4774 goto abort_due_to_error;
4775 }
4776 }
4777 }else{
4778 /* res might be negative because the table is empty. Check to
4779 ** see if this is the case.
4780 */
4781 res = sqlite3BtreeEof(pC->uc.pCursor);
4782 }
4783 }
4784seek_not_found:
4785 assert( pOp->p2>0 );
4786 VdbeBranchTaken(res!=0,2);
4787 if( res ){
4788 goto jump_to_p2;
4789 }else if( eqOnly ){
4790 assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
4791 pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */
4792 }
4793 break;
4794}
4795
4796
4797/* Opcode: SeekScan P1 P2 * * P5
4798** Synopsis: Scan-ahead up to P1 rows
4799**
4800** This opcode is a prefix opcode to OP_SeekGE. In other words, this
4801** opcode must be immediately followed by OP_SeekGE. This constraint is
4802** checked by assert() statements.
4803**
4804** This opcode uses the P1 through P4 operands of the subsequent
4805** OP_SeekGE. In the text that follows, the operands of the subsequent
4806** OP_SeekGE opcode are denoted as SeekOP.P1 through SeekOP.P4. Only
4807** the P1, P2 and P5 operands of this opcode are also used, and are called
4808** This.P1, This.P2 and This.P5.
4809**
4810** This opcode helps to optimize IN operators on a multi-column index
4811** where the IN operator is on the later terms of the index by avoiding
4812** unnecessary seeks on the btree, substituting steps to the next row
4813** of the b-tree instead. A correct answer is obtained if this opcode
4814** is omitted or is a no-op.
4815**
4816** The SeekGE.P3 and SeekGE.P4 operands identify an unpacked key which
4817** is the desired entry that we want the cursor SeekGE.P1 to be pointing
4818** to. Call this SeekGE.P3/P4 row the "target".
4819**
4820** If the SeekGE.P1 cursor is not currently pointing to a valid row,
4821** then this opcode is a no-op and control passes through into the OP_SeekGE.
4822**
4823** If the SeekGE.P1 cursor is pointing to a valid row, then that row
4824** might be the target row, or it might be near and slightly before the
4825** target row, or it might be after the target row. If the cursor is
4826** currently before the target row, then this opcode attempts to position
4827** the cursor on or after the target row by invoking sqlite3BtreeStep()
4828** on the cursor between 1 and This.P1 times.
4829**
4830** The This.P5 parameter is a flag that indicates what to do if the
4831** cursor ends up pointing at a valid row that is past the target
4832** row. If This.P5 is false (0) then a jump is made to SeekGE.P2. If
4833** This.P5 is true (non-zero) then a jump is made to This.P2. The P5==0
4834** case occurs when there are no inequality constraints to the right of
4835** the IN constraing. The jump to SeekGE.P2 ends the loop. The P5!=0 case
4836** occurs when there are inequality constraints to the right of the IN
4837** operator. In that case, the This.P2 will point either directly to or
4838** to setup code prior to the OP_IdxGT or OP_IdxGE opcode that checks for
4839** loop terminate.
4840**
4841** Possible outcomes from this opcode:<ol>
4842**
4843** <li> If the cursor is initally not pointed to any valid row, then
4844** fall through into the subsequent OP_SeekGE opcode.
4845**
4846** <li> If the cursor is left pointing to a row that is before the target
4847** row, even after making as many as This.P1 calls to
4848** sqlite3BtreeNext(), then also fall through into OP_SeekGE.
4849**
4850** <li> If the cursor is left pointing at the target row, either because it
4851** was at the target row to begin with or because one or more
4852** sqlite3BtreeNext() calls moved the cursor to the target row,
4853** then jump to This.P2..,
4854**
4855** <li> If the cursor started out before the target row and a call to
4856** to sqlite3BtreeNext() moved the cursor off the end of the index
4857** (indicating that the target row definitely does not exist in the
4858** btree) then jump to SeekGE.P2, ending the loop.
4859**
4860** <li> If the cursor ends up on a valid row that is past the target row
4861** (indicating that the target row does not exist in the btree) then
4862** jump to SeekOP.P2 if This.P5==0 or to This.P2 if This.P5>0.
4863** </ol>
4864*/
4865case OP_SeekScan: {
4866 VdbeCursor *pC;
4867 int res;
4868 int nStep;
4869 UnpackedRecord r;
4870
4871 assert( pOp[1].opcode==OP_SeekGE );
4872
4873 /* If pOp->p5 is clear, then pOp->p2 points to the first instruction past the
4874 ** OP_IdxGT that follows the OP_SeekGE. Otherwise, it points to the first
4875 ** opcode past the OP_SeekGE itself. */
4876 assert( pOp->p2>=(int)(pOp-aOp)+2 );
4877#ifdef SQLITE_DEBUG
4878 if( pOp->p5==0 ){
4879 /* There are no inequality constraints following the IN constraint. */
4880 assert( pOp[1].p1==aOp[pOp->p2-1].p1 );
4881 assert( pOp[1].p2==aOp[pOp->p2-1].p2 );
4882 assert( pOp[1].p3==aOp[pOp->p2-1].p3 );
4883 assert( aOp[pOp->p2-1].opcode==OP_IdxGT
4884 || aOp[pOp->p2-1].opcode==OP_IdxGE );
4885 testcase( aOp[pOp->p2-1].opcode==OP_IdxGE );
4886 }else{
4887 /* There are inequality constraints. */
4888 assert( pOp->p2==(int)(pOp-aOp)+2 );
4889 assert( aOp[pOp->p2-1].opcode==OP_SeekGE );
4890 }
4891#endif
4892
4893 assert( pOp->p1>0 );
4894 pC = p->apCsr[pOp[1].p1];
4895 assert( pC!=0 );
4896 assert( pC->eCurType==CURTYPE_BTREE );
4897 assert( !pC->isTable );
4898 if( !sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) ){
4899#ifdef SQLITE_DEBUG
4900 if( db->flags&SQLITE_VdbeTrace ){
4901 printf("... cursor not valid - fall through\n");
4902 }
4903#endif
4904 break;
4905 }
4906 nStep = pOp->p1;
4907 assert( nStep>=1 );
4908 r.pKeyInfo = pC->pKeyInfo;
4909 r.nField = (u16)pOp[1].p4.i;
4910 r.default_rc = 0;
4911 r.aMem = &aMem[pOp[1].p3];
4912#ifdef SQLITE_DEBUG
4913 {
4914 int i;
4915 for(i=0; i<r.nField; i++){
4916 assert( memIsValid(&r.aMem[i]) );
4917 REGISTER_TRACE(pOp[1].p3+i, &aMem[pOp[1].p3+i]);
4918 }
4919 }
4920#endif
4921 res = 0; /* Not needed. Only used to silence a warning. */
4922 while(1){
4923 rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
4924 if( rc ) goto abort_due_to_error;
4925 if( res>0 && pOp->p5==0 ){
4926 seekscan_search_fail:
4927 /* Jump to SeekGE.P2, ending the loop */
4928#ifdef SQLITE_DEBUG
4929 if( db->flags&SQLITE_VdbeTrace ){
4930 printf("... %d steps and then skip\n", pOp->p1 - nStep);
4931 }
4932#endif
4933 VdbeBranchTaken(1,3);
4934 pOp++;
4935 goto jump_to_p2;
4936 }
4937 if( res>=0 ){
4938 /* Jump to This.P2, bypassing the OP_SeekGE opcode */
4939#ifdef SQLITE_DEBUG
4940 if( db->flags&SQLITE_VdbeTrace ){
4941 printf("... %d steps and then success\n", pOp->p1 - nStep);
4942 }
4943#endif
4944 VdbeBranchTaken(2,3);
4945 goto jump_to_p2;
4946 break;
4947 }
4948 if( nStep<=0 ){
4949#ifdef SQLITE_DEBUG
4950 if( db->flags&SQLITE_VdbeTrace ){
4951 printf("... fall through after %d steps\n", pOp->p1);
4952 }
4953#endif
4954 VdbeBranchTaken(0,3);
4955 break;
4956 }
4957 nStep--;
4958 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
4959 if( rc ){
4960 if( rc==SQLITE_DONE ){
4961 rc = SQLITE_OK;
4962 goto seekscan_search_fail;
4963 }else{
4964 goto abort_due_to_error;
4965 }
4966 }
4967 }
4968
4969 break;
4970}
4971
4972
4973/* Opcode: SeekHit P1 P2 P3 * *
4974** Synopsis: set P2<=seekHit<=P3
4975**
4976** Increase or decrease the seekHit value for cursor P1, if necessary,
4977** so that it is no less than P2 and no greater than P3.
4978**
4979** The seekHit integer represents the maximum of terms in an index for which
4980** there is known to be at least one match. If the seekHit value is smaller
4981** than the total number of equality terms in an index lookup, then the
4982** OP_IfNoHope opcode might run to see if the IN loop can be abandoned
4983** early, thus saving work. This is part of the IN-early-out optimization.
4984**
4985** P1 must be a valid b-tree cursor.
4986*/
4987case OP_SeekHit: {
4988 VdbeCursor *pC;
4989 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4990 pC = p->apCsr[pOp->p1];
4991 assert( pC!=0 );
4992 assert( pOp->p3>=pOp->p2 );
4993 if( pC->seekHit<pOp->p2 ){
4994#ifdef SQLITE_DEBUG
4995 if( db->flags&SQLITE_VdbeTrace ){
4996 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p2);
4997 }
4998#endif
4999 pC->seekHit = pOp->p2;
5000 }else if( pC->seekHit>pOp->p3 ){
5001#ifdef SQLITE_DEBUG
5002 if( db->flags&SQLITE_VdbeTrace ){
5003 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p3);
5004 }
5005#endif
5006 pC->seekHit = pOp->p3;
5007 }
5008 break;
5009}
5010
5011/* Opcode: IfNotOpen P1 P2 * * *
5012** Synopsis: if( !csr[P1] ) goto P2
5013**
5014** If cursor P1 is not open or if P1 is set to a NULL row using the
5015** OP_NullRow opcode, then jump to instruction P2. Otherwise, fall through.
5016*/
5017case OP_IfNotOpen: { /* jump */
5018 VdbeCursor *pCur;
5019
5020 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5021 pCur = p->apCsr[pOp->p1];
5022 VdbeBranchTaken(pCur==0 || pCur->nullRow, 2);
5023 if( pCur==0 || pCur->nullRow ){
5024 goto jump_to_p2_and_check_for_interrupt;
5025 }
5026 break;
5027}
5028
5029/* Opcode: Found P1 P2 P3 P4 *
5030** Synopsis: key=r[P3@P4]
5031**
5032** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
5033** P4>0 then register P3 is the first of P4 registers that form an unpacked
5034** record.
5035**
5036** Cursor P1 is on an index btree. If the record identified by P3 and P4
5037** is a prefix of any entry in P1 then a jump is made to P2 and
5038** P1 is left pointing at the matching entry.
5039**
5040** This operation leaves the cursor in a state where it can be
5041** advanced in the forward direction. The Next instruction will work,
5042** but not the Prev instruction.
5043**
5044** See also: NotFound, NoConflict, NotExists. SeekGe
5045*/
5046/* Opcode: NotFound P1 P2 P3 P4 *
5047** Synopsis: key=r[P3@P4]
5048**
5049** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
5050** P4>0 then register P3 is the first of P4 registers that form an unpacked
5051** record.
5052**
5053** Cursor P1 is on an index btree. If the record identified by P3 and P4
5054** is not the prefix of any entry in P1 then a jump is made to P2. If P1
5055** does contain an entry whose prefix matches the P3/P4 record then control
5056** falls through to the next instruction and P1 is left pointing at the
5057** matching entry.
5058**
5059** This operation leaves the cursor in a state where it cannot be
5060** advanced in either direction. In other words, the Next and Prev
5061** opcodes do not work after this operation.
5062**
5063** See also: Found, NotExists, NoConflict, IfNoHope
5064*/
5065/* Opcode: IfNoHope P1 P2 P3 P4 *
5066** Synopsis: key=r[P3@P4]
5067**
5068** Register P3 is the first of P4 registers that form an unpacked
5069** record. Cursor P1 is an index btree. P2 is a jump destination.
5070** In other words, the operands to this opcode are the same as the
5071** operands to OP_NotFound and OP_IdxGT.
5072**
5073** This opcode is an optimization attempt only. If this opcode always
5074** falls through, the correct answer is still obtained, but extra works
5075** is performed.
5076**
5077** A value of N in the seekHit flag of cursor P1 means that there exists
5078** a key P3:N that will match some record in the index. We want to know
5079** if it is possible for a record P3:P4 to match some record in the
5080** index. If it is not possible, we can skips some work. So if seekHit
5081** is less than P4, attempt to find out if a match is possible by running
5082** OP_NotFound.
5083**
5084** This opcode is used in IN clause processing for a multi-column key.
5085** If an IN clause is attached to an element of the key other than the
5086** left-most element, and if there are no matches on the most recent
5087** seek over the whole key, then it might be that one of the key element
5088** to the left is prohibiting a match, and hence there is "no hope" of
5089** any match regardless of how many IN clause elements are checked.
5090** In such a case, we abandon the IN clause search early, using this
5091** opcode. The opcode name comes from the fact that the
5092** jump is taken if there is "no hope" of achieving a match.
5093**
5094** See also: NotFound, SeekHit
5095*/
5096/* Opcode: NoConflict P1 P2 P3 P4 *
5097** Synopsis: key=r[P3@P4]
5098**
5099** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
5100** P4>0 then register P3 is the first of P4 registers that form an unpacked
5101** record.
5102**
5103** Cursor P1 is on an index btree. If the record identified by P3 and P4
5104** contains any NULL value, jump immediately to P2. If all terms of the
5105** record are not-NULL then a check is done to determine if any row in the
5106** P1 index btree has a matching key prefix. If there are no matches, jump
5107** immediately to P2. If there is a match, fall through and leave the P1
5108** cursor pointing to the matching row.
5109**
5110** This opcode is similar to OP_NotFound with the exceptions that the
5111** branch is always taken if any part of the search key input is NULL.
5112**
5113** This operation leaves the cursor in a state where it cannot be
5114** advanced in either direction. In other words, the Next and Prev
5115** opcodes do not work after this operation.
5116**
5117** See also: NotFound, Found, NotExists
5118*/
5119case OP_IfNoHope: { /* jump, in3 */
5120 VdbeCursor *pC;
5121 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5122 pC = p->apCsr[pOp->p1];
5123 assert( pC!=0 );
5124#ifdef SQLITE_DEBUG
5125 if( db->flags&SQLITE_VdbeTrace ){
5126 printf("seekHit is %d\n", pC->seekHit);
5127 }
5128#endif
5129 if( pC->seekHit>=pOp->p4.i ) break;
5130 /* Fall through into OP_NotFound */
5131 /* no break */ deliberate_fall_through
5132}
5133case OP_NoConflict: /* jump, in3 */
5134case OP_NotFound: /* jump, in3 */
5135case OP_Found: { /* jump, in3 */
5136 int alreadyExists;
5137 int ii;
5138 VdbeCursor *pC;
5139 UnpackedRecord *pIdxKey;
5140 UnpackedRecord r;
5141
5142#ifdef SQLITE_TEST
5143 if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++;
5144#endif
5145
5146 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5147 assert( pOp->p4type==P4_INT32 );
5148 pC = p->apCsr[pOp->p1];
5149 assert( pC!=0 );
5150#ifdef SQLITE_DEBUG
5151 pC->seekOp = pOp->opcode;
5152#endif
5153 r.aMem = &aMem[pOp->p3];
5154 assert( pC->eCurType==CURTYPE_BTREE );
5155 assert( pC->uc.pCursor!=0 );
5156 assert( pC->isTable==0 );
5157 r.nField = (u16)pOp->p4.i;
5158 if( r.nField>0 ){
5159 /* Key values in an array of registers */
5160 r.pKeyInfo = pC->pKeyInfo;
5161 r.default_rc = 0;
5162#ifdef SQLITE_DEBUG
5163 for(ii=0; ii<r.nField; ii++){
5164 assert( memIsValid(&r.aMem[ii]) );
5165 assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 );
5166 if( ii ) REGISTER_TRACE(pOp->p3+ii, &r.aMem[ii]);
5167 }
5168#endif
5169 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &pC->seekResult);
5170 }else{
5171 /* Composite key generated by OP_MakeRecord */
5172 assert( r.aMem->flags & MEM_Blob );
5173 assert( pOp->opcode!=OP_NoConflict );
5174 rc = ExpandBlob(r.aMem);
5175 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
5176 if( rc ) goto no_mem;
5177 pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
5178 if( pIdxKey==0 ) goto no_mem;
5179 sqlite3VdbeRecordUnpack(pC->pKeyInfo, r.aMem->n, r.aMem->z, pIdxKey);
5180 pIdxKey->default_rc = 0;
5181 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &pC->seekResult);
5182 sqlite3DbFreeNN(db, pIdxKey);
5183 }
5184 if( rc!=SQLITE_OK ){
5185 goto abort_due_to_error;
5186 }
5187 alreadyExists = (pC->seekResult==0);
5188 pC->nullRow = 1-alreadyExists;
5189 pC->deferredMoveto = 0;
5190 pC->cacheStatus = CACHE_STALE;
5191 if( pOp->opcode==OP_Found ){
5192 VdbeBranchTaken(alreadyExists!=0,2);
5193 if( alreadyExists ) goto jump_to_p2;
5194 }else{
5195 if( !alreadyExists ){
5196 VdbeBranchTaken(1,2);
5197 goto jump_to_p2;
5198 }
5199 if( pOp->opcode==OP_NoConflict ){
5200 /* For the OP_NoConflict opcode, take the jump if any of the
5201 ** input fields are NULL, since any key with a NULL will not
5202 ** conflict */
5203 for(ii=0; ii<r.nField; ii++){
5204 if( r.aMem[ii].flags & MEM_Null ){
5205 VdbeBranchTaken(1,2);
5206 goto jump_to_p2;
5207 }
5208 }
5209 }
5210 VdbeBranchTaken(0,2);
5211 if( pOp->opcode==OP_IfNoHope ){
5212 pC->seekHit = pOp->p4.i;
5213 }
5214 }
5215 break;
5216}
5217
5218/* Opcode: SeekRowid P1 P2 P3 * *
5219** Synopsis: intkey=r[P3]
5220**
5221** P1 is the index of a cursor open on an SQL table btree (with integer
5222** keys). If register P3 does not contain an integer or if P1 does not
5223** contain a record with rowid P3 then jump immediately to P2.
5224** Or, if P2 is 0, raise an SQLITE_CORRUPT error. If P1 does contain
5225** a record with rowid P3 then
5226** leave the cursor pointing at that record and fall through to the next
5227** instruction.
5228**
5229** The OP_NotExists opcode performs the same operation, but with OP_NotExists
5230** the P3 register must be guaranteed to contain an integer value. With this
5231** opcode, register P3 might not contain an integer.
5232**
5233** The OP_NotFound opcode performs the same operation on index btrees
5234** (with arbitrary multi-value keys).
5235**
5236** This opcode leaves the cursor in a state where it cannot be advanced
5237** in either direction. In other words, the Next and Prev opcodes will
5238** not work following this opcode.
5239**
5240** See also: Found, NotFound, NoConflict, SeekRowid
5241*/
5242/* Opcode: NotExists P1 P2 P3 * *
5243** Synopsis: intkey=r[P3]
5244**
5245** P1 is the index of a cursor open on an SQL table btree (with integer
5246** keys). P3 is an integer rowid. If P1 does not contain a record with
5247** rowid P3 then jump immediately to P2. Or, if P2 is 0, raise an
5248** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then
5249** leave the cursor pointing at that record and fall through to the next
5250** instruction.
5251**
5252** The OP_SeekRowid opcode performs the same operation but also allows the
5253** P3 register to contain a non-integer value, in which case the jump is
5254** always taken. This opcode requires that P3 always contain an integer.
5255**
5256** The OP_NotFound opcode performs the same operation on index btrees
5257** (with arbitrary multi-value keys).
5258**
5259** This opcode leaves the cursor in a state where it cannot be advanced
5260** in either direction. In other words, the Next and Prev opcodes will
5261** not work following this opcode.
5262**
5263** See also: Found, NotFound, NoConflict, SeekRowid
5264*/
5265case OP_SeekRowid: { /* jump, in3 */
5266 VdbeCursor *pC;
5267 BtCursor *pCrsr;
5268 int res;
5269 u64 iKey;
5270
5271 pIn3 = &aMem[pOp->p3];
5272 testcase( pIn3->flags & MEM_Int );
5273 testcase( pIn3->flags & MEM_IntReal );
5274 testcase( pIn3->flags & MEM_Real );
5275 testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str );
5276 if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){
5277 /* If pIn3->u.i does not contain an integer, compute iKey as the
5278 ** integer value of pIn3. Jump to P2 if pIn3 cannot be converted
5279 ** into an integer without loss of information. Take care to avoid
5280 ** changing the datatype of pIn3, however, as it is used by other
5281 ** parts of the prepared statement. */
5282 Mem x = pIn3[0];
5283 applyAffinity(&x, SQLITE_AFF_NUMERIC, encoding);
5284 if( (x.flags & MEM_Int)==0 ) goto jump_to_p2;
5285 iKey = x.u.i;
5286 goto notExistsWithKey;
5287 }
5288 /* Fall through into OP_NotExists */
5289 /* no break */ deliberate_fall_through
5290case OP_NotExists: /* jump, in3 */
5291 pIn3 = &aMem[pOp->p3];
5292 assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );
5293 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5294 iKey = pIn3->u.i;
5295notExistsWithKey:
5296 pC = p->apCsr[pOp->p1];
5297 assert( pC!=0 );
5298#ifdef SQLITE_DEBUG
5299 if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid;
5300#endif
5301 assert( pC->isTable );
5302 assert( pC->eCurType==CURTYPE_BTREE );
5303 pCrsr = pC->uc.pCursor;
5304 assert( pCrsr!=0 );
5305 res = 0;
5306 rc = sqlite3BtreeTableMoveto(pCrsr, iKey, 0, &res);
5307 assert( rc==SQLITE_OK || res==0 );
5308 pC->movetoTarget = iKey; /* Used by OP_Delete */
5309 pC->nullRow = 0;
5310 pC->cacheStatus = CACHE_STALE;
5311 pC->deferredMoveto = 0;
5312 VdbeBranchTaken(res!=0,2);
5313 pC->seekResult = res;
5314 if( res!=0 ){
5315 assert( rc==SQLITE_OK );
5316 if( pOp->p2==0 ){
5317 rc = SQLITE_CORRUPT_BKPT;
5318 }else{
5319 goto jump_to_p2;
5320 }
5321 }
5322 if( rc ) goto abort_due_to_error;
5323 break;
5324}
5325
5326/* Opcode: Sequence P1 P2 * * *
5327** Synopsis: r[P2]=cursor[P1].ctr++
5328**
5329** Find the next available sequence number for cursor P1.
5330** Write the sequence number into register P2.
5331** The sequence number on the cursor is incremented after this
5332** instruction.
5333*/
5334case OP_Sequence: { /* out2 */
5335 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5336 assert( p->apCsr[pOp->p1]!=0 );
5337 assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB );
5338 pOut = out2Prerelease(p, pOp);
5339 pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
5340 break;
5341}
5342
5343
5344/* Opcode: NewRowid P1 P2 P3 * *
5345** Synopsis: r[P2]=rowid
5346**
5347** Get a new integer record number (a.k.a "rowid") used as the key to a table.
5348** The record number is not previously used as a key in the database
5349** table that cursor P1 points to. The new record number is written
5350** written to register P2.
5351**
5352** If P3>0 then P3 is a register in the root frame of this VDBE that holds
5353** the largest previously generated record number. No new record numbers are
5354** allowed to be less than this value. When this value reaches its maximum,
5355** an SQLITE_FULL error is generated. The P3 register is updated with the '
5356** generated record number. This P3 mechanism is used to help implement the
5357** AUTOINCREMENT feature.
5358*/
5359case OP_NewRowid: { /* out2 */
5360 i64 v; /* The new rowid */
5361 VdbeCursor *pC; /* Cursor of table to get the new rowid */
5362 int res; /* Result of an sqlite3BtreeLast() */
5363 int cnt; /* Counter to limit the number of searches */
5364#ifndef SQLITE_OMIT_AUTOINCREMENT
5365 Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
5366 VdbeFrame *pFrame; /* Root frame of VDBE */
5367#endif
5368
5369 v = 0;
5370 res = 0;
5371 pOut = out2Prerelease(p, pOp);
5372 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5373 pC = p->apCsr[pOp->p1];
5374 assert( pC!=0 );
5375 assert( pC->isTable );
5376 assert( pC->eCurType==CURTYPE_BTREE );
5377 assert( pC->uc.pCursor!=0 );
5378 {
5379 /* The next rowid or record number (different terms for the same
5380 ** thing) is obtained in a two-step algorithm.
5381 **
5382 ** First we attempt to find the largest existing rowid and add one
5383 ** to that. But if the largest existing rowid is already the maximum
5384 ** positive integer, we have to fall through to the second
5385 ** probabilistic algorithm
5386 **
5387 ** The second algorithm is to select a rowid at random and see if
5388 ** it already exists in the table. If it does not exist, we have
5389 ** succeeded. If the random rowid does exist, we select a new one
5390 ** and try again, up to 100 times.
5391 */
5392 assert( pC->isTable );
5393
5394#ifdef SQLITE_32BIT_ROWID
5395# define MAX_ROWID 0x7fffffff
5396#else
5397 /* Some compilers complain about constants of the form 0x7fffffffffffffff.
5398 ** Others complain about 0x7ffffffffffffffffLL. The following macro seems
5399 ** to provide the constant while making all compilers happy.
5400 */
5401# define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
5402#endif
5403
5404 if( !pC->useRandomRowid ){
5405 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
5406 if( rc!=SQLITE_OK ){
5407 goto abort_due_to_error;
5408 }
5409 if( res ){
5410 v = 1; /* IMP: R-61914-48074 */
5411 }else{
5412 assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
5413 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
5414 if( v>=MAX_ROWID ){
5415 pC->useRandomRowid = 1;
5416 }else{
5417 v++; /* IMP: R-29538-34987 */
5418 }
5419 }
5420 }
5421
5422#ifndef SQLITE_OMIT_AUTOINCREMENT
5423 if( pOp->p3 ){
5424 /* Assert that P3 is a valid memory cell. */
5425 assert( pOp->p3>0 );
5426 if( p->pFrame ){
5427 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
5428 /* Assert that P3 is a valid memory cell. */
5429 assert( pOp->p3<=pFrame->nMem );
5430 pMem = &pFrame->aMem[pOp->p3];
5431 }else{
5432 /* Assert that P3 is a valid memory cell. */
5433 assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
5434 pMem = &aMem[pOp->p3];
5435 memAboutToChange(p, pMem);
5436 }
5437 assert( memIsValid(pMem) );
5438
5439 REGISTER_TRACE(pOp->p3, pMem);
5440 sqlite3VdbeMemIntegerify(pMem);
5441 assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
5442 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
5443 rc = SQLITE_FULL; /* IMP: R-17817-00630 */
5444 goto abort_due_to_error;
5445 }
5446 if( v<pMem->u.i+1 ){
5447 v = pMem->u.i + 1;
5448 }
5449 pMem->u.i = v;
5450 }
5451#endif
5452 if( pC->useRandomRowid ){
5453 /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
5454 ** largest possible integer (9223372036854775807) then the database
5455 ** engine starts picking positive candidate ROWIDs at random until
5456 ** it finds one that is not previously used. */
5457 assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
5458 ** an AUTOINCREMENT table. */
5459 cnt = 0;
5460 do{
5461 sqlite3_randomness(sizeof(v), &v);
5462 v &= (MAX_ROWID>>1); v++; /* Ensure that v is greater than zero */
5463 }while( ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v,
5464 0, &res))==SQLITE_OK)
5465 && (res==0)
5466 && (++cnt<100));
5467 if( rc ) goto abort_due_to_error;
5468 if( res==0 ){
5469 rc = SQLITE_FULL; /* IMP: R-38219-53002 */
5470 goto abort_due_to_error;
5471 }
5472 assert( v>0 ); /* EV: R-40812-03570 */
5473 }
5474 pC->deferredMoveto = 0;
5475 pC->cacheStatus = CACHE_STALE;
5476 }
5477 pOut->u.i = v;
5478 break;
5479}
5480
5481/* Opcode: Insert P1 P2 P3 P4 P5
5482** Synopsis: intkey=r[P3] data=r[P2]
5483**
5484** Write an entry into the table of cursor P1. A new entry is
5485** created if it doesn't already exist or the data for an existing
5486** entry is overwritten. The data is the value MEM_Blob stored in register
5487** number P2. The key is stored in register P3. The key must
5488** be a MEM_Int.
5489**
5490** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
5491** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set,
5492** then rowid is stored for subsequent return by the
5493** sqlite3_last_insert_rowid() function (otherwise it is unmodified).
5494**
5495** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
5496** run faster by avoiding an unnecessary seek on cursor P1. However,
5497** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
5498** seeks on the cursor or if the most recent seek used a key equal to P3.
5499**
5500** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
5501** UPDATE operation. Otherwise (if the flag is clear) then this opcode
5502** is part of an INSERT operation. The difference is only important to
5503** the update hook.
5504**
5505** Parameter P4 may point to a Table structure, or may be NULL. If it is
5506** not NULL, then the update-hook (sqlite3.xUpdateCallback) is invoked
5507** following a successful insert.
5508**
5509** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
5510** allocated, then ownership of P2 is transferred to the pseudo-cursor
5511** and register P2 becomes ephemeral. If the cursor is changed, the
5512** value of register P2 will then change. Make sure this does not
5513** cause any problems.)
5514**
5515** This instruction only works on tables. The equivalent instruction
5516** for indices is OP_IdxInsert.
5517*/
5518case OP_Insert: {
5519 Mem *pData; /* MEM cell holding data for the record to be inserted */
5520 Mem *pKey; /* MEM cell holding key for the record */
5521 VdbeCursor *pC; /* Cursor to table into which insert is written */
5522 int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */
5523 const char *zDb; /* database name - used by the update hook */
5524 Table *pTab; /* Table structure - used by update and pre-update hooks */
5525 BtreePayload x; /* Payload to be inserted */
5526
5527 pData = &aMem[pOp->p2];
5528 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5529 assert( memIsValid(pData) );
5530 pC = p->apCsr[pOp->p1];
5531 assert( pC!=0 );
5532 assert( pC->eCurType==CURTYPE_BTREE );
5533 assert( pC->deferredMoveto==0 );
5534 assert( pC->uc.pCursor!=0 );
5535 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
5536 assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC );
5537 REGISTER_TRACE(pOp->p2, pData);
5538 sqlite3VdbeIncrWriteCounter(p, pC);
5539
5540 pKey = &aMem[pOp->p3];
5541 assert( pKey->flags & MEM_Int );
5542 assert( memIsValid(pKey) );
5543 REGISTER_TRACE(pOp->p3, pKey);
5544 x.nKey = pKey->u.i;
5545
5546 if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
5547 assert( pC->iDb>=0 );
5548 zDb = db->aDb[pC->iDb].zDbSName;
5549 pTab = pOp->p4.pTab;
5550 assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
5551 }else{
5552 pTab = 0;
5553 zDb = 0;
5554 }
5555
5556#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
5557 /* Invoke the pre-update hook, if any */
5558 if( pTab ){
5559 if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){
5560 sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1);
5561 }
5562 if( db->xUpdateCallback==0 || pTab->aCol==0 ){
5563 /* Prevent post-update hook from running in cases when it should not */
5564 pTab = 0;
5565 }
5566 }
5567 if( pOp->p5 & OPFLAG_ISNOOP ) break;
5568#endif
5569
5570 if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
5571 if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey;
5572 assert( (pData->flags & (MEM_Blob|MEM_Str))!=0 || pData->n==0 );
5573 x.pData = pData->z;
5574 x.nData = pData->n;
5575 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
5576 if( pData->flags & MEM_Zero ){
5577 x.nZero = pData->u.nZero;
5578 }else{
5579 x.nZero = 0;
5580 }
5581 x.pKey = 0;
5582 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
5583 (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
5584 seekResult
5585 );
5586 pC->deferredMoveto = 0;
5587 pC->cacheStatus = CACHE_STALE;
5588
5589 /* Invoke the update-hook if required. */
5590 if( rc ) goto abort_due_to_error;
5591 if( pTab ){
5592 assert( db->xUpdateCallback!=0 );
5593 assert( pTab->aCol!=0 );
5594 db->xUpdateCallback(db->pUpdateArg,
5595 (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT,
5596 zDb, pTab->zName, x.nKey);
5597 }
5598 break;
5599}
5600
5601/* Opcode: RowCell P1 P2 P3 * *
5602**
5603** P1 and P2 are both open cursors. Both must be opened on the same type
5604** of table - intkey or index. This opcode is used as part of copying
5605** the current row from P2 into P1. If the cursors are opened on intkey
5606** tables, register P3 contains the rowid to use with the new record in
5607** P1. If they are opened on index tables, P3 is not used.
5608**
5609** This opcode must be followed by either an Insert or InsertIdx opcode
5610** with the OPFLAG_PREFORMAT flag set to complete the insert operation.
5611*/
5612case OP_RowCell: {
5613 VdbeCursor *pDest; /* Cursor to write to */
5614 VdbeCursor *pSrc; /* Cursor to read from */
5615 i64 iKey; /* Rowid value to insert with */
5616 assert( pOp[1].opcode==OP_Insert || pOp[1].opcode==OP_IdxInsert );
5617 assert( pOp[1].opcode==OP_Insert || pOp->p3==0 );
5618 assert( pOp[1].opcode==OP_IdxInsert || pOp->p3>0 );
5619 assert( pOp[1].p5 & OPFLAG_PREFORMAT );
5620 pDest = p->apCsr[pOp->p1];
5621 pSrc = p->apCsr[pOp->p2];
5622 iKey = pOp->p3 ? aMem[pOp->p3].u.i : 0;
5623 rc = sqlite3BtreeTransferRow(pDest->uc.pCursor, pSrc->uc.pCursor, iKey);
5624 if( rc!=SQLITE_OK ) goto abort_due_to_error;
5625 break;
5626};
5627
5628/* Opcode: Delete P1 P2 P3 P4 P5
5629**
5630** Delete the record at which the P1 cursor is currently pointing.
5631**
5632** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then
5633** the cursor will be left pointing at either the next or the previous
5634** record in the table. If it is left pointing at the next record, then
5635** the next Next instruction will be a no-op. As a result, in this case
5636** it is ok to delete a record from within a Next loop. If
5637** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be
5638** left in an undefined state.
5639**
5640** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this
5641** delete one of several associated with deleting a table row and all its
5642** associated index entries. Exactly one of those deletes is the "primary"
5643** delete. The others are all on OPFLAG_FORDELETE cursors or else are
5644** marked with the AUXDELETE flag.
5645**
5646** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row
5647** change count is incremented (otherwise not).
5648**
5649** P1 must not be pseudo-table. It has to be a real table with
5650** multiple rows.
5651**
5652** If P4 is not NULL then it points to a Table object. In this case either
5653** the update or pre-update hook, or both, may be invoked. The P1 cursor must
5654** have been positioned using OP_NotFound prior to invoking this opcode in
5655** this case. Specifically, if one is configured, the pre-update hook is
5656** invoked if P4 is not NULL. The update-hook is invoked if one is configured,
5657** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2.
5658**
5659** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address
5660** of the memory cell that contains the value that the rowid of the row will
5661** be set to by the update.
5662*/
5663case OP_Delete: {
5664 VdbeCursor *pC;
5665 const char *zDb;
5666 Table *pTab;
5667 int opflags;
5668
5669 opflags = pOp->p2;
5670 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5671 pC = p->apCsr[pOp->p1];
5672 assert( pC!=0 );
5673 assert( pC->eCurType==CURTYPE_BTREE );
5674 assert( pC->uc.pCursor!=0 );
5675 assert( pC->deferredMoveto==0 );
5676 sqlite3VdbeIncrWriteCounter(p, pC);
5677
5678#ifdef SQLITE_DEBUG
5679 if( pOp->p4type==P4_TABLE
5680 && HasRowid(pOp->p4.pTab)
5681 && pOp->p5==0
5682 && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor)
5683 ){
5684 /* If p5 is zero, the seek operation that positioned the cursor prior to
5685 ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
5686 ** the row that is being deleted */
5687 i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
5688 assert( CORRUPT_DB || pC->movetoTarget==iKey );
5689 }
5690#endif
5691
5692 /* If the update-hook or pre-update-hook will be invoked, set zDb to
5693 ** the name of the db to pass as to it. Also set local pTab to a copy
5694 ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was
5695 ** last moved with OP_Next or OP_Prev, not Seek or NotFound, set
5696 ** VdbeCursor.movetoTarget to the current rowid. */
5697 if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
5698 assert( pC->iDb>=0 );
5699 assert( pOp->p4.pTab!=0 );
5700 zDb = db->aDb[pC->iDb].zDbSName;
5701 pTab = pOp->p4.pTab;
5702 if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
5703 pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
5704 }
5705 }else{
5706 zDb = 0;
5707 pTab = 0;
5708 }
5709
5710#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
5711 /* Invoke the pre-update-hook if required. */
5712 assert( db->xPreUpdateCallback==0 || pTab==pOp->p4.pTab );
5713 if( db->xPreUpdateCallback && pTab ){
5714 assert( !(opflags & OPFLAG_ISUPDATE)
5715 || HasRowid(pTab)==0
5716 || (aMem[pOp->p3].flags & MEM_Int)
5717 );
5718 sqlite3VdbePreUpdateHook(p, pC,
5719 (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE,
5720 zDb, pTab, pC->movetoTarget,
5721 pOp->p3, -1
5722 );
5723 }
5724 if( opflags & OPFLAG_ISNOOP ) break;
5725#endif
5726
5727 /* Only flags that can be set are SAVEPOISTION and AUXDELETE */
5728 assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 );
5729 assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION );
5730 assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE );
5731
5732#ifdef SQLITE_DEBUG
5733 if( p->pFrame==0 ){
5734 if( pC->isEphemeral==0
5735 && (pOp->p5 & OPFLAG_AUXDELETE)==0
5736 && (pC->wrFlag & OPFLAG_FORDELETE)==0
5737 ){
5738 nExtraDelete++;
5739 }
5740 if( pOp->p2 & OPFLAG_NCHANGE ){
5741 nExtraDelete--;
5742 }
5743 }
5744#endif
5745
5746 rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
5747 pC->cacheStatus = CACHE_STALE;
5748 pC->seekResult = 0;
5749 if( rc ) goto abort_due_to_error;
5750
5751 /* Invoke the update-hook if required. */
5752 if( opflags & OPFLAG_NCHANGE ){
5753 p->nChange++;
5754 if( db->xUpdateCallback && ALWAYS(pTab!=0) && HasRowid(pTab) ){
5755 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
5756 pC->movetoTarget);
5757 assert( pC->iDb>=0 );
5758 }
5759 }
5760
5761 break;
5762}
5763/* Opcode: ResetCount * * * * *
5764**
5765** The value of the change counter is copied to the database handle
5766** change counter (returned by subsequent calls to sqlite3_changes()).
5767** Then the VMs internal change counter resets to 0.
5768** This is used by trigger programs.
5769*/
5770case OP_ResetCount: {
5771 sqlite3VdbeSetChanges(db, p->nChange);
5772 p->nChange = 0;
5773 break;
5774}
5775
5776/* Opcode: SorterCompare P1 P2 P3 P4
5777** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2
5778**
5779** P1 is a sorter cursor. This instruction compares a prefix of the
5780** record blob in register P3 against a prefix of the entry that
5781** the sorter cursor currently points to. Only the first P4 fields
5782** of r[P3] and the sorter record are compared.
5783**
5784** If either P3 or the sorter contains a NULL in one of their significant
5785** fields (not counting the P4 fields at the end which are ignored) then
5786** the comparison is assumed to be equal.
5787**
5788** Fall through to next instruction if the two records compare equal to
5789** each other. Jump to P2 if they are different.
5790*/
5791case OP_SorterCompare: {
5792 VdbeCursor *pC;
5793 int res;
5794 int nKeyCol;
5795
5796 pC = p->apCsr[pOp->p1];
5797 assert( isSorter(pC) );
5798 assert( pOp->p4type==P4_INT32 );
5799 pIn3 = &aMem[pOp->p3];
5800 nKeyCol = pOp->p4.i;
5801 res = 0;
5802 rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
5803 VdbeBranchTaken(res!=0,2);
5804 if( rc ) goto abort_due_to_error;
5805 if( res ) goto jump_to_p2;
5806 break;
5807};
5808
5809/* Opcode: SorterData P1 P2 P3 * *
5810** Synopsis: r[P2]=data
5811**
5812** Write into register P2 the current sorter data for sorter cursor P1.
5813** Then clear the column header cache on cursor P3.
5814**
5815** This opcode is normally use to move a record out of the sorter and into
5816** a register that is the source for a pseudo-table cursor created using
5817** OpenPseudo. That pseudo-table cursor is the one that is identified by
5818** parameter P3. Clearing the P3 column cache as part of this opcode saves
5819** us from having to issue a separate NullRow instruction to clear that cache.
5820*/
5821case OP_SorterData: {
5822 VdbeCursor *pC;
5823
5824 pOut = &aMem[pOp->p2];
5825 pC = p->apCsr[pOp->p1];
5826 assert( isSorter(pC) );
5827 rc = sqlite3VdbeSorterRowkey(pC, pOut);
5828 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
5829 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5830 if( rc ) goto abort_due_to_error;
5831 p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE;
5832 break;
5833}
5834
5835/* Opcode: RowData P1 P2 P3 * *
5836** Synopsis: r[P2]=data
5837**
5838** Write into register P2 the complete row content for the row at
5839** which cursor P1 is currently pointing.
5840** There is no interpretation of the data.
5841** It is just copied onto the P2 register exactly as
5842** it is found in the database file.
5843**
5844** If cursor P1 is an index, then the content is the key of the row.
5845** If cursor P2 is a table, then the content extracted is the data.
5846**
5847** If the P1 cursor must be pointing to a valid row (not a NULL row)
5848** of a real table, not a pseudo-table.
5849**
5850** If P3!=0 then this opcode is allowed to make an ephemeral pointer
5851** into the database page. That means that the content of the output
5852** register will be invalidated as soon as the cursor moves - including
5853** moves caused by other cursors that "save" the current cursors
5854** position in order that they can write to the same table. If P3==0
5855** then a copy of the data is made into memory. P3!=0 is faster, but
5856** P3==0 is safer.
5857**
5858** If P3!=0 then the content of the P2 register is unsuitable for use
5859** in OP_Result and any OP_Result will invalidate the P2 register content.
5860** The P2 register content is invalidated by opcodes like OP_Function or
5861** by any use of another cursor pointing to the same table.
5862*/
5863case OP_RowData: {
5864 VdbeCursor *pC;
5865 BtCursor *pCrsr;
5866 u32 n;
5867
5868 pOut = out2Prerelease(p, pOp);
5869
5870 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5871 pC = p->apCsr[pOp->p1];
5872 assert( pC!=0 );
5873 assert( pC->eCurType==CURTYPE_BTREE );
5874 assert( isSorter(pC)==0 );
5875 assert( pC->nullRow==0 );
5876 assert( pC->uc.pCursor!=0 );
5877 pCrsr = pC->uc.pCursor;
5878
5879 /* The OP_RowData opcodes always follow OP_NotExists or
5880 ** OP_SeekRowid or OP_Rewind/Op_Next with no intervening instructions
5881 ** that might invalidate the cursor.
5882 ** If this where not the case, on of the following assert()s
5883 ** would fail. Should this ever change (because of changes in the code
5884 ** generator) then the fix would be to insert a call to
5885 ** sqlite3VdbeCursorMoveto().
5886 */
5887 assert( pC->deferredMoveto==0 );
5888 assert( sqlite3BtreeCursorIsValid(pCrsr) );
5889
5890 n = sqlite3BtreePayloadSize(pCrsr);
5891 if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
5892 goto too_big;
5893 }
5894 testcase( n==0 );
5895 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCrsr, n, pOut);
5896 if( rc ) goto abort_due_to_error;
5897 if( !pOp->p3 ) Deephemeralize(pOut);
5898 UPDATE_MAX_BLOBSIZE(pOut);
5899 REGISTER_TRACE(pOp->p2, pOut);
5900 break;
5901}
5902
5903/* Opcode: Rowid P1 P2 * * *
5904** Synopsis: r[P2]=PX rowid of P1
5905**
5906** Store in register P2 an integer which is the key of the table entry that
5907** P1 is currently point to.
5908**
5909** P1 can be either an ordinary table or a virtual table. There used to
5910** be a separate OP_VRowid opcode for use with virtual tables, but this
5911** one opcode now works for both table types.
5912*/
5913case OP_Rowid: { /* out2 */
5914 VdbeCursor *pC;
5915 i64 v;
5916 sqlite3_vtab *pVtab;
5917 const sqlite3_module *pModule;
5918
5919 pOut = out2Prerelease(p, pOp);
5920 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5921 pC = p->apCsr[pOp->p1];
5922 assert( pC!=0 );
5923 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
5924 if( pC->nullRow ){
5925 pOut->flags = MEM_Null;
5926 break;
5927 }else if( pC->deferredMoveto ){
5928 v = pC->movetoTarget;
5929#ifndef SQLITE_OMIT_VIRTUALTABLE
5930 }else if( pC->eCurType==CURTYPE_VTAB ){
5931 assert( pC->uc.pVCur!=0 );
5932 pVtab = pC->uc.pVCur->pVtab;
5933 pModule = pVtab->pModule;
5934 assert( pModule->xRowid );
5935 rc = pModule->xRowid(pC->uc.pVCur, &v);
5936 sqlite3VtabImportErrmsg(p, pVtab);
5937 if( rc ) goto abort_due_to_error;
5938#endif /* SQLITE_OMIT_VIRTUALTABLE */
5939 }else{
5940 assert( pC->eCurType==CURTYPE_BTREE );
5941 assert( pC->uc.pCursor!=0 );
5942 rc = sqlite3VdbeCursorRestore(pC);
5943 if( rc ) goto abort_due_to_error;
5944 if( pC->nullRow ){
5945 pOut->flags = MEM_Null;
5946 break;
5947 }
5948 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
5949 }
5950 pOut->u.i = v;
5951 break;
5952}
5953
5954/* Opcode: NullRow P1 * * * *
5955**
5956** Move the cursor P1 to a null row. Any OP_Column operations
5957** that occur while the cursor is on the null row will always
5958** write a NULL.
5959**
5960** If cursor P1 is not previously opened, open it now to a special
5961** pseudo-cursor that always returns NULL for every column.
5962*/
5963case OP_NullRow: {
5964 VdbeCursor *pC;
5965
5966 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
5967 pC = p->apCsr[pOp->p1];
5968 if( pC==0 ){
5969 /* If the cursor is not already open, create a special kind of
5970 ** pseudo-cursor that always gives null rows. */
5971 pC = allocateCursor(p, pOp->p1, 1, CURTYPE_PSEUDO);
5972 if( pC==0 ) goto no_mem;
5973 pC->seekResult = 0;
5974 pC->isTable = 1;
5975 pC->noReuse = 1;
5976 pC->uc.pCursor = sqlite3BtreeFakeValidCursor();
5977 }
5978 pC->nullRow = 1;
5979 pC->cacheStatus = CACHE_STALE;
5980 if( pC->eCurType==CURTYPE_BTREE ){
5981 assert( pC->uc.pCursor!=0 );
5982 sqlite3BtreeClearCursor(pC->uc.pCursor);
5983 }
5984#ifdef SQLITE_DEBUG
5985 if( pC->seekOp==0 ) pC->seekOp = OP_NullRow;
5986#endif
5987 break;
5988}
5989
5990/* Opcode: SeekEnd P1 * * * *
5991**
5992** Position cursor P1 at the end of the btree for the purpose of
5993** appending a new entry onto the btree.
5994**
5995** It is assumed that the cursor is used only for appending and so
5996** if the cursor is valid, then the cursor must already be pointing
5997** at the end of the btree and so no changes are made to
5998** the cursor.
5999*/
6000/* Opcode: Last P1 P2 * * *
6001**
6002** The next use of the Rowid or Column or Prev instruction for P1
6003** will refer to the last entry in the database table or index.
6004** If the table or index is empty and P2>0, then jump immediately to P2.
6005** If P2 is 0 or if the table or index is not empty, fall through
6006** to the following instruction.
6007**
6008** This opcode leaves the cursor configured to move in reverse order,
6009** from the end toward the beginning. In other words, the cursor is
6010** configured to use Prev, not Next.
6011*/
6012case OP_SeekEnd:
6013case OP_Last: { /* jump */
6014 VdbeCursor *pC;
6015 BtCursor *pCrsr;
6016 int res;
6017
6018 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6019 pC = p->apCsr[pOp->p1];
6020 assert( pC!=0 );
6021 assert( pC->eCurType==CURTYPE_BTREE );
6022 pCrsr = pC->uc.pCursor;
6023 res = 0;
6024 assert( pCrsr!=0 );
6025#ifdef SQLITE_DEBUG
6026 pC->seekOp = pOp->opcode;
6027#endif
6028 if( pOp->opcode==OP_SeekEnd ){
6029 assert( pOp->p2==0 );
6030 pC->seekResult = -1;
6031 if( sqlite3BtreeCursorIsValidNN(pCrsr) ){
6032 break;
6033 }
6034 }
6035 rc = sqlite3BtreeLast(pCrsr, &res);
6036 pC->nullRow = (u8)res;
6037 pC->deferredMoveto = 0;
6038 pC->cacheStatus = CACHE_STALE;
6039 if( rc ) goto abort_due_to_error;
6040 if( pOp->p2>0 ){
6041 VdbeBranchTaken(res!=0,2);
6042 if( res ) goto jump_to_p2;
6043 }
6044 break;
6045}
6046
6047/* Opcode: IfSmaller P1 P2 P3 * *
6048**
6049** Estimate the number of rows in the table P1. Jump to P2 if that
6050** estimate is less than approximately 2**(0.1*P3).
6051*/
6052case OP_IfSmaller: { /* jump */
6053 VdbeCursor *pC;
6054 BtCursor *pCrsr;
6055 int res;
6056 i64 sz;
6057
6058 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6059 pC = p->apCsr[pOp->p1];
6060 assert( pC!=0 );
6061 pCrsr = pC->uc.pCursor;
6062 assert( pCrsr );
6063 rc = sqlite3BtreeFirst(pCrsr, &res);
6064 if( rc ) goto abort_due_to_error;
6065 if( res==0 ){
6066 sz = sqlite3BtreeRowCountEst(pCrsr);
6067 if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)<pOp->p3 ) res = 1;
6068 }
6069 VdbeBranchTaken(res!=0,2);
6070 if( res ) goto jump_to_p2;
6071 break;
6072}
6073
6074
6075/* Opcode: SorterSort P1 P2 * * *
6076**
6077** After all records have been inserted into the Sorter object
6078** identified by P1, invoke this opcode to actually do the sorting.
6079** Jump to P2 if there are no records to be sorted.
6080**
6081** This opcode is an alias for OP_Sort and OP_Rewind that is used
6082** for Sorter objects.
6083*/
6084/* Opcode: Sort P1 P2 * * *
6085**
6086** This opcode does exactly the same thing as OP_Rewind except that
6087** it increments an undocumented global variable used for testing.
6088**
6089** Sorting is accomplished by writing records into a sorting index,
6090** then rewinding that index and playing it back from beginning to
6091** end. We use the OP_Sort opcode instead of OP_Rewind to do the
6092** rewinding so that the global variable will be incremented and
6093** regression tests can determine whether or not the optimizer is
6094** correctly optimizing out sorts.
6095*/
6096case OP_SorterSort: /* jump */
6097case OP_Sort: { /* jump */
6098#ifdef SQLITE_TEST
6099 sqlite3_sort_count++;
6100 sqlite3_search_count--;
6101#endif
6102 p->aCounter[SQLITE_STMTSTATUS_SORT]++;
6103 /* Fall through into OP_Rewind */
6104 /* no break */ deliberate_fall_through
6105}
6106/* Opcode: Rewind P1 P2 * * *
6107**
6108** The next use of the Rowid or Column or Next instruction for P1
6109** will refer to the first entry in the database table or index.
6110** If the table or index is empty, jump immediately to P2.
6111** If the table or index is not empty, fall through to the following
6112** instruction.
6113**
6114** This opcode leaves the cursor configured to move in forward order,
6115** from the beginning toward the end. In other words, the cursor is
6116** configured to use Next, not Prev.
6117*/
6118case OP_Rewind: { /* jump */
6119 VdbeCursor *pC;
6120 BtCursor *pCrsr;
6121 int res;
6122
6123 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6124 assert( pOp->p5==0 );
6125 pC = p->apCsr[pOp->p1];
6126 assert( pC!=0 );
6127 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
6128 res = 1;
6129#ifdef SQLITE_DEBUG
6130 pC->seekOp = OP_Rewind;
6131#endif
6132 if( isSorter(pC) ){
6133 rc = sqlite3VdbeSorterRewind(pC, &res);
6134 }else{
6135 assert( pC->eCurType==CURTYPE_BTREE );
6136 pCrsr = pC->uc.pCursor;
6137 assert( pCrsr );
6138 rc = sqlite3BtreeFirst(pCrsr, &res);
6139 pC->deferredMoveto = 0;
6140 pC->cacheStatus = CACHE_STALE;
6141 }
6142 if( rc ) goto abort_due_to_error;
6143 pC->nullRow = (u8)res;
6144 assert( pOp->p2>0 && pOp->p2<p->nOp );
6145 VdbeBranchTaken(res!=0,2);
6146 if( res ) goto jump_to_p2;
6147 break;
6148}
6149
6150/* Opcode: Next P1 P2 P3 * P5
6151**
6152** Advance cursor P1 so that it points to the next key/data pair in its
6153** table or index. If there are no more key/value pairs then fall through
6154** to the following instruction. But if the cursor advance was successful,
6155** jump immediately to P2.
6156**
6157** The Next opcode is only valid following an SeekGT, SeekGE, or
6158** OP_Rewind opcode used to position the cursor. Next is not allowed
6159** to follow SeekLT, SeekLE, or OP_Last.
6160**
6161** The P1 cursor must be for a real table, not a pseudo-table. P1 must have
6162** been opened prior to this opcode or the program will segfault.
6163**
6164** The P3 value is a hint to the btree implementation. If P3==1, that
6165** means P1 is an SQL index and that this instruction could have been
6166** omitted if that index had been unique. P3 is usually 0. P3 is
6167** always either 0 or 1.
6168**
6169** If P5 is positive and the jump is taken, then event counter
6170** number P5-1 in the prepared statement is incremented.
6171**
6172** See also: Prev
6173*/
6174/* Opcode: Prev P1 P2 P3 * P5
6175**
6176** Back up cursor P1 so that it points to the previous key/data pair in its
6177** table or index. If there is no previous key/value pairs then fall through
6178** to the following instruction. But if the cursor backup was successful,
6179** jump immediately to P2.
6180**
6181**
6182** The Prev opcode is only valid following an SeekLT, SeekLE, or
6183** OP_Last opcode used to position the cursor. Prev is not allowed
6184** to follow SeekGT, SeekGE, or OP_Rewind.
6185**
6186** The P1 cursor must be for a real table, not a pseudo-table. If P1 is
6187** not open then the behavior is undefined.
6188**
6189** The P3 value is a hint to the btree implementation. If P3==1, that
6190** means P1 is an SQL index and that this instruction could have been
6191** omitted if that index had been unique. P3 is usually 0. P3 is
6192** always either 0 or 1.
6193**
6194** If P5 is positive and the jump is taken, then event counter
6195** number P5-1 in the prepared statement is incremented.
6196*/
6197/* Opcode: SorterNext P1 P2 * * P5
6198**
6199** This opcode works just like OP_Next except that P1 must be a
6200** sorter object for which the OP_SorterSort opcode has been
6201** invoked. This opcode advances the cursor to the next sorted
6202** record, or jumps to P2 if there are no more sorted records.
6203*/
6204case OP_SorterNext: { /* jump */
6205 VdbeCursor *pC;
6206
6207 pC = p->apCsr[pOp->p1];
6208 assert( isSorter(pC) );
6209 rc = sqlite3VdbeSorterNext(db, pC);
6210 goto next_tail;
6211
6212case OP_Prev: /* jump */
6213 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6214 assert( pOp->p5==0
6215 || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
6216 || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX);
6217 pC = p->apCsr[pOp->p1];
6218 assert( pC!=0 );
6219 assert( pC->deferredMoveto==0 );
6220 assert( pC->eCurType==CURTYPE_BTREE );
6221 assert( pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
6222 || pC->seekOp==OP_Last || pC->seekOp==OP_IfNoHope
6223 || pC->seekOp==OP_NullRow);
6224 rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3);
6225 goto next_tail;
6226
6227case OP_Next: /* jump */
6228 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6229 assert( pOp->p5==0
6230 || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
6231 || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX);
6232 pC = p->apCsr[pOp->p1];
6233 assert( pC!=0 );
6234 assert( pC->deferredMoveto==0 );
6235 assert( pC->eCurType==CURTYPE_BTREE );
6236 assert( pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
6237 || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found
6238 || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid
6239 || pC->seekOp==OP_IfNoHope);
6240 rc = sqlite3BtreeNext(pC->uc.pCursor, pOp->p3);
6241
6242next_tail:
6243 pC->cacheStatus = CACHE_STALE;
6244 VdbeBranchTaken(rc==SQLITE_OK,2);
6245 if( rc==SQLITE_OK ){
6246 pC->nullRow = 0;
6247 p->aCounter[pOp->p5]++;
6248#ifdef SQLITE_TEST
6249 sqlite3_search_count++;
6250#endif
6251 goto jump_to_p2_and_check_for_interrupt;
6252 }
6253 if( rc!=SQLITE_DONE ) goto abort_due_to_error;
6254 rc = SQLITE_OK;
6255 pC->nullRow = 1;
6256 goto check_for_interrupt;
6257}
6258
6259/* Opcode: IdxInsert P1 P2 P3 P4 P5
6260** Synopsis: key=r[P2]
6261**
6262** Register P2 holds an SQL index key made using the
6263** MakeRecord instructions. This opcode writes that key
6264** into the index P1. Data for the entry is nil.
6265**
6266** If P4 is not zero, then it is the number of values in the unpacked
6267** key of reg(P2). In that case, P3 is the index of the first register
6268** for the unpacked key. The availability of the unpacked key can sometimes
6269** be an optimization.
6270**
6271** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer
6272** that this insert is likely to be an append.
6273**
6274** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
6275** incremented by this instruction. If the OPFLAG_NCHANGE bit is clear,
6276** then the change counter is unchanged.
6277**
6278** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
6279** run faster by avoiding an unnecessary seek on cursor P1. However,
6280** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
6281** seeks on the cursor or if the most recent seek used a key equivalent
6282** to P2.
6283**
6284** This instruction only works for indices. The equivalent instruction
6285** for tables is OP_Insert.
6286*/
6287case OP_IdxInsert: { /* in2 */
6288 VdbeCursor *pC;
6289 BtreePayload x;
6290
6291 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6292 pC = p->apCsr[pOp->p1];
6293 sqlite3VdbeIncrWriteCounter(p, pC);
6294 assert( pC!=0 );
6295 assert( !isSorter(pC) );
6296 pIn2 = &aMem[pOp->p2];
6297 assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) );
6298 if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
6299 assert( pC->eCurType==CURTYPE_BTREE );
6300 assert( pC->isTable==0 );
6301 rc = ExpandBlob(pIn2);
6302 if( rc ) goto abort_due_to_error;
6303 x.nKey = pIn2->n;
6304 x.pKey = pIn2->z;
6305 x.aMem = aMem + pOp->p3;
6306 x.nMem = (u16)pOp->p4.i;
6307 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
6308 (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
6309 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
6310 );
6311 assert( pC->deferredMoveto==0 );
6312 pC->cacheStatus = CACHE_STALE;
6313 if( rc) goto abort_due_to_error;
6314 break;
6315}
6316
6317/* Opcode: SorterInsert P1 P2 * * *
6318** Synopsis: key=r[P2]
6319**
6320** Register P2 holds an SQL index key made using the
6321** MakeRecord instructions. This opcode writes that key
6322** into the sorter P1. Data for the entry is nil.
6323*/
6324case OP_SorterInsert: { /* in2 */
6325 VdbeCursor *pC;
6326
6327 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6328 pC = p->apCsr[pOp->p1];
6329 sqlite3VdbeIncrWriteCounter(p, pC);
6330 assert( pC!=0 );
6331 assert( isSorter(pC) );
6332 pIn2 = &aMem[pOp->p2];
6333 assert( pIn2->flags & MEM_Blob );
6334 assert( pC->isTable==0 );
6335 rc = ExpandBlob(pIn2);
6336 if( rc ) goto abort_due_to_error;
6337 rc = sqlite3VdbeSorterWrite(pC, pIn2);
6338 if( rc) goto abort_due_to_error;
6339 break;
6340}
6341
6342/* Opcode: IdxDelete P1 P2 P3 * P5
6343** Synopsis: key=r[P2@P3]
6344**
6345** The content of P3 registers starting at register P2 form
6346** an unpacked index key. This opcode removes that entry from the
6347** index opened by cursor P1.
6348**
6349** If P5 is not zero, then raise an SQLITE_CORRUPT_INDEX error
6350** if no matching index entry is found. This happens when running
6351** an UPDATE or DELETE statement and the index entry to be updated
6352** or deleted is not found. For some uses of IdxDelete
6353** (example: the EXCEPT operator) it does not matter that no matching
6354** entry is found. For those cases, P5 is zero. Also, do not raise
6355** this (self-correcting and non-critical) error if in writable_schema mode.
6356*/
6357case OP_IdxDelete: {
6358 VdbeCursor *pC;
6359 BtCursor *pCrsr;
6360 int res;
6361 UnpackedRecord r;
6362
6363 assert( pOp->p3>0 );
6364 assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 );
6365 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6366 pC = p->apCsr[pOp->p1];
6367 assert( pC!=0 );
6368 assert( pC->eCurType==CURTYPE_BTREE );
6369 sqlite3VdbeIncrWriteCounter(p, pC);
6370 pCrsr = pC->uc.pCursor;
6371 assert( pCrsr!=0 );
6372 r.pKeyInfo = pC->pKeyInfo;
6373 r.nField = (u16)pOp->p3;
6374 r.default_rc = 0;
6375 r.aMem = &aMem[pOp->p2];
6376 rc = sqlite3BtreeIndexMoveto(pCrsr, &r, &res);
6377 if( rc ) goto abort_due_to_error;
6378 if( res==0 ){
6379 rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE);
6380 if( rc ) goto abort_due_to_error;
6381 }else if( pOp->p5 && !sqlite3WritableSchema(db) ){
6382 rc = sqlite3ReportError(SQLITE_CORRUPT_INDEX, __LINE__, "index corruption");
6383 goto abort_due_to_error;
6384 }
6385 assert( pC->deferredMoveto==0 );
6386 pC->cacheStatus = CACHE_STALE;
6387 pC->seekResult = 0;
6388 break;
6389}
6390
6391/* Opcode: DeferredSeek P1 * P3 P4 *
6392** Synopsis: Move P3 to P1.rowid if needed
6393**
6394** P1 is an open index cursor and P3 is a cursor on the corresponding
6395** table. This opcode does a deferred seek of the P3 table cursor
6396** to the row that corresponds to the current row of P1.
6397**
6398** This is a deferred seek. Nothing actually happens until
6399** the cursor is used to read a record. That way, if no reads
6400** occur, no unnecessary I/O happens.
6401**
6402** P4 may be an array of integers (type P4_INTARRAY) containing
6403** one entry for each column in the P3 table. If array entry a(i)
6404** is non-zero, then reading column a(i)-1 from cursor P3 is
6405** equivalent to performing the deferred seek and then reading column i
6406** from P1. This information is stored in P3 and used to redirect
6407** reads against P3 over to P1, thus possibly avoiding the need to
6408** seek and read cursor P3.
6409*/
6410/* Opcode: IdxRowid P1 P2 * * *
6411** Synopsis: r[P2]=rowid
6412**
6413** Write into register P2 an integer which is the last entry in the record at
6414** the end of the index key pointed to by cursor P1. This integer should be
6415** the rowid of the table entry to which this index entry points.
6416**
6417** See also: Rowid, MakeRecord.
6418*/
6419case OP_DeferredSeek:
6420case OP_IdxRowid: { /* out2 */
6421 VdbeCursor *pC; /* The P1 index cursor */
6422 VdbeCursor *pTabCur; /* The P2 table cursor (OP_DeferredSeek only) */
6423 i64 rowid; /* Rowid that P1 current points to */
6424
6425 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6426 pC = p->apCsr[pOp->p1];
6427 assert( pC!=0 );
6428 assert( pC->eCurType==CURTYPE_BTREE || IsNullCursor(pC) );
6429 assert( pC->uc.pCursor!=0 );
6430 assert( pC->isTable==0 || IsNullCursor(pC) );
6431 assert( pC->deferredMoveto==0 );
6432 assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
6433
6434 /* The IdxRowid and Seek opcodes are combined because of the commonality
6435 ** of sqlite3VdbeCursorRestore() and sqlite3VdbeIdxRowid(). */
6436 rc = sqlite3VdbeCursorRestore(pC);
6437
6438 /* sqlite3VdbeCursorRestore() may fail if the cursor has been disturbed
6439 ** since it was last positioned and an error (e.g. OOM or an IO error)
6440 ** occurs while trying to reposition it. */
6441 if( rc!=SQLITE_OK ) goto abort_due_to_error;
6442
6443 if( !pC->nullRow ){
6444 rowid = 0; /* Not needed. Only used to silence a warning. */
6445 rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
6446 if( rc!=SQLITE_OK ){
6447 goto abort_due_to_error;
6448 }
6449 if( pOp->opcode==OP_DeferredSeek ){
6450 assert( pOp->p3>=0 && pOp->p3<p->nCursor );
6451 pTabCur = p->apCsr[pOp->p3];
6452 assert( pTabCur!=0 );
6453 assert( pTabCur->eCurType==CURTYPE_BTREE );
6454 assert( pTabCur->uc.pCursor!=0 );
6455 assert( pTabCur->isTable );
6456 pTabCur->nullRow = 0;
6457 pTabCur->movetoTarget = rowid;
6458 pTabCur->deferredMoveto = 1;
6459 pTabCur->cacheStatus = CACHE_STALE;
6460 assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
6461 assert( !pTabCur->isEphemeral );
6462 pTabCur->ub.aAltMap = pOp->p4.ai;
6463 assert( !pC->isEphemeral );
6464 pTabCur->pAltCursor = pC;
6465 }else{
6466 pOut = out2Prerelease(p, pOp);
6467 pOut->u.i = rowid;
6468 }
6469 }else{
6470 assert( pOp->opcode==OP_IdxRowid );
6471 sqlite3VdbeMemSetNull(&aMem[pOp->p2]);
6472 }
6473 break;
6474}
6475
6476/* Opcode: FinishSeek P1 * * * *
6477**
6478** If cursor P1 was previously moved via OP_DeferredSeek, complete that
6479** seek operation now, without further delay. If the cursor seek has
6480** already occurred, this instruction is a no-op.
6481*/
6482case OP_FinishSeek: {
6483 VdbeCursor *pC; /* The P1 index cursor */
6484
6485 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6486 pC = p->apCsr[pOp->p1];
6487 if( pC->deferredMoveto ){
6488 rc = sqlite3VdbeFinishMoveto(pC);
6489 if( rc ) goto abort_due_to_error;
6490 }
6491 break;
6492}
6493
6494/* Opcode: IdxGE P1 P2 P3 P4 *
6495** Synopsis: key=r[P3@P4]
6496**
6497** The P4 register values beginning with P3 form an unpacked index
6498** key that omits the PRIMARY KEY. Compare this key value against the index
6499** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID
6500** fields at the end.
6501**
6502** If the P1 index entry is greater than or equal to the key value
6503** then jump to P2. Otherwise fall through to the next instruction.
6504*/
6505/* Opcode: IdxGT P1 P2 P3 P4 *
6506** Synopsis: key=r[P3@P4]
6507**
6508** The P4 register values beginning with P3 form an unpacked index
6509** key that omits the PRIMARY KEY. Compare this key value against the index
6510** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID
6511** fields at the end.
6512**
6513** If the P1 index entry is greater than the key value
6514** then jump to P2. Otherwise fall through to the next instruction.
6515*/
6516/* Opcode: IdxLT P1 P2 P3 P4 *
6517** Synopsis: key=r[P3@P4]
6518**
6519** The P4 register values beginning with P3 form an unpacked index
6520** key that omits the PRIMARY KEY or ROWID. Compare this key value against
6521** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
6522** ROWID on the P1 index.
6523**
6524** If the P1 index entry is less than the key value then jump to P2.
6525** Otherwise fall through to the next instruction.
6526*/
6527/* Opcode: IdxLE P1 P2 P3 P4 *
6528** Synopsis: key=r[P3@P4]
6529**
6530** The P4 register values beginning with P3 form an unpacked index
6531** key that omits the PRIMARY KEY or ROWID. Compare this key value against
6532** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
6533** ROWID on the P1 index.
6534**
6535** If the P1 index entry is less than or equal to the key value then jump
6536** to P2. Otherwise fall through to the next instruction.
6537*/
6538case OP_IdxLE: /* jump */
6539case OP_IdxGT: /* jump */
6540case OP_IdxLT: /* jump */
6541case OP_IdxGE: { /* jump */
6542 VdbeCursor *pC;
6543 int res;
6544 UnpackedRecord r;
6545
6546 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6547 pC = p->apCsr[pOp->p1];
6548 assert( pC!=0 );
6549 assert( pC->isOrdered );
6550 assert( pC->eCurType==CURTYPE_BTREE );
6551 assert( pC->uc.pCursor!=0);
6552 assert( pC->deferredMoveto==0 );
6553 assert( pOp->p4type==P4_INT32 );
6554 r.pKeyInfo = pC->pKeyInfo;
6555 r.nField = (u16)pOp->p4.i;
6556 if( pOp->opcode<OP_IdxLT ){
6557 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT );
6558 r.default_rc = -1;
6559 }else{
6560 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT );
6561 r.default_rc = 0;
6562 }
6563 r.aMem = &aMem[pOp->p3];
6564#ifdef SQLITE_DEBUG
6565 {
6566 int i;
6567 for(i=0; i<r.nField; i++){
6568 assert( memIsValid(&r.aMem[i]) );
6569 REGISTER_TRACE(pOp->p3+i, &aMem[pOp->p3+i]);
6570 }
6571 }
6572#endif
6573
6574 /* Inlined version of sqlite3VdbeIdxKeyCompare() */
6575 {
6576 i64 nCellKey = 0;
6577 BtCursor *pCur;
6578 Mem m;
6579
6580 assert( pC->eCurType==CURTYPE_BTREE );
6581 pCur = pC->uc.pCursor;
6582 assert( sqlite3BtreeCursorIsValid(pCur) );
6583 nCellKey = sqlite3BtreePayloadSize(pCur);
6584 /* nCellKey will always be between 0 and 0xffffffff because of the way
6585 ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
6586 if( nCellKey<=0 || nCellKey>0x7fffffff ){
6587 rc = SQLITE_CORRUPT_BKPT;
6588 goto abort_due_to_error;
6589 }
6590 sqlite3VdbeMemInit(&m, db, 0);
6591 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m);
6592 if( rc ) goto abort_due_to_error;
6593 res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, &r, 0);
6594 sqlite3VdbeMemReleaseMalloc(&m);
6595 }
6596 /* End of inlined sqlite3VdbeIdxKeyCompare() */
6597
6598 assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) );
6599 if( (pOp->opcode&1)==(OP_IdxLT&1) ){
6600 assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT );
6601 res = -res;
6602 }else{
6603 assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT );
6604 res++;
6605 }
6606 VdbeBranchTaken(res>0,2);
6607 assert( rc==SQLITE_OK );
6608 if( res>0 ) goto jump_to_p2;
6609 break;
6610}
6611
6612/* Opcode: Destroy P1 P2 P3 * *
6613**
6614** Delete an entire database table or index whose root page in the database
6615** file is given by P1.
6616**
6617** The table being destroyed is in the main database file if P3==0. If
6618** P3==1 then the table to be clear is in the auxiliary database file
6619** that is used to store tables create using CREATE TEMPORARY TABLE.
6620**
6621** If AUTOVACUUM is enabled then it is possible that another root page
6622** might be moved into the newly deleted root page in order to keep all
6623** root pages contiguous at the beginning of the database. The former
6624** value of the root page that moved - its value before the move occurred -
6625** is stored in register P2. If no page movement was required (because the
6626** table being dropped was already the last one in the database) then a
6627** zero is stored in register P2. If AUTOVACUUM is disabled then a zero
6628** is stored in register P2.
6629**
6630** This opcode throws an error if there are any active reader VMs when
6631** it is invoked. This is done to avoid the difficulty associated with
6632** updating existing cursors when a root page is moved in an AUTOVACUUM
6633** database. This error is thrown even if the database is not an AUTOVACUUM
6634** db in order to avoid introducing an incompatibility between autovacuum
6635** and non-autovacuum modes.
6636**
6637** See also: Clear
6638*/
6639case OP_Destroy: { /* out2 */
6640 int iMoved;
6641 int iDb;
6642
6643 sqlite3VdbeIncrWriteCounter(p, 0);
6644 assert( p->readOnly==0 );
6645 assert( pOp->p1>1 );
6646 pOut = out2Prerelease(p, pOp);
6647 pOut->flags = MEM_Null;
6648 if( db->nVdbeRead > db->nVDestroy+1 ){
6649 rc = SQLITE_LOCKED;
6650 p->errorAction = OE_Abort;
6651 goto abort_due_to_error;
6652 }else{
6653 iDb = pOp->p3;
6654 assert( DbMaskTest(p->btreeMask, iDb) );
6655 iMoved = 0; /* Not needed. Only to silence a warning. */
6656 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
6657 pOut->flags = MEM_Int;
6658 pOut->u.i = iMoved;
6659 if( rc ) goto abort_due_to_error;
6660#ifndef SQLITE_OMIT_AUTOVACUUM
6661 if( iMoved!=0 ){
6662 sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
6663 /* All OP_Destroy operations occur on the same btree */
6664 assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
6665 resetSchemaOnFault = iDb+1;
6666 }
6667#endif
6668 }
6669 break;
6670}
6671
6672/* Opcode: Clear P1 P2 P3
6673**
6674** Delete all contents of the database table or index whose root page
6675** in the database file is given by P1. But, unlike Destroy, do not
6676** remove the table or index from the database file.
6677**
6678** The table being clear is in the main database file if P2==0. If
6679** P2==1 then the table to be clear is in the auxiliary database file
6680** that is used to store tables create using CREATE TEMPORARY TABLE.
6681**
6682** If the P3 value is non-zero, then the row change count is incremented
6683** by the number of rows in the table being cleared. If P3 is greater
6684** than zero, then the value stored in register P3 is also incremented
6685** by the number of rows in the table being cleared.
6686**
6687** See also: Destroy
6688*/
6689case OP_Clear: {
6690 i64 nChange;
6691
6692 sqlite3VdbeIncrWriteCounter(p, 0);
6693 nChange = 0;
6694 assert( p->readOnly==0 );
6695 assert( DbMaskTest(p->btreeMask, pOp->p2) );
6696 rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, (u32)pOp->p1, &nChange);
6697 if( pOp->p3 ){
6698 p->nChange += nChange;
6699 if( pOp->p3>0 ){
6700 assert( memIsValid(&aMem[pOp->p3]) );
6701 memAboutToChange(p, &aMem[pOp->p3]);
6702 aMem[pOp->p3].u.i += nChange;
6703 }
6704 }
6705 if( rc ) goto abort_due_to_error;
6706 break;
6707}
6708
6709/* Opcode: ResetSorter P1 * * * *
6710**
6711** Delete all contents from the ephemeral table or sorter
6712** that is open on cursor P1.
6713**
6714** This opcode only works for cursors used for sorting and
6715** opened with OP_OpenEphemeral or OP_SorterOpen.
6716*/
6717case OP_ResetSorter: {
6718 VdbeCursor *pC;
6719
6720 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
6721 pC = p->apCsr[pOp->p1];
6722 assert( pC!=0 );
6723 if( isSorter(pC) ){
6724 sqlite3VdbeSorterReset(db, pC->uc.pSorter);
6725 }else{
6726 assert( pC->eCurType==CURTYPE_BTREE );
6727 assert( pC->isEphemeral );
6728 rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
6729 if( rc ) goto abort_due_to_error;
6730 }
6731 break;
6732}
6733
6734/* Opcode: CreateBtree P1 P2 P3 * *
6735** Synopsis: r[P2]=root iDb=P1 flags=P3
6736**
6737** Allocate a new b-tree in the main database file if P1==0 or in the
6738** TEMP database file if P1==1 or in an attached database if
6739** P1>1. The P3 argument must be 1 (BTREE_INTKEY) for a rowid table
6740** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table.
6741** The root page number of the new b-tree is stored in register P2.
6742*/
6743case OP_CreateBtree: { /* out2 */
6744 Pgno pgno;
6745 Db *pDb;
6746
6747 sqlite3VdbeIncrWriteCounter(p, 0);
6748 pOut = out2Prerelease(p, pOp);
6749 pgno = 0;
6750 assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY );
6751 assert( pOp->p1>=0 && pOp->p1<db->nDb );
6752 assert( DbMaskTest(p->btreeMask, pOp->p1) );
6753 assert( p->readOnly==0 );
6754 pDb = &db->aDb[pOp->p1];
6755 assert( pDb->pBt!=0 );
6756 rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3);
6757 if( rc ) goto abort_due_to_error;
6758 pOut->u.i = pgno;
6759 break;
6760}
6761
6762/* Opcode: SqlExec * * * P4 *
6763**
6764** Run the SQL statement or statements specified in the P4 string.
6765*/
6766case OP_SqlExec: {
6767 sqlite3VdbeIncrWriteCounter(p, 0);
6768 db->nSqlExec++;
6769 rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0);
6770 db->nSqlExec--;
6771 if( rc ) goto abort_due_to_error;
6772 break;
6773}
6774
6775/* Opcode: ParseSchema P1 * * P4 *
6776**
6777** Read and parse all entries from the schema table of database P1
6778** that match the WHERE clause P4. If P4 is a NULL pointer, then the
6779** entire schema for P1 is reparsed.
6780**
6781** This opcode invokes the parser to create a new virtual machine,
6782** then runs the new virtual machine. It is thus a re-entrant opcode.
6783*/
6784case OP_ParseSchema: {
6785 int iDb;
6786 const char *zSchema;
6787 char *zSql;
6788 InitData initData;
6789
6790 /* Any prepared statement that invokes this opcode will hold mutexes
6791 ** on every btree. This is a prerequisite for invoking
6792 ** sqlite3InitCallback().
6793 */
6794#ifdef SQLITE_DEBUG
6795 for(iDb=0; iDb<db->nDb; iDb++){
6796 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
6797 }
6798#endif
6799
6800 iDb = pOp->p1;
6801 assert( iDb>=0 && iDb<db->nDb );
6802 assert( DbHasProperty(db, iDb, DB_SchemaLoaded)
6803 || db->mallocFailed
6804 || (CORRUPT_DB && (db->flags & SQLITE_NoSchemaError)!=0) );
6805
6806#ifndef SQLITE_OMIT_ALTERTABLE
6807 if( pOp->p4.z==0 ){
6808 sqlite3SchemaClear(db->aDb[iDb].pSchema);
6809 db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
6810 rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
6811 db->mDbFlags |= DBFLAG_SchemaChange;
6812 p->expired = 0;
6813 }else
6814#endif
6815 {
6816 zSchema = LEGACY_SCHEMA_TABLE;
6817 initData.db = db;
6818 initData.iDb = iDb;
6819 initData.pzErrMsg = &p->zErrMsg;
6820 initData.mInitFlags = 0;
6821 initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt);
6822 zSql = sqlite3MPrintf(db,
6823 "SELECT*FROM\"%w\".%s WHERE %s ORDER BY rowid",
6824 db->aDb[iDb].zDbSName, zSchema, pOp->p4.z);
6825 if( zSql==0 ){
6826 rc = SQLITE_NOMEM_BKPT;
6827 }else{
6828 assert( db->init.busy==0 );
6829 db->init.busy = 1;
6830 initData.rc = SQLITE_OK;
6831 initData.nInitRow = 0;
6832 assert( !db->mallocFailed );
6833 rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
6834 if( rc==SQLITE_OK ) rc = initData.rc;
6835 if( rc==SQLITE_OK && initData.nInitRow==0 ){
6836 /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse
6837 ** at least one SQL statement. Any less than that indicates that
6838 ** the sqlite_schema table is corrupt. */
6839 rc = SQLITE_CORRUPT_BKPT;
6840 }
6841 sqlite3DbFreeNN(db, zSql);
6842 db->init.busy = 0;
6843 }
6844 }
6845 if( rc ){
6846 sqlite3ResetAllSchemasOfConnection(db);
6847 if( rc==SQLITE_NOMEM ){
6848 goto no_mem;
6849 }
6850 goto abort_due_to_error;
6851 }
6852 break;
6853}
6854
6855#if !defined(SQLITE_OMIT_ANALYZE)
6856/* Opcode: LoadAnalysis P1 * * * *
6857**
6858** Read the sqlite_stat1 table for database P1 and load the content
6859** of that table into the internal index hash table. This will cause
6860** the analysis to be used when preparing all subsequent queries.
6861*/
6862case OP_LoadAnalysis: {
6863 assert( pOp->p1>=0 && pOp->p1<db->nDb );
6864 rc = sqlite3AnalysisLoad(db, pOp->p1);
6865 if( rc ) goto abort_due_to_error;
6866 break;
6867}
6868#endif /* !defined(SQLITE_OMIT_ANALYZE) */
6869
6870/* Opcode: DropTable P1 * * P4 *
6871**
6872** Remove the internal (in-memory) data structures that describe
6873** the table named P4 in database P1. This is called after a table
6874** is dropped from disk (using the Destroy opcode) in order to keep
6875** the internal representation of the
6876** schema consistent with what is on disk.
6877*/
6878case OP_DropTable: {
6879 sqlite3VdbeIncrWriteCounter(p, 0);
6880 sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
6881 break;
6882}
6883
6884/* Opcode: DropIndex P1 * * P4 *
6885**
6886** Remove the internal (in-memory) data structures that describe
6887** the index named P4 in database P1. This is called after an index
6888** is dropped from disk (using the Destroy opcode)
6889** in order to keep the internal representation of the
6890** schema consistent with what is on disk.
6891*/
6892case OP_DropIndex: {
6893 sqlite3VdbeIncrWriteCounter(p, 0);
6894 sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
6895 break;
6896}
6897
6898/* Opcode: DropTrigger P1 * * P4 *
6899**
6900** Remove the internal (in-memory) data structures that describe
6901** the trigger named P4 in database P1. This is called after a trigger
6902** is dropped from disk (using the Destroy opcode) in order to keep
6903** the internal representation of the
6904** schema consistent with what is on disk.
6905*/
6906case OP_DropTrigger: {
6907 sqlite3VdbeIncrWriteCounter(p, 0);
6908 sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
6909 break;
6910}
6911
6912
6913#ifndef SQLITE_OMIT_INTEGRITY_CHECK
6914/* Opcode: IntegrityCk P1 P2 P3 P4 P5
6915**
6916** Do an analysis of the currently open database. Store in
6917** register P1 the text of an error message describing any problems.
6918** If no problems are found, store a NULL in register P1.
6919**
6920** The register P3 contains one less than the maximum number of allowed errors.
6921** At most reg(P3) errors will be reported.
6922** In other words, the analysis stops as soon as reg(P1) errors are
6923** seen. Reg(P1) is updated with the number of errors remaining.
6924**
6925** The root page numbers of all tables in the database are integers
6926** stored in P4_INTARRAY argument.
6927**
6928** If P5 is not zero, the check is done on the auxiliary database
6929** file, not the main database file.
6930**
6931** This opcode is used to implement the integrity_check pragma.
6932*/
6933case OP_IntegrityCk: {
6934 int nRoot; /* Number of tables to check. (Number of root pages.) */
6935 Pgno *aRoot; /* Array of rootpage numbers for tables to be checked */
6936 int nErr; /* Number of errors reported */
6937 char *z; /* Text of the error report */
6938 Mem *pnErr; /* Register keeping track of errors remaining */
6939
6940 assert( p->bIsReader );
6941 nRoot = pOp->p2;
6942 aRoot = pOp->p4.ai;
6943 assert( nRoot>0 );
6944 assert( aRoot[0]==(Pgno)nRoot );
6945 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
6946 pnErr = &aMem[pOp->p3];
6947 assert( (pnErr->flags & MEM_Int)!=0 );
6948 assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
6949 pIn1 = &aMem[pOp->p1];
6950 assert( pOp->p5<db->nDb );
6951 assert( DbMaskTest(p->btreeMask, pOp->p5) );
6952 z = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,
6953 (int)pnErr->u.i+1, &nErr);
6954 sqlite3VdbeMemSetNull(pIn1);
6955 if( nErr==0 ){
6956 assert( z==0 );
6957 }else if( z==0 ){
6958 goto no_mem;
6959 }else{
6960 pnErr->u.i -= nErr-1;
6961 sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
6962 }
6963 UPDATE_MAX_BLOBSIZE(pIn1);
6964 sqlite3VdbeChangeEncoding(pIn1, encoding);
6965 goto check_for_interrupt;
6966}
6967#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
6968
6969/* Opcode: RowSetAdd P1 P2 * * *
6970** Synopsis: rowset(P1)=r[P2]
6971**
6972** Insert the integer value held by register P2 into a RowSet object
6973** held in register P1.
6974**
6975** An assertion fails if P2 is not an integer.
6976*/
6977case OP_RowSetAdd: { /* in1, in2 */
6978 pIn1 = &aMem[pOp->p1];
6979 pIn2 = &aMem[pOp->p2];
6980 assert( (pIn2->flags & MEM_Int)!=0 );
6981 if( (pIn1->flags & MEM_Blob)==0 ){
6982 if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem;
6983 }
6984 assert( sqlite3VdbeMemIsRowSet(pIn1) );
6985 sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i);
6986 break;
6987}
6988
6989/* Opcode: RowSetRead P1 P2 P3 * *
6990** Synopsis: r[P3]=rowset(P1)
6991**
6992** Extract the smallest value from the RowSet object in P1
6993** and put that value into register P3.
6994** Or, if RowSet object P1 is initially empty, leave P3
6995** unchanged and jump to instruction P2.
6996*/
6997case OP_RowSetRead: { /* jump, in1, out3 */
6998 i64 val;
6999
7000 pIn1 = &aMem[pOp->p1];
7001 assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) );
7002 if( (pIn1->flags & MEM_Blob)==0
7003 || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0
7004 ){
7005 /* The boolean index is empty */
7006 sqlite3VdbeMemSetNull(pIn1);
7007 VdbeBranchTaken(1,2);
7008 goto jump_to_p2_and_check_for_interrupt;
7009 }else{
7010 /* A value was pulled from the index */
7011 VdbeBranchTaken(0,2);
7012 sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val);
7013 }
7014 goto check_for_interrupt;
7015}
7016
7017/* Opcode: RowSetTest P1 P2 P3 P4
7018** Synopsis: if r[P3] in rowset(P1) goto P2
7019**
7020** Register P3 is assumed to hold a 64-bit integer value. If register P1
7021** contains a RowSet object and that RowSet object contains
7022** the value held in P3, jump to register P2. Otherwise, insert the
7023** integer in P3 into the RowSet and continue on to the
7024** next opcode.
7025**
7026** The RowSet object is optimized for the case where sets of integers
7027** are inserted in distinct phases, which each set contains no duplicates.
7028** Each set is identified by a unique P4 value. The first set
7029** must have P4==0, the final set must have P4==-1, and for all other sets
7030** must have P4>0.
7031**
7032** This allows optimizations: (a) when P4==0 there is no need to test
7033** the RowSet object for P3, as it is guaranteed not to contain it,
7034** (b) when P4==-1 there is no need to insert the value, as it will
7035** never be tested for, and (c) when a value that is part of set X is
7036** inserted, there is no need to search to see if the same value was
7037** previously inserted as part of set X (only if it was previously
7038** inserted as part of some other set).
7039*/
7040case OP_RowSetTest: { /* jump, in1, in3 */
7041 int iSet;
7042 int exists;
7043
7044 pIn1 = &aMem[pOp->p1];
7045 pIn3 = &aMem[pOp->p3];
7046 iSet = pOp->p4.i;
7047 assert( pIn3->flags&MEM_Int );
7048
7049 /* If there is anything other than a rowset object in memory cell P1,
7050 ** delete it now and initialize P1 with an empty rowset
7051 */
7052 if( (pIn1->flags & MEM_Blob)==0 ){
7053 if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem;
7054 }
7055 assert( sqlite3VdbeMemIsRowSet(pIn1) );
7056 assert( pOp->p4type==P4_INT32 );
7057 assert( iSet==-1 || iSet>=0 );
7058 if( iSet ){
7059 exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i);
7060 VdbeBranchTaken(exists!=0,2);
7061 if( exists ) goto jump_to_p2;
7062 }
7063 if( iSet>=0 ){
7064 sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i);
7065 }
7066 break;
7067}
7068
7069
7070#ifndef SQLITE_OMIT_TRIGGER
7071
7072/* Opcode: Program P1 P2 P3 P4 P5
7073**
7074** Execute the trigger program passed as P4 (type P4_SUBPROGRAM).
7075**
7076** P1 contains the address of the memory cell that contains the first memory
7077** cell in an array of values used as arguments to the sub-program. P2
7078** contains the address to jump to if the sub-program throws an IGNORE
7079** exception using the RAISE() function. Register P3 contains the address
7080** of a memory cell in this (the parent) VM that is used to allocate the
7081** memory required by the sub-vdbe at runtime.
7082**
7083** P4 is a pointer to the VM containing the trigger program.
7084**
7085** If P5 is non-zero, then recursive program invocation is enabled.
7086*/
7087case OP_Program: { /* jump */
7088 int nMem; /* Number of memory registers for sub-program */
7089 int nByte; /* Bytes of runtime space required for sub-program */
7090 Mem *pRt; /* Register to allocate runtime space */
7091 Mem *pMem; /* Used to iterate through memory cells */
7092 Mem *pEnd; /* Last memory cell in new array */
7093 VdbeFrame *pFrame; /* New vdbe frame to execute in */
7094 SubProgram *pProgram; /* Sub-program to execute */
7095 void *t; /* Token identifying trigger */
7096
7097 pProgram = pOp->p4.pProgram;
7098 pRt = &aMem[pOp->p3];
7099 assert( pProgram->nOp>0 );
7100
7101 /* If the p5 flag is clear, then recursive invocation of triggers is
7102 ** disabled for backwards compatibility (p5 is set if this sub-program
7103 ** is really a trigger, not a foreign key action, and the flag set
7104 ** and cleared by the "PRAGMA recursive_triggers" command is clear).
7105 **
7106 ** It is recursive invocation of triggers, at the SQL level, that is
7107 ** disabled. In some cases a single trigger may generate more than one
7108 ** SubProgram (if the trigger may be executed with more than one different
7109 ** ON CONFLICT algorithm). SubProgram structures associated with a
7110 ** single trigger all have the same value for the SubProgram.token
7111 ** variable. */
7112 if( pOp->p5 ){
7113 t = pProgram->token;
7114 for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent);
7115 if( pFrame ) break;
7116 }
7117
7118 if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){
7119 rc = SQLITE_ERROR;
7120 sqlite3VdbeError(p, "too many levels of trigger recursion");
7121 goto abort_due_to_error;
7122 }
7123
7124 /* Register pRt is used to store the memory required to save the state
7125 ** of the current program, and the memory required at runtime to execute
7126 ** the trigger program. If this trigger has been fired before, then pRt
7127 ** is already allocated. Otherwise, it must be initialized. */
7128 if( (pRt->flags&MEM_Blob)==0 ){
7129 /* SubProgram.nMem is set to the number of memory cells used by the
7130 ** program stored in SubProgram.aOp. As well as these, one memory
7131 ** cell is required for each cursor used by the program. Set local
7132 ** variable nMem (and later, VdbeFrame.nChildMem) to this value.
7133 */
7134 nMem = pProgram->nMem + pProgram->nCsr;
7135 assert( nMem>0 );
7136 if( pProgram->nCsr==0 ) nMem++;
7137 nByte = ROUND8(sizeof(VdbeFrame))
7138 + nMem * sizeof(Mem)
7139 + pProgram->nCsr * sizeof(VdbeCursor*)
7140 + (pProgram->nOp + 7)/8;
7141 pFrame = sqlite3DbMallocZero(db, nByte);
7142 if( !pFrame ){
7143 goto no_mem;
7144 }
7145 sqlite3VdbeMemRelease(pRt);
7146 pRt->flags = MEM_Blob|MEM_Dyn;
7147 pRt->z = (char*)pFrame;
7148 pRt->n = nByte;
7149 pRt->xDel = sqlite3VdbeFrameMemDel;
7150
7151 pFrame->v = p;
7152 pFrame->nChildMem = nMem;
7153 pFrame->nChildCsr = pProgram->nCsr;
7154 pFrame->pc = (int)(pOp - aOp);
7155 pFrame->aMem = p->aMem;
7156 pFrame->nMem = p->nMem;
7157 pFrame->apCsr = p->apCsr;
7158 pFrame->nCursor = p->nCursor;
7159 pFrame->aOp = p->aOp;
7160 pFrame->nOp = p->nOp;
7161 pFrame->token = pProgram->token;
7162#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
7163 pFrame->anExec = p->anExec;
7164#endif
7165#ifdef SQLITE_DEBUG
7166 pFrame->iFrameMagic = SQLITE_FRAME_MAGIC;
7167#endif
7168
7169 pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem];
7170 for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){
7171 pMem->flags = MEM_Undefined;
7172 pMem->db = db;
7173 }
7174 }else{
7175 pFrame = (VdbeFrame*)pRt->z;
7176 assert( pRt->xDel==sqlite3VdbeFrameMemDel );
7177 assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem
7178 || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) );
7179 assert( pProgram->nCsr==pFrame->nChildCsr );
7180 assert( (int)(pOp - aOp)==pFrame->pc );
7181 }
7182
7183 p->nFrame++;
7184 pFrame->pParent = p->pFrame;
7185 pFrame->lastRowid = db->lastRowid;
7186 pFrame->nChange = p->nChange;
7187 pFrame->nDbChange = p->db->nChange;
7188 assert( pFrame->pAuxData==0 );
7189 pFrame->pAuxData = p->pAuxData;
7190 p->pAuxData = 0;
7191 p->nChange = 0;
7192 p->pFrame = pFrame;
7193 p->aMem = aMem = VdbeFrameMem(pFrame);
7194 p->nMem = pFrame->nChildMem;
7195 p->nCursor = (u16)pFrame->nChildCsr;
7196 p->apCsr = (VdbeCursor **)&aMem[p->nMem];
7197 pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr];
7198 memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8);
7199 p->aOp = aOp = pProgram->aOp;
7200 p->nOp = pProgram->nOp;
7201#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
7202 p->anExec = 0;
7203#endif
7204#ifdef SQLITE_DEBUG
7205 /* Verify that second and subsequent executions of the same trigger do not
7206 ** try to reuse register values from the first use. */
7207 {
7208 int i;
7209 for(i=0; i<p->nMem; i++){
7210 aMem[i].pScopyFrom = 0; /* Prevent false-positive AboutToChange() errs */
7211 MemSetTypeFlag(&aMem[i], MEM_Undefined); /* Fault if this reg is reused */
7212 }
7213 }
7214#endif
7215 pOp = &aOp[-1];
7216 goto check_for_interrupt;
7217}
7218
7219/* Opcode: Param P1 P2 * * *
7220**
7221** This opcode is only ever present in sub-programs called via the
7222** OP_Program instruction. Copy a value currently stored in a memory
7223** cell of the calling (parent) frame to cell P2 in the current frames
7224** address space. This is used by trigger programs to access the new.*
7225** and old.* values.
7226**
7227** The address of the cell in the parent frame is determined by adding
7228** the value of the P1 argument to the value of the P1 argument to the
7229** calling OP_Program instruction.
7230*/
7231case OP_Param: { /* out2 */
7232 VdbeFrame *pFrame;
7233 Mem *pIn;
7234 pOut = out2Prerelease(p, pOp);
7235 pFrame = p->pFrame;
7236 pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];
7237 sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem);
7238 break;
7239}
7240
7241#endif /* #ifndef SQLITE_OMIT_TRIGGER */
7242
7243#ifndef SQLITE_OMIT_FOREIGN_KEY
7244/* Opcode: FkCounter P1 P2 * * *
7245** Synopsis: fkctr[P1]+=P2
7246**
7247** Increment a "constraint counter" by P2 (P2 may be negative or positive).
7248** If P1 is non-zero, the database constraint counter is incremented
7249** (deferred foreign key constraints). Otherwise, if P1 is zero, the
7250** statement counter is incremented (immediate foreign key constraints).
7251*/
7252case OP_FkCounter: {
7253 if( db->flags & SQLITE_DeferFKs ){
7254 db->nDeferredImmCons += pOp->p2;
7255 }else if( pOp->p1 ){
7256 db->nDeferredCons += pOp->p2;
7257 }else{
7258 p->nFkConstraint += pOp->p2;
7259 }
7260 break;
7261}
7262
7263/* Opcode: FkIfZero P1 P2 * * *
7264** Synopsis: if fkctr[P1]==0 goto P2
7265**
7266** This opcode tests if a foreign key constraint-counter is currently zero.
7267** If so, jump to instruction P2. Otherwise, fall through to the next
7268** instruction.
7269**
7270** If P1 is non-zero, then the jump is taken if the database constraint-counter
7271** is zero (the one that counts deferred constraint violations). If P1 is
7272** zero, the jump is taken if the statement constraint-counter is zero
7273** (immediate foreign key constraint violations).
7274*/
7275case OP_FkIfZero: { /* jump */
7276 if( pOp->p1 ){
7277 VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2);
7278 if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
7279 }else{
7280 VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2);
7281 if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
7282 }
7283 break;
7284}
7285#endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */
7286
7287#ifndef SQLITE_OMIT_AUTOINCREMENT
7288/* Opcode: MemMax P1 P2 * * *
7289** Synopsis: r[P1]=max(r[P1],r[P2])
7290**
7291** P1 is a register in the root frame of this VM (the root frame is
7292** different from the current frame if this instruction is being executed
7293** within a sub-program). Set the value of register P1 to the maximum of
7294** its current value and the value in register P2.
7295**
7296** This instruction throws an error if the memory cell is not initially
7297** an integer.
7298*/
7299case OP_MemMax: { /* in2 */
7300 VdbeFrame *pFrame;
7301 if( p->pFrame ){
7302 for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
7303 pIn1 = &pFrame->aMem[pOp->p1];
7304 }else{
7305 pIn1 = &aMem[pOp->p1];
7306 }
7307 assert( memIsValid(pIn1) );
7308 sqlite3VdbeMemIntegerify(pIn1);
7309 pIn2 = &aMem[pOp->p2];
7310 sqlite3VdbeMemIntegerify(pIn2);
7311 if( pIn1->u.i<pIn2->u.i){
7312 pIn1->u.i = pIn2->u.i;
7313 }
7314 break;
7315}
7316#endif /* SQLITE_OMIT_AUTOINCREMENT */
7317
7318/* Opcode: IfPos P1 P2 P3 * *
7319** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2
7320**
7321** Register P1 must contain an integer.
7322** If the value of register P1 is 1 or greater, subtract P3 from the
7323** value in P1 and jump to P2.
7324**
7325** If the initial value of register P1 is less than 1, then the
7326** value is unchanged and control passes through to the next instruction.
7327*/
7328case OP_IfPos: { /* jump, in1 */
7329 pIn1 = &aMem[pOp->p1];
7330 assert( pIn1->flags&MEM_Int );
7331 VdbeBranchTaken( pIn1->u.i>0, 2);
7332 if( pIn1->u.i>0 ){
7333 pIn1->u.i -= pOp->p3;
7334 goto jump_to_p2;
7335 }
7336 break;
7337}
7338
7339/* Opcode: OffsetLimit P1 P2 P3 * *
7340** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)
7341**
7342** This opcode performs a commonly used computation associated with
7343** LIMIT and OFFSET processing. r[P1] holds the limit counter. r[P3]
7344** holds the offset counter. The opcode computes the combined value
7345** of the LIMIT and OFFSET and stores that value in r[P2]. The r[P2]
7346** value computed is the total number of rows that will need to be
7347** visited in order to complete the query.
7348**
7349** If r[P3] is zero or negative, that means there is no OFFSET
7350** and r[P2] is set to be the value of the LIMIT, r[P1].
7351**
7352** if r[P1] is zero or negative, that means there is no LIMIT
7353** and r[P2] is set to -1.
7354**
7355** Otherwise, r[P2] is set to the sum of r[P1] and r[P3].
7356*/
7357case OP_OffsetLimit: { /* in1, out2, in3 */
7358 i64 x;
7359 pIn1 = &aMem[pOp->p1];
7360 pIn3 = &aMem[pOp->p3];
7361 pOut = out2Prerelease(p, pOp);
7362 assert( pIn1->flags & MEM_Int );
7363 assert( pIn3->flags & MEM_Int );
7364 x = pIn1->u.i;
7365 if( x<=0 || sqlite3AddInt64(&x, pIn3->u.i>0?pIn3->u.i:0) ){
7366 /* If the LIMIT is less than or equal to zero, loop forever. This
7367 ** is documented. But also, if the LIMIT+OFFSET exceeds 2^63 then
7368 ** also loop forever. This is undocumented. In fact, one could argue
7369 ** that the loop should terminate. But assuming 1 billion iterations
7370 ** per second (far exceeding the capabilities of any current hardware)
7371 ** it would take nearly 300 years to actually reach the limit. So
7372 ** looping forever is a reasonable approximation. */
7373 pOut->u.i = -1;
7374 }else{
7375 pOut->u.i = x;
7376 }
7377 break;
7378}
7379
7380/* Opcode: IfNotZero P1 P2 * * *
7381** Synopsis: if r[P1]!=0 then r[P1]--, goto P2
7382**
7383** Register P1 must contain an integer. If the content of register P1 is
7384** initially greater than zero, then decrement the value in register P1.
7385** If it is non-zero (negative or positive) and then also jump to P2.
7386** If register P1 is initially zero, leave it unchanged and fall through.
7387*/
7388case OP_IfNotZero: { /* jump, in1 */
7389 pIn1 = &aMem[pOp->p1];
7390 assert( pIn1->flags&MEM_Int );
7391 VdbeBranchTaken(pIn1->u.i<0, 2);
7392 if( pIn1->u.i ){
7393 if( pIn1->u.i>0 ) pIn1->u.i--;
7394 goto jump_to_p2;
7395 }
7396 break;
7397}
7398
7399/* Opcode: DecrJumpZero P1 P2 * * *
7400** Synopsis: if (--r[P1])==0 goto P2
7401**
7402** Register P1 must hold an integer. Decrement the value in P1
7403** and jump to P2 if the new value is exactly zero.
7404*/
7405case OP_DecrJumpZero: { /* jump, in1 */
7406 pIn1 = &aMem[pOp->p1];
7407 assert( pIn1->flags&MEM_Int );
7408 if( pIn1->u.i>SMALLEST_INT64 ) pIn1->u.i--;
7409 VdbeBranchTaken(pIn1->u.i==0, 2);
7410 if( pIn1->u.i==0 ) goto jump_to_p2;
7411 break;
7412}
7413
7414
7415/* Opcode: AggStep * P2 P3 P4 P5
7416** Synopsis: accum=r[P3] step(r[P2@P5])
7417**
7418** Execute the xStep function for an aggregate.
7419** The function has P5 arguments. P4 is a pointer to the
7420** FuncDef structure that specifies the function. Register P3 is the
7421** accumulator.
7422**
7423** The P5 arguments are taken from register P2 and its
7424** successors.
7425*/
7426/* Opcode: AggInverse * P2 P3 P4 P5
7427** Synopsis: accum=r[P3] inverse(r[P2@P5])
7428**
7429** Execute the xInverse function for an aggregate.
7430** The function has P5 arguments. P4 is a pointer to the
7431** FuncDef structure that specifies the function. Register P3 is the
7432** accumulator.
7433**
7434** The P5 arguments are taken from register P2 and its
7435** successors.
7436*/
7437/* Opcode: AggStep1 P1 P2 P3 P4 P5
7438** Synopsis: accum=r[P3] step(r[P2@P5])
7439**
7440** Execute the xStep (if P1==0) or xInverse (if P1!=0) function for an
7441** aggregate. The function has P5 arguments. P4 is a pointer to the
7442** FuncDef structure that specifies the function. Register P3 is the
7443** accumulator.
7444**
7445** The P5 arguments are taken from register P2 and its
7446** successors.
7447**
7448** This opcode is initially coded as OP_AggStep0. On first evaluation,
7449** the FuncDef stored in P4 is converted into an sqlite3_context and
7450** the opcode is changed. In this way, the initialization of the
7451** sqlite3_context only happens once, instead of on each call to the
7452** step function.
7453*/
7454case OP_AggInverse:
7455case OP_AggStep: {
7456 int n;
7457 sqlite3_context *pCtx;
7458
7459 assert( pOp->p4type==P4_FUNCDEF );
7460 n = pOp->p5;
7461 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
7462 assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
7463 assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
7464 pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) +
7465 (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*)));
7466 if( pCtx==0 ) goto no_mem;
7467 pCtx->pMem = 0;
7468 pCtx->pOut = (Mem*)&(pCtx->argv[n]);
7469 sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
7470 pCtx->pFunc = pOp->p4.pFunc;
7471 pCtx->iOp = (int)(pOp - aOp);
7472 pCtx->pVdbe = p;
7473 pCtx->skipFlag = 0;
7474 pCtx->isError = 0;
7475 pCtx->enc = encoding;
7476 pCtx->argc = n;
7477 pOp->p4type = P4_FUNCCTX;
7478 pOp->p4.pCtx = pCtx;
7479
7480 /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */
7481 assert( pOp->p1==(pOp->opcode==OP_AggInverse) );
7482
7483 pOp->opcode = OP_AggStep1;
7484 /* Fall through into OP_AggStep */
7485 /* no break */ deliberate_fall_through
7486}
7487case OP_AggStep1: {
7488 int i;
7489 sqlite3_context *pCtx;
7490 Mem *pMem;
7491
7492 assert( pOp->p4type==P4_FUNCCTX );
7493 pCtx = pOp->p4.pCtx;
7494 pMem = &aMem[pOp->p3];
7495
7496#ifdef SQLITE_DEBUG
7497 if( pOp->p1 ){
7498 /* This is an OP_AggInverse call. Verify that xStep has always
7499 ** been called at least once prior to any xInverse call. */
7500 assert( pMem->uTemp==0x1122e0e3 );
7501 }else{
7502 /* This is an OP_AggStep call. Mark it as such. */
7503 pMem->uTemp = 0x1122e0e3;
7504 }
7505#endif
7506
7507 /* If this function is inside of a trigger, the register array in aMem[]
7508 ** might change from one evaluation to the next. The next block of code
7509 ** checks to see if the register array has changed, and if so it
7510 ** reinitializes the relavant parts of the sqlite3_context object */
7511 if( pCtx->pMem != pMem ){
7512 pCtx->pMem = pMem;
7513 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
7514 }
7515
7516#ifdef SQLITE_DEBUG
7517 for(i=0; i<pCtx->argc; i++){
7518 assert( memIsValid(pCtx->argv[i]) );
7519 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
7520 }
7521#endif
7522
7523 pMem->n++;
7524 assert( pCtx->pOut->flags==MEM_Null );
7525 assert( pCtx->isError==0 );
7526 assert( pCtx->skipFlag==0 );
7527#ifndef SQLITE_OMIT_WINDOWFUNC
7528 if( pOp->p1 ){
7529 (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv);
7530 }else
7531#endif
7532 (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
7533
7534 if( pCtx->isError ){
7535 if( pCtx->isError>0 ){
7536 sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
7537 rc = pCtx->isError;
7538 }
7539 if( pCtx->skipFlag ){
7540 assert( pOp[-1].opcode==OP_CollSeq );
7541 i = pOp[-1].p1;
7542 if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1);
7543 pCtx->skipFlag = 0;
7544 }
7545 sqlite3VdbeMemRelease(pCtx->pOut);
7546 pCtx->pOut->flags = MEM_Null;
7547 pCtx->isError = 0;
7548 if( rc ) goto abort_due_to_error;
7549 }
7550 assert( pCtx->pOut->flags==MEM_Null );
7551 assert( pCtx->skipFlag==0 );
7552 break;
7553}
7554
7555/* Opcode: AggFinal P1 P2 * P4 *
7556** Synopsis: accum=r[P1] N=P2
7557**
7558** P1 is the memory location that is the accumulator for an aggregate
7559** or window function. Execute the finalizer function
7560** for an aggregate and store the result in P1.
7561**
7562** P2 is the number of arguments that the step function takes and
7563** P4 is a pointer to the FuncDef for this function. The P2
7564** argument is not used by this opcode. It is only there to disambiguate
7565** functions that can take varying numbers of arguments. The
7566** P4 argument is only needed for the case where
7567** the step function was not previously called.
7568*/
7569/* Opcode: AggValue * P2 P3 P4 *
7570** Synopsis: r[P3]=value N=P2
7571**
7572** Invoke the xValue() function and store the result in register P3.
7573**
7574** P2 is the number of arguments that the step function takes and
7575** P4 is a pointer to the FuncDef for this function. The P2
7576** argument is not used by this opcode. It is only there to disambiguate
7577** functions that can take varying numbers of arguments. The
7578** P4 argument is only needed for the case where
7579** the step function was not previously called.
7580*/
7581case OP_AggValue:
7582case OP_AggFinal: {
7583 Mem *pMem;
7584 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
7585 assert( pOp->p3==0 || pOp->opcode==OP_AggValue );
7586 pMem = &aMem[pOp->p1];
7587 assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
7588#ifndef SQLITE_OMIT_WINDOWFUNC
7589 if( pOp->p3 ){
7590 memAboutToChange(p, &aMem[pOp->p3]);
7591 rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc);
7592 pMem = &aMem[pOp->p3];
7593 }else
7594#endif
7595 {
7596 rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
7597 }
7598
7599 if( rc ){
7600 sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem));
7601 goto abort_due_to_error;
7602 }
7603 sqlite3VdbeChangeEncoding(pMem, encoding);
7604 UPDATE_MAX_BLOBSIZE(pMem);
7605 break;
7606}
7607
7608#ifndef SQLITE_OMIT_WAL
7609/* Opcode: Checkpoint P1 P2 P3 * *
7610**
7611** Checkpoint database P1. This is a no-op if P1 is not currently in
7612** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL,
7613** RESTART, or TRUNCATE. Write 1 or 0 into mem[P3] if the checkpoint returns
7614** SQLITE_BUSY or not, respectively. Write the number of pages in the
7615** WAL after the checkpoint into mem[P3+1] and the number of pages
7616** in the WAL that have been checkpointed after the checkpoint
7617** completes into mem[P3+2]. However on an error, mem[P3+1] and
7618** mem[P3+2] are initialized to -1.
7619*/
7620case OP_Checkpoint: {
7621 int i; /* Loop counter */
7622 int aRes[3]; /* Results */
7623 Mem *pMem; /* Write results here */
7624
7625 assert( p->readOnly==0 );
7626 aRes[0] = 0;
7627 aRes[1] = aRes[2] = -1;
7628 assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
7629 || pOp->p2==SQLITE_CHECKPOINT_FULL
7630 || pOp->p2==SQLITE_CHECKPOINT_RESTART
7631 || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE
7632 );
7633 rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
7634 if( rc ){
7635 if( rc!=SQLITE_BUSY ) goto abort_due_to_error;
7636 rc = SQLITE_OK;
7637 aRes[0] = 1;
7638 }
7639 for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){
7640 sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]);
7641 }
7642 break;
7643};
7644#endif
7645
7646#ifndef SQLITE_OMIT_PRAGMA
7647/* Opcode: JournalMode P1 P2 P3 * *
7648**
7649** Change the journal mode of database P1 to P3. P3 must be one of the
7650** PAGER_JOURNALMODE_XXX values. If changing between the various rollback
7651** modes (delete, truncate, persist, off and memory), this is a simple
7652** operation. No IO is required.
7653**
7654** If changing into or out of WAL mode the procedure is more complicated.
7655**
7656** Write a string containing the final journal-mode to register P2.
7657*/
7658case OP_JournalMode: { /* out2 */
7659 Btree *pBt; /* Btree to change journal mode of */
7660 Pager *pPager; /* Pager associated with pBt */
7661 int eNew; /* New journal mode */
7662 int eOld; /* The old journal mode */
7663#ifndef SQLITE_OMIT_WAL
7664 const char *zFilename; /* Name of database file for pPager */
7665#endif
7666
7667 pOut = out2Prerelease(p, pOp);
7668 eNew = pOp->p3;
7669 assert( eNew==PAGER_JOURNALMODE_DELETE
7670 || eNew==PAGER_JOURNALMODE_TRUNCATE
7671 || eNew==PAGER_JOURNALMODE_PERSIST
7672 || eNew==PAGER_JOURNALMODE_OFF
7673 || eNew==PAGER_JOURNALMODE_MEMORY
7674 || eNew==PAGER_JOURNALMODE_WAL
7675 || eNew==PAGER_JOURNALMODE_QUERY
7676 );
7677 assert( pOp->p1>=0 && pOp->p1<db->nDb );
7678 assert( p->readOnly==0 );
7679
7680 pBt = db->aDb[pOp->p1].pBt;
7681 pPager = sqlite3BtreePager(pBt);
7682 eOld = sqlite3PagerGetJournalMode(pPager);
7683 if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;
7684 assert( sqlite3BtreeHoldsMutex(pBt) );
7685 if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
7686
7687#ifndef SQLITE_OMIT_WAL
7688 zFilename = sqlite3PagerFilename(pPager, 1);
7689
7690 /* Do not allow a transition to journal_mode=WAL for a database
7691 ** in temporary storage or if the VFS does not support shared memory
7692 */
7693 if( eNew==PAGER_JOURNALMODE_WAL
7694 && (sqlite3Strlen30(zFilename)==0 /* Temp file */
7695 || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */
7696 ){
7697 eNew = eOld;
7698 }
7699
7700 if( (eNew!=eOld)
7701 && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL)
7702 ){
7703 if( !db->autoCommit || db->nVdbeRead>1 ){
7704 rc = SQLITE_ERROR;
7705 sqlite3VdbeError(p,
7706 "cannot change %s wal mode from within a transaction",
7707 (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
7708 );
7709 goto abort_due_to_error;
7710 }else{
7711
7712 if( eOld==PAGER_JOURNALMODE_WAL ){
7713 /* If leaving WAL mode, close the log file. If successful, the call
7714 ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
7715 ** file. An EXCLUSIVE lock may still be held on the database file
7716 ** after a successful return.
7717 */
7718 rc = sqlite3PagerCloseWal(pPager, db);
7719 if( rc==SQLITE_OK ){
7720 sqlite3PagerSetJournalMode(pPager, eNew);
7721 }
7722 }else if( eOld==PAGER_JOURNALMODE_MEMORY ){
7723 /* Cannot transition directly from MEMORY to WAL. Use mode OFF
7724 ** as an intermediate */
7725 sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF);
7726 }
7727
7728 /* Open a transaction on the database file. Regardless of the journal
7729 ** mode, this transaction always uses a rollback journal.
7730 */
7731 assert( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_WRITE );
7732 if( rc==SQLITE_OK ){
7733 rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
7734 }
7735 }
7736 }
7737#endif /* ifndef SQLITE_OMIT_WAL */
7738
7739 if( rc ) eNew = eOld;
7740 eNew = sqlite3PagerSetJournalMode(pPager, eNew);
7741
7742 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
7743 pOut->z = (char *)sqlite3JournalModename(eNew);
7744 pOut->n = sqlite3Strlen30(pOut->z);
7745 pOut->enc = SQLITE_UTF8;
7746 sqlite3VdbeChangeEncoding(pOut, encoding);
7747 if( rc ) goto abort_due_to_error;
7748 break;
7749};
7750#endif /* SQLITE_OMIT_PRAGMA */
7751
7752#if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
7753/* Opcode: Vacuum P1 P2 * * *
7754**
7755** Vacuum the entire database P1. P1 is 0 for "main", and 2 or more
7756** for an attached database. The "temp" database may not be vacuumed.
7757**
7758** If P2 is not zero, then it is a register holding a string which is
7759** the file into which the result of vacuum should be written. When
7760** P2 is zero, the vacuum overwrites the original database.
7761*/
7762case OP_Vacuum: {
7763 assert( p->readOnly==0 );
7764 rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1,
7765 pOp->p2 ? &aMem[pOp->p2] : 0);
7766 if( rc ) goto abort_due_to_error;
7767 break;
7768}
7769#endif
7770
7771#if !defined(SQLITE_OMIT_AUTOVACUUM)
7772/* Opcode: IncrVacuum P1 P2 * * *
7773**
7774** Perform a single step of the incremental vacuum procedure on
7775** the P1 database. If the vacuum has finished, jump to instruction
7776** P2. Otherwise, fall through to the next instruction.
7777*/
7778case OP_IncrVacuum: { /* jump */
7779 Btree *pBt;
7780
7781 assert( pOp->p1>=0 && pOp->p1<db->nDb );
7782 assert( DbMaskTest(p->btreeMask, pOp->p1) );
7783 assert( p->readOnly==0 );
7784 pBt = db->aDb[pOp->p1].pBt;
7785 rc = sqlite3BtreeIncrVacuum(pBt);
7786 VdbeBranchTaken(rc==SQLITE_DONE,2);
7787 if( rc ){
7788 if( rc!=SQLITE_DONE ) goto abort_due_to_error;
7789 rc = SQLITE_OK;
7790 goto jump_to_p2;
7791 }
7792 break;
7793}
7794#endif
7795
7796/* Opcode: Expire P1 P2 * * *
7797**
7798** Cause precompiled statements to expire. When an expired statement
7799** is executed using sqlite3_step() it will either automatically
7800** reprepare itself (if it was originally created using sqlite3_prepare_v2())
7801** or it will fail with SQLITE_SCHEMA.
7802**
7803** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
7804** then only the currently executing statement is expired.
7805**
7806** If P2 is 0, then SQL statements are expired immediately. If P2 is 1,
7807** then running SQL statements are allowed to continue to run to completion.
7808** The P2==1 case occurs when a CREATE INDEX or similar schema change happens
7809** that might help the statement run faster but which does not affect the
7810** correctness of operation.
7811*/
7812case OP_Expire: {
7813 assert( pOp->p2==0 || pOp->p2==1 );
7814 if( !pOp->p1 ){
7815 sqlite3ExpirePreparedStatements(db, pOp->p2);
7816 }else{
7817 p->expired = pOp->p2+1;
7818 }
7819 break;
7820}
7821
7822/* Opcode: CursorLock P1 * * * *
7823**
7824** Lock the btree to which cursor P1 is pointing so that the btree cannot be
7825** written by an other cursor.
7826*/
7827case OP_CursorLock: {
7828 VdbeCursor *pC;
7829 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
7830 pC = p->apCsr[pOp->p1];
7831 assert( pC!=0 );
7832 assert( pC->eCurType==CURTYPE_BTREE );
7833 sqlite3BtreeCursorPin(pC->uc.pCursor);
7834 break;
7835}
7836
7837/* Opcode: CursorUnlock P1 * * * *
7838**
7839** Unlock the btree to which cursor P1 is pointing so that it can be
7840** written by other cursors.
7841*/
7842case OP_CursorUnlock: {
7843 VdbeCursor *pC;
7844 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
7845 pC = p->apCsr[pOp->p1];
7846 assert( pC!=0 );
7847 assert( pC->eCurType==CURTYPE_BTREE );
7848 sqlite3BtreeCursorUnpin(pC->uc.pCursor);
7849 break;
7850}
7851
7852#ifndef SQLITE_OMIT_SHARED_CACHE
7853/* Opcode: TableLock P1 P2 P3 P4 *
7854** Synopsis: iDb=P1 root=P2 write=P3
7855**
7856** Obtain a lock on a particular table. This instruction is only used when
7857** the shared-cache feature is enabled.
7858**
7859** P1 is the index of the database in sqlite3.aDb[] of the database
7860** on which the lock is acquired. A readlock is obtained if P3==0 or
7861** a write lock if P3==1.
7862**
7863** P2 contains the root-page of the table to lock.
7864**
7865** P4 contains a pointer to the name of the table being locked. This is only
7866** used to generate an error message if the lock cannot be obtained.
7867*/
7868case OP_TableLock: {
7869 u8 isWriteLock = (u8)pOp->p3;
7870 if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){
7871 int p1 = pOp->p1;
7872 assert( p1>=0 && p1<db->nDb );
7873 assert( DbMaskTest(p->btreeMask, p1) );
7874 assert( isWriteLock==0 || isWriteLock==1 );
7875 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
7876 if( rc ){
7877 if( (rc&0xFF)==SQLITE_LOCKED ){
7878 const char *z = pOp->p4.z;
7879 sqlite3VdbeError(p, "database table is locked: %s", z);
7880 }
7881 goto abort_due_to_error;
7882 }
7883 }
7884 break;
7885}
7886#endif /* SQLITE_OMIT_SHARED_CACHE */
7887
7888#ifndef SQLITE_OMIT_VIRTUALTABLE
7889/* Opcode: VBegin * * * P4 *
7890**
7891** P4 may be a pointer to an sqlite3_vtab structure. If so, call the
7892** xBegin method for that table.
7893**
7894** Also, whether or not P4 is set, check that this is not being called from
7895** within a callback to a virtual table xSync() method. If it is, the error
7896** code will be set to SQLITE_LOCKED.
7897*/
7898case OP_VBegin: {
7899 VTable *pVTab;
7900 pVTab = pOp->p4.pVtab;
7901 rc = sqlite3VtabBegin(db, pVTab);
7902 if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab);
7903 if( rc ) goto abort_due_to_error;
7904 break;
7905}
7906#endif /* SQLITE_OMIT_VIRTUALTABLE */
7907
7908#ifndef SQLITE_OMIT_VIRTUALTABLE
7909/* Opcode: VCreate P1 P2 * * *
7910**
7911** P2 is a register that holds the name of a virtual table in database
7912** P1. Call the xCreate method for that table.
7913*/
7914case OP_VCreate: {
7915 Mem sMem; /* For storing the record being decoded */
7916 const char *zTab; /* Name of the virtual table */
7917
7918 memset(&sMem, 0, sizeof(sMem));
7919 sMem.db = db;
7920 /* Because P2 is always a static string, it is impossible for the
7921 ** sqlite3VdbeMemCopy() to fail */
7922 assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
7923 assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
7924 rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]);
7925 assert( rc==SQLITE_OK );
7926 zTab = (const char*)sqlite3_value_text(&sMem);
7927 assert( zTab || db->mallocFailed );
7928 if( zTab ){
7929 rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg);
7930 }
7931 sqlite3VdbeMemRelease(&sMem);
7932 if( rc ) goto abort_due_to_error;
7933 break;
7934}
7935#endif /* SQLITE_OMIT_VIRTUALTABLE */
7936
7937#ifndef SQLITE_OMIT_VIRTUALTABLE
7938/* Opcode: VDestroy P1 * * P4 *
7939**
7940** P4 is the name of a virtual table in database P1. Call the xDestroy method
7941** of that table.
7942*/
7943case OP_VDestroy: {
7944 db->nVDestroy++;
7945 rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
7946 db->nVDestroy--;
7947 assert( p->errorAction==OE_Abort && p->usesStmtJournal );
7948 if( rc ) goto abort_due_to_error;
7949 break;
7950}
7951#endif /* SQLITE_OMIT_VIRTUALTABLE */
7952
7953#ifndef SQLITE_OMIT_VIRTUALTABLE
7954/* Opcode: VOpen P1 * * P4 *
7955**
7956** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
7957** P1 is a cursor number. This opcode opens a cursor to the virtual
7958** table and stores that cursor in P1.
7959*/
7960case OP_VOpen: {
7961 VdbeCursor *pCur;
7962 sqlite3_vtab_cursor *pVCur;
7963 sqlite3_vtab *pVtab;
7964 const sqlite3_module *pModule;
7965
7966 assert( p->bIsReader );
7967 pCur = 0;
7968 pVCur = 0;
7969 pVtab = pOp->p4.pVtab->pVtab;
7970 if( pVtab==0 || NEVER(pVtab->pModule==0) ){
7971 rc = SQLITE_LOCKED;
7972 goto abort_due_to_error;
7973 }
7974 pModule = pVtab->pModule;
7975 rc = pModule->xOpen(pVtab, &pVCur);
7976 sqlite3VtabImportErrmsg(p, pVtab);
7977 if( rc ) goto abort_due_to_error;
7978
7979 /* Initialize sqlite3_vtab_cursor base class */
7980 pVCur->pVtab = pVtab;
7981
7982 /* Initialize vdbe cursor object */
7983 pCur = allocateCursor(p, pOp->p1, 0, CURTYPE_VTAB);
7984 if( pCur ){
7985 pCur->uc.pVCur = pVCur;
7986 pVtab->nRef++;
7987 }else{
7988 assert( db->mallocFailed );
7989 pModule->xClose(pVCur);
7990 goto no_mem;
7991 }
7992 break;
7993}
7994#endif /* SQLITE_OMIT_VIRTUALTABLE */
7995
7996#ifndef SQLITE_OMIT_VIRTUALTABLE
7997/* Opcode: VInitIn P1 P2 P3 * *
7998** Synopsis: r[P2]=ValueList(P1,P3)
7999**
8000** Set register P2 to be a pointer to a ValueList object for cursor P1
8001** with cache register P3 and output register P3+1. This ValueList object
8002** can be used as the first argument to sqlite3_vtab_in_first() and
8003** sqlite3_vtab_in_next() to extract all of the values stored in the P1
8004** cursor. Register P3 is used to hold the values returned by
8005** sqlite3_vtab_in_first() and sqlite3_vtab_in_next().
8006*/
8007case OP_VInitIn: { /* out2 */
8008 VdbeCursor *pC; /* The cursor containing the RHS values */
8009 ValueList *pRhs; /* New ValueList object to put in reg[P2] */
8010
8011 pC = p->apCsr[pOp->p1];
8012 pRhs = sqlite3_malloc64( sizeof(*pRhs) );
8013 if( pRhs==0 ) goto no_mem;
8014 pRhs->pCsr = pC->uc.pCursor;
8015 pRhs->pOut = &aMem[pOp->p3];
8016 pOut = out2Prerelease(p, pOp);
8017 pOut->flags = MEM_Null;
8018 sqlite3VdbeMemSetPointer(pOut, pRhs, "ValueList", sqlite3_free);
8019 break;
8020}
8021#endif /* SQLITE_OMIT_VIRTUALTABLE */
8022
8023
8024#ifndef SQLITE_OMIT_VIRTUALTABLE
8025/* Opcode: VFilter P1 P2 P3 P4 *
8026** Synopsis: iplan=r[P3] zplan='P4'
8027**
8028** P1 is a cursor opened using VOpen. P2 is an address to jump to if
8029** the filtered result set is empty.
8030**
8031** P4 is either NULL or a string that was generated by the xBestIndex
8032** method of the module. The interpretation of the P4 string is left
8033** to the module implementation.
8034**
8035** This opcode invokes the xFilter method on the virtual table specified
8036** by P1. The integer query plan parameter to xFilter is stored in register
8037** P3. Register P3+1 stores the argc parameter to be passed to the
8038** xFilter method. Registers P3+2..P3+1+argc are the argc
8039** additional parameters which are passed to
8040** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
8041**
8042** A jump is made to P2 if the result set after filtering would be empty.
8043*/
8044case OP_VFilter: { /* jump */
8045 int nArg;
8046 int iQuery;
8047 const sqlite3_module *pModule;
8048 Mem *pQuery;
8049 Mem *pArgc;
8050 sqlite3_vtab_cursor *pVCur;
8051 sqlite3_vtab *pVtab;
8052 VdbeCursor *pCur;
8053 int res;
8054 int i;
8055 Mem **apArg;
8056
8057 pQuery = &aMem[pOp->p3];
8058 pArgc = &pQuery[1];
8059 pCur = p->apCsr[pOp->p1];
8060 assert( memIsValid(pQuery) );
8061 REGISTER_TRACE(pOp->p3, pQuery);
8062 assert( pCur!=0 );
8063 assert( pCur->eCurType==CURTYPE_VTAB );
8064 pVCur = pCur->uc.pVCur;
8065 pVtab = pVCur->pVtab;
8066 pModule = pVtab->pModule;
8067
8068 /* Grab the index number and argc parameters */
8069 assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
8070 nArg = (int)pArgc->u.i;
8071 iQuery = (int)pQuery->u.i;
8072
8073 /* Invoke the xFilter method */
8074 apArg = p->apArg;
8075 for(i = 0; i<nArg; i++){
8076 apArg[i] = &pArgc[i+1];
8077 }
8078 rc = pModule->xFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg);
8079 sqlite3VtabImportErrmsg(p, pVtab);
8080 if( rc ) goto abort_due_to_error;
8081 res = pModule->xEof(pVCur);
8082 pCur->nullRow = 0;
8083 VdbeBranchTaken(res!=0,2);
8084 if( res ) goto jump_to_p2;
8085 break;
8086}
8087#endif /* SQLITE_OMIT_VIRTUALTABLE */
8088
8089#ifndef SQLITE_OMIT_VIRTUALTABLE
8090/* Opcode: VColumn P1 P2 P3 * P5
8091** Synopsis: r[P3]=vcolumn(P2)
8092**
8093** Store in register P3 the value of the P2-th column of
8094** the current row of the virtual-table of cursor P1.
8095**
8096** If the VColumn opcode is being used to fetch the value of
8097** an unchanging column during an UPDATE operation, then the P5
8098** value is OPFLAG_NOCHNG. This will cause the sqlite3_vtab_nochange()
8099** function to return true inside the xColumn method of the virtual
8100** table implementation. The P5 column might also contain other
8101** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are
8102** unused by OP_VColumn.
8103*/
8104case OP_VColumn: {
8105 sqlite3_vtab *pVtab;
8106 const sqlite3_module *pModule;
8107 Mem *pDest;
8108 sqlite3_context sContext;
8109
8110 VdbeCursor *pCur = p->apCsr[pOp->p1];
8111 assert( pCur!=0 );
8112 assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
8113 pDest = &aMem[pOp->p3];
8114 memAboutToChange(p, pDest);
8115 if( pCur->nullRow ){
8116 sqlite3VdbeMemSetNull(pDest);
8117 break;
8118 }
8119 assert( pCur->eCurType==CURTYPE_VTAB );
8120 pVtab = pCur->uc.pVCur->pVtab;
8121 pModule = pVtab->pModule;
8122 assert( pModule->xColumn );
8123 memset(&sContext, 0, sizeof(sContext));
8124 sContext.pOut = pDest;
8125 sContext.enc = encoding;
8126 assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 );
8127 if( pOp->p5 & OPFLAG_NOCHNG ){
8128 sqlite3VdbeMemSetNull(pDest);
8129 pDest->flags = MEM_Null|MEM_Zero;
8130 pDest->u.nZero = 0;
8131 }else{
8132 MemSetTypeFlag(pDest, MEM_Null);
8133 }
8134 rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
8135 sqlite3VtabImportErrmsg(p, pVtab);
8136 if( sContext.isError>0 ){
8137 sqlite3VdbeError(p, "%s", sqlite3_value_text(pDest));
8138 rc = sContext.isError;
8139 }
8140 sqlite3VdbeChangeEncoding(pDest, encoding);
8141 REGISTER_TRACE(pOp->p3, pDest);
8142 UPDATE_MAX_BLOBSIZE(pDest);
8143
8144 if( rc ) goto abort_due_to_error;
8145 break;
8146}
8147#endif /* SQLITE_OMIT_VIRTUALTABLE */
8148
8149#ifndef SQLITE_OMIT_VIRTUALTABLE
8150/* Opcode: VNext P1 P2 * * *
8151**
8152** Advance virtual table P1 to the next row in its result set and
8153** jump to instruction P2. Or, if the virtual table has reached
8154** the end of its result set, then fall through to the next instruction.
8155*/
8156case OP_VNext: { /* jump */
8157 sqlite3_vtab *pVtab;
8158 const sqlite3_module *pModule;
8159 int res;
8160 VdbeCursor *pCur;
8161
8162 pCur = p->apCsr[pOp->p1];
8163 assert( pCur!=0 );
8164 assert( pCur->eCurType==CURTYPE_VTAB );
8165 if( pCur->nullRow ){
8166 break;
8167 }
8168 pVtab = pCur->uc.pVCur->pVtab;
8169 pModule = pVtab->pModule;
8170 assert( pModule->xNext );
8171
8172 /* Invoke the xNext() method of the module. There is no way for the
8173 ** underlying implementation to return an error if one occurs during
8174 ** xNext(). Instead, if an error occurs, true is returned (indicating that
8175 ** data is available) and the error code returned when xColumn or
8176 ** some other method is next invoked on the save virtual table cursor.
8177 */
8178 rc = pModule->xNext(pCur->uc.pVCur);
8179 sqlite3VtabImportErrmsg(p, pVtab);
8180 if( rc ) goto abort_due_to_error;
8181 res = pModule->xEof(pCur->uc.pVCur);
8182 VdbeBranchTaken(!res,2);
8183 if( !res ){
8184 /* If there is data, jump to P2 */
8185 goto jump_to_p2_and_check_for_interrupt;
8186 }
8187 goto check_for_interrupt;
8188}
8189#endif /* SQLITE_OMIT_VIRTUALTABLE */
8190
8191#ifndef SQLITE_OMIT_VIRTUALTABLE
8192/* Opcode: VRename P1 * * P4 *
8193**
8194** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
8195** This opcode invokes the corresponding xRename method. The value
8196** in register P1 is passed as the zName argument to the xRename method.
8197*/
8198case OP_VRename: {
8199 sqlite3_vtab *pVtab;
8200 Mem *pName;
8201 int isLegacy;
8202
8203 isLegacy = (db->flags & SQLITE_LegacyAlter);
8204 db->flags |= SQLITE_LegacyAlter;
8205 pVtab = pOp->p4.pVtab->pVtab;
8206 pName = &aMem[pOp->p1];
8207 assert( pVtab->pModule->xRename );
8208 assert( memIsValid(pName) );
8209 assert( p->readOnly==0 );
8210 REGISTER_TRACE(pOp->p1, pName);
8211 assert( pName->flags & MEM_Str );
8212 testcase( pName->enc==SQLITE_UTF8 );
8213 testcase( pName->enc==SQLITE_UTF16BE );
8214 testcase( pName->enc==SQLITE_UTF16LE );
8215 rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8);
8216 if( rc ) goto abort_due_to_error;
8217 rc = pVtab->pModule->xRename(pVtab, pName->z);
8218 if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter;
8219 sqlite3VtabImportErrmsg(p, pVtab);
8220 p->expired = 0;
8221 if( rc ) goto abort_due_to_error;
8222 break;
8223}
8224#endif
8225
8226#ifndef SQLITE_OMIT_VIRTUALTABLE
8227/* Opcode: VUpdate P1 P2 P3 P4 P5
8228** Synopsis: data=r[P3@P2]
8229**
8230** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
8231** This opcode invokes the corresponding xUpdate method. P2 values
8232** are contiguous memory cells starting at P3 to pass to the xUpdate
8233** invocation. The value in register (P3+P2-1) corresponds to the
8234** p2th element of the argv array passed to xUpdate.
8235**
8236** The xUpdate method will do a DELETE or an INSERT or both.
8237** The argv[0] element (which corresponds to memory cell P3)
8238** is the rowid of a row to delete. If argv[0] is NULL then no
8239** deletion occurs. The argv[1] element is the rowid of the new
8240** row. This can be NULL to have the virtual table select the new
8241** rowid for itself. The subsequent elements in the array are
8242** the values of columns in the new row.
8243**
8244** If P2==1 then no insert is performed. argv[0] is the rowid of
8245** a row to delete.
8246**
8247** P1 is a boolean flag. If it is set to true and the xUpdate call
8248** is successful, then the value returned by sqlite3_last_insert_rowid()
8249** is set to the value of the rowid for the row just inserted.
8250**
8251** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to
8252** apply in the case of a constraint failure on an insert or update.
8253*/
8254case OP_VUpdate: {
8255 sqlite3_vtab *pVtab;
8256 const sqlite3_module *pModule;
8257 int nArg;
8258 int i;
8259 sqlite_int64 rowid = 0;
8260 Mem **apArg;
8261 Mem *pX;
8262
8263 assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
8264 || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
8265 );
8266 assert( p->readOnly==0 );
8267 if( db->mallocFailed ) goto no_mem;
8268 sqlite3VdbeIncrWriteCounter(p, 0);
8269 pVtab = pOp->p4.pVtab->pVtab;
8270 if( pVtab==0 || NEVER(pVtab->pModule==0) ){
8271 rc = SQLITE_LOCKED;
8272 goto abort_due_to_error;
8273 }
8274 pModule = pVtab->pModule;
8275 nArg = pOp->p2;
8276 assert( pOp->p4type==P4_VTAB );
8277 if( ALWAYS(pModule->xUpdate) ){
8278 u8 vtabOnConflict = db->vtabOnConflict;
8279 apArg = p->apArg;
8280 pX = &aMem[pOp->p3];
8281 for(i=0; i<nArg; i++){
8282 assert( memIsValid(pX) );
8283 memAboutToChange(p, pX);
8284 apArg[i] = pX;
8285 pX++;
8286 }
8287 db->vtabOnConflict = pOp->p5;
8288 rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
8289 db->vtabOnConflict = vtabOnConflict;
8290 sqlite3VtabImportErrmsg(p, pVtab);
8291 if( rc==SQLITE_OK && pOp->p1 ){
8292 assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
8293 db->lastRowid = rowid;
8294 }
8295 if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
8296 if( pOp->p5==OE_Ignore ){
8297 rc = SQLITE_OK;
8298 }else{
8299 p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
8300 }
8301 }else{
8302 p->nChange++;
8303 }
8304 if( rc ) goto abort_due_to_error;
8305 }
8306 break;
8307}
8308#endif /* SQLITE_OMIT_VIRTUALTABLE */
8309
8310#ifndef SQLITE_OMIT_PAGER_PRAGMAS
8311/* Opcode: Pagecount P1 P2 * * *
8312**
8313** Write the current number of pages in database P1 to memory cell P2.
8314*/
8315case OP_Pagecount: { /* out2 */
8316 pOut = out2Prerelease(p, pOp);
8317 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
8318 break;
8319}
8320#endif
8321
8322
8323#ifndef SQLITE_OMIT_PAGER_PRAGMAS
8324/* Opcode: MaxPgcnt P1 P2 P3 * *
8325**
8326** Try to set the maximum page count for database P1 to the value in P3.
8327** Do not let the maximum page count fall below the current page count and
8328** do not change the maximum page count value if P3==0.
8329**
8330** Store the maximum page count after the change in register P2.
8331*/
8332case OP_MaxPgcnt: { /* out2 */
8333 unsigned int newMax;
8334 Btree *pBt;
8335
8336 pOut = out2Prerelease(p, pOp);
8337 pBt = db->aDb[pOp->p1].pBt;
8338 newMax = 0;
8339 if( pOp->p3 ){
8340 newMax = sqlite3BtreeLastPage(pBt);
8341 if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3;
8342 }
8343 pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
8344 break;
8345}
8346#endif
8347
8348/* Opcode: Function P1 P2 P3 P4 *
8349** Synopsis: r[P3]=func(r[P2@NP])
8350**
8351** Invoke a user function (P4 is a pointer to an sqlite3_context object that
8352** contains a pointer to the function to be run) with arguments taken
8353** from register P2 and successors. The number of arguments is in
8354** the sqlite3_context object that P4 points to.
8355** The result of the function is stored
8356** in register P3. Register P3 must not be one of the function inputs.
8357**
8358** P1 is a 32-bit bitmask indicating whether or not each argument to the
8359** function was determined to be constant at compile time. If the first
8360** argument was constant then bit 0 of P1 is set. This is used to determine
8361** whether meta data associated with a user function argument using the
8362** sqlite3_set_auxdata() API may be safely retained until the next
8363** invocation of this opcode.
8364**
8365** See also: AggStep, AggFinal, PureFunc
8366*/
8367/* Opcode: PureFunc P1 P2 P3 P4 *
8368** Synopsis: r[P3]=func(r[P2@NP])
8369**
8370** Invoke a user function (P4 is a pointer to an sqlite3_context object that
8371** contains a pointer to the function to be run) with arguments taken
8372** from register P2 and successors. The number of arguments is in
8373** the sqlite3_context object that P4 points to.
8374** The result of the function is stored
8375** in register P3. Register P3 must not be one of the function inputs.
8376**
8377** P1 is a 32-bit bitmask indicating whether or not each argument to the
8378** function was determined to be constant at compile time. If the first
8379** argument was constant then bit 0 of P1 is set. This is used to determine
8380** whether meta data associated with a user function argument using the
8381** sqlite3_set_auxdata() API may be safely retained until the next
8382** invocation of this opcode.
8383**
8384** This opcode works exactly like OP_Function. The only difference is in
8385** its name. This opcode is used in places where the function must be
8386** purely non-deterministic. Some built-in date/time functions can be
8387** either determinitic of non-deterministic, depending on their arguments.
8388** When those function are used in a non-deterministic way, they will check
8389** to see if they were called using OP_PureFunc instead of OP_Function, and
8390** if they were, they throw an error.
8391**
8392** See also: AggStep, AggFinal, Function
8393*/
8394case OP_PureFunc: /* group */
8395case OP_Function: { /* group */
8396 int i;
8397 sqlite3_context *pCtx;
8398
8399 assert( pOp->p4type==P4_FUNCCTX );
8400 pCtx = pOp->p4.pCtx;
8401
8402 /* If this function is inside of a trigger, the register array in aMem[]
8403 ** might change from one evaluation to the next. The next block of code
8404 ** checks to see if the register array has changed, and if so it
8405 ** reinitializes the relavant parts of the sqlite3_context object */
8406 pOut = &aMem[pOp->p3];
8407 if( pCtx->pOut != pOut ){
8408 pCtx->pVdbe = p;
8409 pCtx->pOut = pOut;
8410 pCtx->enc = encoding;
8411 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
8412 }
8413 assert( pCtx->pVdbe==p );
8414
8415 memAboutToChange(p, pOut);
8416#ifdef SQLITE_DEBUG
8417 for(i=0; i<pCtx->argc; i++){
8418 assert( memIsValid(pCtx->argv[i]) );
8419 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
8420 }
8421#endif
8422 MemSetTypeFlag(pOut, MEM_Null);
8423 assert( pCtx->isError==0 );
8424 (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
8425
8426 /* If the function returned an error, throw an exception */
8427 if( pCtx->isError ){
8428 if( pCtx->isError>0 ){
8429 sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
8430 rc = pCtx->isError;
8431 }
8432 sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
8433 pCtx->isError = 0;
8434 if( rc ) goto abort_due_to_error;
8435 }
8436
8437 assert( (pOut->flags&MEM_Str)==0
8438 || pOut->enc==encoding
8439 || db->mallocFailed );
8440 assert( !sqlite3VdbeMemTooBig(pOut) );
8441
8442 REGISTER_TRACE(pOp->p3, pOut);
8443 UPDATE_MAX_BLOBSIZE(pOut);
8444 break;
8445}
8446
8447/* Opcode: ClrSubtype P1 * * * *
8448** Synopsis: r[P1].subtype = 0
8449**
8450** Clear the subtype from register P1.
8451*/
8452case OP_ClrSubtype: { /* in1 */
8453 pIn1 = &aMem[pOp->p1];
8454 pIn1->flags &= ~MEM_Subtype;
8455 break;
8456}
8457
8458/* Opcode: FilterAdd P1 * P3 P4 *
8459** Synopsis: filter(P1) += key(P3@P4)
8460**
8461** Compute a hash on the P4 registers starting with r[P3] and
8462** add that hash to the bloom filter contained in r[P1].
8463*/
8464case OP_FilterAdd: {
8465 u64 h;
8466
8467 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
8468 pIn1 = &aMem[pOp->p1];
8469 assert( pIn1->flags & MEM_Blob );
8470 assert( pIn1->n>0 );
8471 h = filterHash(aMem, pOp);
8472#ifdef SQLITE_DEBUG
8473 if( db->flags&SQLITE_VdbeTrace ){
8474 int ii;
8475 for(ii=pOp->p3; ii<pOp->p3+pOp->p4.i; ii++){
8476 registerTrace(ii, &aMem[ii]);
8477 }
8478 printf("hash: %llu modulo %d -> %u\n", h, pIn1->n, (int)(h%pIn1->n));
8479 }
8480#endif
8481 h %= pIn1->n;
8482 pIn1->z[h/8] |= 1<<(h&7);
8483 break;
8484}
8485
8486/* Opcode: Filter P1 P2 P3 P4 *
8487** Synopsis: if key(P3@P4) not in filter(P1) goto P2
8488**
8489** Compute a hash on the key contained in the P4 registers starting
8490** with r[P3]. Check to see if that hash is found in the
8491** bloom filter hosted by register P1. If it is not present then
8492** maybe jump to P2. Otherwise fall through.
8493**
8494** False negatives are harmless. It is always safe to fall through,
8495** even if the value is in the bloom filter. A false negative causes
8496** more CPU cycles to be used, but it should still yield the correct
8497** answer. However, an incorrect answer may well arise from a
8498** false positive - if the jump is taken when it should fall through.
8499*/
8500case OP_Filter: { /* jump */
8501 u64 h;
8502
8503 assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
8504 pIn1 = &aMem[pOp->p1];
8505 assert( (pIn1->flags & MEM_Blob)!=0 );
8506 assert( pIn1->n >= 1 );
8507 h = filterHash(aMem, pOp);
8508#ifdef SQLITE_DEBUG
8509 if( db->flags&SQLITE_VdbeTrace ){
8510 int ii;
8511 for(ii=pOp->p3; ii<pOp->p3+pOp->p4.i; ii++){
8512 registerTrace(ii, &aMem[ii]);
8513 }
8514 printf("hash: %llu modulo %d -> %u\n", h, pIn1->n, (int)(h%pIn1->n));
8515 }
8516#endif
8517 h %= pIn1->n;
8518 if( (pIn1->z[h/8] & (1<<(h&7)))==0 ){
8519 VdbeBranchTaken(1, 2);
8520 p->aCounter[SQLITE_STMTSTATUS_FILTER_HIT]++;
8521 goto jump_to_p2;
8522 }else{
8523 p->aCounter[SQLITE_STMTSTATUS_FILTER_MISS]++;
8524 VdbeBranchTaken(0, 2);
8525 }
8526 break;
8527}
8528
8529/* Opcode: Trace P1 P2 * P4 *
8530**
8531** Write P4 on the statement trace output if statement tracing is
8532** enabled.
8533**
8534** Operand P1 must be 0x7fffffff and P2 must positive.
8535*/
8536/* Opcode: Init P1 P2 P3 P4 *
8537** Synopsis: Start at P2
8538**
8539** Programs contain a single instance of this opcode as the very first
8540** opcode.
8541**
8542** If tracing is enabled (by the sqlite3_trace()) interface, then
8543** the UTF-8 string contained in P4 is emitted on the trace callback.
8544** Or if P4 is blank, use the string returned by sqlite3_sql().
8545**
8546** If P2 is not zero, jump to instruction P2.
8547**
8548** Increment the value of P1 so that OP_Once opcodes will jump the
8549** first time they are evaluated for this run.
8550**
8551** If P3 is not zero, then it is an address to jump to if an SQLITE_CORRUPT
8552** error is encountered.
8553*/
8554case OP_Trace:
8555case OP_Init: { /* jump */
8556 int i;
8557#ifndef SQLITE_OMIT_TRACE
8558 char *zTrace;
8559#endif
8560
8561 /* If the P4 argument is not NULL, then it must be an SQL comment string.
8562 ** The "--" string is broken up to prevent false-positives with srcck1.c.
8563 **
8564 ** This assert() provides evidence for:
8565 ** EVIDENCE-OF: R-50676-09860 The callback can compute the same text that
8566 ** would have been returned by the legacy sqlite3_trace() interface by
8567 ** using the X argument when X begins with "--" and invoking
8568 ** sqlite3_expanded_sql(P) otherwise.
8569 */
8570 assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 );
8571
8572 /* OP_Init is always instruction 0 */
8573 assert( pOp==p->aOp || pOp->opcode==OP_Trace );
8574
8575#ifndef SQLITE_OMIT_TRACE
8576 if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0
8577 && p->minWriteFileFormat!=254 /* tag-20220401a */
8578 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
8579 ){
8580#ifndef SQLITE_OMIT_DEPRECATED
8581 if( db->mTrace & SQLITE_TRACE_LEGACY ){
8582 char *z = sqlite3VdbeExpandSql(p, zTrace);
8583 db->trace.xLegacy(db->pTraceArg, z);
8584 sqlite3_free(z);
8585 }else
8586#endif
8587 if( db->nVdbeExec>1 ){
8588 char *z = sqlite3MPrintf(db, "-- %s", zTrace);
8589 (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, z);
8590 sqlite3DbFree(db, z);
8591 }else{
8592 (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace);
8593 }
8594 }
8595#ifdef SQLITE_USE_FCNTL_TRACE
8596 zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql);
8597 if( zTrace ){
8598 int j;
8599 for(j=0; j<db->nDb; j++){
8600 if( DbMaskTest(p->btreeMask, j)==0 ) continue;
8601 sqlite3_file_control(db, db->aDb[j].zDbSName, SQLITE_FCNTL_TRACE, zTrace);
8602 }
8603 }
8604#endif /* SQLITE_USE_FCNTL_TRACE */
8605#ifdef SQLITE_DEBUG
8606 if( (db->flags & SQLITE_SqlTrace)!=0
8607 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
8608 ){
8609 sqlite3DebugPrintf("SQL-trace: %s\n", zTrace);
8610 }
8611#endif /* SQLITE_DEBUG */
8612#endif /* SQLITE_OMIT_TRACE */
8613 assert( pOp->p2>0 );
8614 if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){
8615 if( pOp->opcode==OP_Trace ) break;
8616 for(i=1; i<p->nOp; i++){
8617 if( p->aOp[i].opcode==OP_Once ) p->aOp[i].p1 = 0;
8618 }
8619 pOp->p1 = 0;
8620 }
8621 pOp->p1++;
8622 p->aCounter[SQLITE_STMTSTATUS_RUN]++;
8623 goto jump_to_p2;
8624}
8625
8626#ifdef SQLITE_ENABLE_CURSOR_HINTS
8627/* Opcode: CursorHint P1 * * P4 *
8628**
8629** Provide a hint to cursor P1 that it only needs to return rows that
8630** satisfy the Expr in P4. TK_REGISTER terms in the P4 expression refer
8631** to values currently held in registers. TK_COLUMN terms in the P4
8632** expression refer to columns in the b-tree to which cursor P1 is pointing.
8633*/
8634case OP_CursorHint: {
8635 VdbeCursor *pC;
8636
8637 assert( pOp->p1>=0 && pOp->p1<p->nCursor );
8638 assert( pOp->p4type==P4_EXPR );
8639 pC = p->apCsr[pOp->p1];
8640 if( pC ){
8641 assert( pC->eCurType==CURTYPE_BTREE );
8642 sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
8643 pOp->p4.pExpr, aMem);
8644 }
8645 break;
8646}
8647#endif /* SQLITE_ENABLE_CURSOR_HINTS */
8648
8649#ifdef SQLITE_DEBUG
8650/* Opcode: Abortable * * * * *
8651**
8652** Verify that an Abort can happen. Assert if an Abort at this point
8653** might cause database corruption. This opcode only appears in debugging
8654** builds.
8655**
8656** An Abort is safe if either there have been no writes, or if there is
8657** an active statement journal.
8658*/
8659case OP_Abortable: {
8660 sqlite3VdbeAssertAbortable(p);
8661 break;
8662}
8663#endif
8664
8665#ifdef SQLITE_DEBUG
8666/* Opcode: ReleaseReg P1 P2 P3 * P5
8667** Synopsis: release r[P1@P2] mask P3
8668**
8669** Release registers from service. Any content that was in the
8670** the registers is unreliable after this opcode completes.
8671**
8672** The registers released will be the P2 registers starting at P1,
8673** except if bit ii of P3 set, then do not release register P1+ii.
8674** In other words, P3 is a mask of registers to preserve.
8675**
8676** Releasing a register clears the Mem.pScopyFrom pointer. That means
8677** that if the content of the released register was set using OP_SCopy,
8678** a change to the value of the source register for the OP_SCopy will no longer
8679** generate an assertion fault in sqlite3VdbeMemAboutToChange().
8680**
8681** If P5 is set, then all released registers have their type set
8682** to MEM_Undefined so that any subsequent attempt to read the released
8683** register (before it is reinitialized) will generate an assertion fault.
8684**
8685** P5 ought to be set on every call to this opcode.
8686** However, there are places in the code generator will release registers
8687** before their are used, under the (valid) assumption that the registers
8688** will not be reallocated for some other purpose before they are used and
8689** hence are safe to release.
8690**
8691** This opcode is only available in testing and debugging builds. It is
8692** not generated for release builds. The purpose of this opcode is to help
8693** validate the generated bytecode. This opcode does not actually contribute
8694** to computing an answer.
8695*/
8696case OP_ReleaseReg: {
8697 Mem *pMem;
8698 int i;
8699 u32 constMask;
8700 assert( pOp->p1>0 );
8701 assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
8702 pMem = &aMem[pOp->p1];
8703 constMask = pOp->p3;
8704 for(i=0; i<pOp->p2; i++, pMem++){
8705 if( i>=32 || (constMask & MASKBIT32(i))==0 ){
8706 pMem->pScopyFrom = 0;
8707 if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined);
8708 }
8709 }
8710 break;
8711}
8712#endif
8713
8714/* Opcode: Noop * * * * *
8715**
8716** Do nothing. This instruction is often useful as a jump
8717** destination.
8718*/
8719/*
8720** The magic Explain opcode are only inserted when explain==2 (which
8721** is to say when the EXPLAIN QUERY PLAN syntax is used.)
8722** This opcode records information from the optimizer. It is the
8723** the same as a no-op. This opcodesnever appears in a real VM program.
8724*/
8725default: { /* This is really OP_Noop, OP_Explain */
8726 assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
8727
8728 break;
8729}
8730
8731/*****************************************************************************
8732** The cases of the switch statement above this line should all be indented
8733** by 6 spaces. But the left-most 6 spaces have been removed to improve the
8734** readability. From this point on down, the normal indentation rules are
8735** restored.
8736*****************************************************************************/
8737 }
8738
8739#ifdef VDBE_PROFILE
8740 {
8741 u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
8742 if( endTime>start ) pOrigOp->cycles += endTime - start;
8743 pOrigOp->cnt++;
8744 }
8745#endif
8746
8747 /* The following code adds nothing to the actual functionality
8748 ** of the program. It is only here for testing and debugging.
8749 ** On the other hand, it does burn CPU cycles every time through
8750 ** the evaluator loop. So we can leave it out when NDEBUG is defined.
8751 */
8752#ifndef NDEBUG
8753 assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] );
8754
8755#ifdef SQLITE_DEBUG
8756 if( db->flags & SQLITE_VdbeTrace ){
8757 u8 opProperty = sqlite3OpcodeProperty[pOrigOp->opcode];
8758 if( rc!=0 ) printf("rc=%d\n",rc);
8759 if( opProperty & (OPFLG_OUT2) ){
8760 registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]);
8761 }
8762 if( opProperty & OPFLG_OUT3 ){
8763 registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]);
8764 }
8765 if( opProperty==0xff ){
8766 /* Never happens. This code exists to avoid a harmless linkage
8767 ** warning aboud sqlite3VdbeRegisterDump() being defined but not
8768 ** used. */
8769 sqlite3VdbeRegisterDump(p);
8770 }
8771 }
8772#endif /* SQLITE_DEBUG */
8773#endif /* NDEBUG */
8774 } /* The end of the for(;;) loop the loops through opcodes */
8775
8776 /* If we reach this point, it means that execution is finished with
8777 ** an error of some kind.
8778 */
8779abort_due_to_error:
8780 if( db->mallocFailed ){
8781 rc = SQLITE_NOMEM_BKPT;
8782 }else if( rc==SQLITE_IOERR_CORRUPTFS ){
8783 rc = SQLITE_CORRUPT_BKPT;
8784 }
8785 assert( rc );
8786#ifdef SQLITE_DEBUG
8787 if( db->flags & SQLITE_VdbeTrace ){
8788 const char *zTrace = p->zSql;
8789 if( zTrace==0 ){
8790 if( aOp[0].opcode==OP_Trace ){
8791 zTrace = aOp[0].p4.z;
8792 }
8793 if( zTrace==0 ) zTrace = "???";
8794 }
8795 printf("ABORT-due-to-error (rc=%d): %s\n", rc, zTrace);
8796 }
8797#endif
8798 if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){
8799 sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc));
8800 }
8801 p->rc = rc;
8802 sqlite3SystemError(db, rc);
8803 testcase( sqlite3GlobalConfig.xLog!=0 );
8804 sqlite3_log(rc, "statement aborts at %d: [%s] %s",
8805 (int)(pOp - aOp), p->zSql, p->zErrMsg);
8806 if( p->eVdbeState==VDBE_RUN_STATE ) sqlite3VdbeHalt(p);
8807 if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db);
8808 if( rc==SQLITE_CORRUPT && db->autoCommit==0 ){
8809 db->flags |= SQLITE_CorruptRdOnly;
8810 }
8811 rc = SQLITE_ERROR;
8812 if( resetSchemaOnFault>0 ){
8813 sqlite3ResetOneSchema(db, resetSchemaOnFault-1);
8814 }
8815
8816 /* This is the only way out of this procedure. We have to
8817 ** release the mutexes on btrees that were acquired at the
8818 ** top. */
8819vdbe_return:
8820#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
8821 while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
8822 nProgressLimit += db->nProgressOps;
8823 if( db->xProgress(db->pProgressArg) ){
8824 nProgressLimit = LARGEST_UINT64;
8825 rc = SQLITE_INTERRUPT;
8826 goto abort_due_to_error;
8827 }
8828 }
8829#endif
8830 p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;
8831 sqlite3VdbeLeave(p);
8832 assert( rc!=SQLITE_OK || nExtraDelete==0
8833 || sqlite3_strlike("DELETE%",p->zSql,0)!=0
8834 );
8835 return rc;
8836
8837 /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
8838 ** is encountered.
8839 */
8840too_big:
8841 sqlite3VdbeError(p, "string or blob too big");
8842 rc = SQLITE_TOOBIG;
8843 goto abort_due_to_error;
8844
8845 /* Jump to here if a malloc() fails.
8846 */
8847no_mem:
8848 sqlite3OomFault(db);
8849 sqlite3VdbeError(p, "out of memory");
8850 rc = SQLITE_NOMEM_BKPT;
8851 goto abort_due_to_error;
8852
8853 /* Jump to here if the sqlite3_interrupt() API sets the interrupt
8854 ** flag.
8855 */
8856abort_due_to_interrupt:
8857 assert( AtomicLoad(&db->u1.isInterrupted) );
8858 rc = SQLITE_INTERRUPT;
8859 goto abort_due_to_error;
8860}
8861