| blob | 366c7a01661b2d48e986d903d412981e69df33f5 |
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 */
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
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
48 #endif
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
60 #endif
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
71 #endif
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
85 }
86 }
87 #endif
89 /*
90 ** The next global variable is incremented each time the OP_Found opcode
91 ** is executed. This is used to test whether or not the foreign key
92 ** operation implemented using OP_FkIsZero is working. This variable
93 ** has no function other than to help verify the correct operation of the
94 ** library.
95 */
96 #ifdef SQLITE_TEST
98 #endif
100 /*
101 ** Test a register to see if it exceeds the current maximum blob size.
102 ** If it does, record the new maximum blob size.
103 */
104 #if defined(SQLITE_TEST) && !defined(SQLITE_OMIT_BUILTIN_TEST)
105 # define UPDATE_MAX_BLOBSIZE(P) updateMaxBlobsize(P)
106 #else
107 # define UPDATE_MAX_BLOBSIZE(P)
108 #endif
110 /*
111 ** Invoke the VDBE coverage callback, if that callback is defined. This
112 ** feature is used for test suite validation only and does not appear an
113 ** production builds.
114 **
115 ** M is an integer, 2 or 3, that indices how many different ways the
116 ** branch can go. It is usually 2. "I" is the direction the branch
117 ** goes. 0 means falls through. 1 means branch is taken. 2 means the
118 ** second alternative branch is taken.
119 **
120 ** iSrcLine is the source code line (from the __LINE__ macro) that
121 ** generated the VDBE instruction. This instrumentation assumes that all
122 ** source code is in a single file (the amalgamation). Special values 1
123 ** and 2 for the iSrcLine parameter mean that this particular branch is
124 ** always taken or never taken, respectively.
125 */
126 #if !defined(SQLITE_VDBE_COVERAGE)
127 # define VdbeBranchTaken(I,M)
128 #else
129 # define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M)
133 /* Assert the truth of VdbeCoverageAlwaysTaken() and
134 ** VdbeCoverageNeverTaken() */
140 }
141 }
142 #endif
144 /*
145 ** Convert the given register into a string if it isn't one
146 ** already. Return non-zero if a malloc() fails.
147 */
148 #define Stringify(P, enc) \
149 if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc,0)) \
150 { goto no_mem; }
152 /*
153 ** An ephemeral string value (signified by the MEM_Ephem flag) contains
154 ** a pointer to a dynamically allocated string where some other entity
155 ** is responsible for deallocating that string. Because the register
156 ** does not control the string, it might be deleted without the register
157 ** knowing it.
158 **
159 ** This routine converts an ephemeral string into a dynamically allocated
160 ** string that the register itself controls. In other words, it
161 ** converts an MEM_Ephem string into a string with P.z==P.zMalloc.
162 */
163 #define Deephemeralize(P) \
164 if( ((P)->flags&MEM_Ephem)!=0 \
165 && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
167 /* Return true if the cursor was opened using the OP_OpenSorter opcode. */
168 #define isSorter(x) ((x)->pSorter!=0)
170 /*
171 ** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL
172 ** if we run out of memory.
173 */
180 ){
181 /* Find the memory cell that will be used to store the blob of memory
182 ** required for this VdbeCursor structure. It is convenient to use a
183 ** vdbe memory cell to manage the memory allocation required for a
184 ** VdbeCursor structure for the following reasons:
185 **
186 ** * Sometimes cursor numbers are used for a couple of different
187 ** purposes in a vdbe program. The different uses might require
188 ** different sized allocations. Memory cells provide growable
189 ** allocations.
190 **
191 ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
192 ** be freed lazily via the sqlite3_release_memory() API. This
193 ** minimizes the number of malloc calls made by the system.
194 **
195 ** Memory cells for cursors are allocated at the top of the address
196 ** space. Memory cell (p->nMem) corresponds to cursor 0. Space for
197 ** cursor 1 is managed by memory cell (p->nMem-1), etc.
198 */
203 nByte =
211 }
222 }
223 }
225 }
227 /*
228 ** Try to convert a value into a numeric representation if we can
229 ** do so without loss of information. In other words, if the string
230 ** looks like a number, convert it into a number. If it does not
231 ** look like a number, leave it alone.
232 **
233 ** If the bTryForInt flag is true, then extra effort is made to give
234 ** an integer representation. Strings that look like floating point
235 ** values but which have no fractional component (example: '48.00')
236 ** will have a MEM_Int representation when bTryForInt is true.
237 **
238 ** If bTryForInt is false, then if the input string contains a decimal
239 ** point or exponential notation, the result is only MEM_Real, even
240 ** if there is an exact integer representation of the quantity.
241 */
244 i64 iValue;
255 }
256 }
258 /*
259 ** Processing is determine by the affinity parameter:
260 **
261 ** SQLITE_AFF_INTEGER:
262 ** SQLITE_AFF_REAL:
263 ** SQLITE_AFF_NUMERIC:
264 ** Try to convert pRec to an integer representation or a
265 ** floating-point representation if an integer representation
266 ** is not possible. Note that the integer representation is
267 ** always preferred, even if the affinity is REAL, because
268 ** an integer representation is more space efficient on disk.
269 **
270 ** SQLITE_AFF_TEXT:
271 ** Convert pRec to a text representation.
272 **
273 ** SQLITE_AFF_NONE:
274 ** No-op. pRec is unchanged.
275 */
279 u8 enc /* Use this text encoding */
280 ){
289 }
290 }
292 /* Only attempt the conversion to TEXT if there is an integer or real
293 ** representation (blob and NULL do not get converted) but no string
294 ** representation.
295 */
298 }
299 }
300 }
302 /*
303 ** Try to convert the type of a function argument or a result column
304 ** into a numeric representation. Use either INTEGER or REAL whichever
305 ** is appropriate. But only do the conversion if it is possible without
306 ** loss of information and return the revised type of the argument.
307 */
314 }
316 }
318 /*
319 ** Exported version of applyAffinity(). This one works on sqlite3_value*,
320 ** not the internal Mem* type.
321 */
324 u8 affinity,
325 u8 enc
326 ){
328 }
330 /*
331 ** pMem currently only holds a string type (or maybe a BLOB that we can
332 ** interpret as a string if we want to). Compute its corresponding
333 ** numeric type, if has one. Set the pMem->u.r and pMem->u.i fields
334 ** accordingly.
335 */
341 }
344 }
346 }
348 /*
349 ** Return the numeric type for pMem, either MEM_Int or MEM_Real or both or
350 ** none.
351 **
352 ** Unlike applyNumericAffinity(), this routine does not modify pMem->flags.
353 ** But it does set pMem->u.r and pMem->u.i appropriately.
354 */
358 }
361 }
363 }
365 #ifdef SQLITE_DEBUG
366 /*
367 ** Write a nice string representation of the contents of cell pMem
368 ** into buffer zBuf, length nBuf.
369 */
390 }
399 }
404 }
411 }
427 }
438 }
439 }
444 }
445 }
446 #endif
448 #ifdef SQLITE_DEBUG
449 /*
450 ** Print the value of a register for tracing purposes:
451 */
461 #ifndef SQLITE_OMIT_FLOATING_POINT
464 #endif
471 }
472 }
477 }
478 #endif
480 #ifdef SQLITE_DEBUG
481 # define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M)
482 #else
483 # define REGISTER_TRACE(R,M)
484 #endif
487 #ifdef VDBE_PROFILE
489 /*
490 ** hwtime.h contains inline assembler code for implementing
491 ** high-performance timing routines.
492 */
495 #endif
497 #ifndef NDEBUG
498 /*
499 ** This function is only called from within an assert() expression. It
500 ** checks that the sqlite3.nTransaction variable is correctly set to
501 ** the number of non-transaction savepoints currently in the
502 ** linked list starting at sqlite3.pSavepoint.
503 **
504 ** Usage:
505 **
506 ** assert( checkSavepointCount(db) );
507 */
514 }
515 #endif
518 /*
519 ** Execute as much of a VDBE program as we can.
520 ** This is the core of sqlite3_step().
521 */
524 ){
534 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
536 #endif
544 #ifdef VDBE_PROFILE
546 #endif
547 /*** INSERT STACK UNION HERE ***/
552 /* This happens if a malloc() inside a call to sqlite3_column_text() or
553 ** sqlite3_column_text16() failed. */
555 }
565 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
573 }
574 }
575 #endif
576 #ifdef SQLITE_DEBUG
580 ){
588 }
589 }
596 }
597 }
598 }
600 }
602 #endif
606 #ifdef VDBE_PROFILE
608 #endif
609 nVmStep++;
612 /* Only allow tracing if SQLITE_DEBUG is defined.
613 */
614 #ifdef SQLITE_DEBUG
617 }
618 #endif
621 /* Check to see if we need to simulate an interrupt. This only happens
622 ** if we have a special test build.
623 */
624 #ifdef SQLITE_TEST
626 sqlite3_interrupt_count--;
629 }
630 }
631 #endif
633 /* On any opcode with the "out2-prerelease" tag, free any
634 ** external allocations out of mem[p2] and set mem[p2] to be
635 ** an undefined integer. Opcodes will either fill in the integer
636 ** value or convert mem[p2] to a different type.
637 */
646 }
648 /* Sanity checking on other operands */
649 #ifdef SQLITE_DEBUG
656 }
663 }
670 }
675 }
680 }
681 #endif
685 /*****************************************************************************
686 ** What follows is a massive switch statement where each case implements a
687 ** separate instruction in the virtual machine. If we follow the usual
688 ** indentation conventions, each case should be indented by 6 spaces. But
689 ** that is a lot of wasted space on the left margin. So the code within
690 ** the switch statement will break with convention and be flush-left. Another
691 ** big comment (similar to this one) will mark the point in the code where
692 ** we transition back to normal indentation.
693 **
694 ** The formatting of each case is important. The makefile for SQLite
695 ** generates two C files "opcodes.h" and "opcodes.c" by scanning this
696 ** file looking for lines that begin with "case OP_". The opcodes.h files
697 ** will be filled with #defines that give unique integer values to each
698 ** opcode and the opcodes.c file is filled with an array of strings where
699 ** each string is the symbolic name for the corresponding opcode. If the
700 ** case statement is followed by a comment of the form "/# same as ... #/"
701 ** that comment is used to determine the particular value of the opcode.
702 **
703 ** Other keywords in the comment that follows each case are used to
704 ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
705 ** Keywords include: in1, in2, in3, out2_prerelease, out2, out3. See
706 ** the mkopcodeh.awk script for additional information.
707 **
708 ** Documentation about VDBE opcodes is generated by scanning this file
709 ** for lines of that contain "Opcode:". That line and all subsequent
710 ** comment lines are used in the generation of the opcode.html documentation
711 ** file.
712 **
713 ** SUMMARY:
714 **
715 ** Formatting is important to scripts that scan this file.
716 ** Do not deviate from the formatting style currently in use.
717 **
718 *****************************************************************************/
720 /* Opcode: Goto * P2 * * *
721 **
722 ** An unconditional jump to address P2.
723 ** The next instruction executed will be
724 ** the one at index P2 from the beginning of
725 ** the program.
726 **
727 ** The P1 parameter is not actually used by this opcode. However, it
728 ** is sometimes set to 1 instead of 0 as a hint to the command-line shell
729 ** that this Goto is the bottom of a loop and that the lines from P2 down
730 ** to the current line should be indented for EXPLAIN output.
731 */
735 /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev,
736 ** OP_VNext, OP_RowSetNext, or OP_SorterNext) all jump here upon
737 ** completion. Check to see if sqlite3_interrupt() has been called
738 ** or if the progress callback needs to be invoked.
739 **
740 ** This code uses unstructured "goto" statements and does not look clean.
741 ** But that is not due to sloppy coding habits. The code is written this
742 ** way for performance, to avoid having to run the interrupt and progress
743 ** checks on every opcode. This helps sqlite3_step() to run about 1.5%
744 ** faster according to "valgrind --tool=cachegrind" */
745 check_for_interrupt:
747 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
748 /* Call the progress callback if it is configured and the required number
749 ** of VDBE ops have been executed (either since this invocation of
750 ** sqlite3VdbeExec() or since last time the progress callback was called).
751 ** If the progress callback returns non-zero, exit the virtual machine with
752 ** a return code SQLITE_ABORT.
753 */
760 }
761 }
762 #endif
765 }
767 /* Opcode: Gosub P1 P2 * * *
768 **
769 ** Write the current address onto register P1
770 ** and then jump to address P2.
771 */
782 }
784 /* Opcode: Return P1 * * * *
785 **
786 ** Jump to the next instruction after the address in register P1. After
787 ** the jump, register P1 becomes undefined.
788 */
795 }
797 /* Opcode: InitCoroutine P1 P2 P3 * *
798 **
799 ** Set up register P1 so that it will Yield to the coroutine
800 ** located at address P3.
801 **
802 ** If P2!=0 then the coroutine implementation immediately follows
803 ** this opcode. So jump over the coroutine implementation to
804 ** address P2.
805 **
806 ** See also: EndCoroutine
807 */
818 }
820 /* Opcode: EndCoroutine P1 * * * *
821 **
822 ** The instruction at the address in register P1 is a Yield.
823 ** Jump to the P2 parameter of that Yield.
824 ** After the jump, register P1 becomes undefined.
825 **
826 ** See also: InitCoroutine
827 */
839 }
841 /* Opcode: Yield P1 P2 * * *
842 **
843 ** Swap the program counter with the value in register P1. This
844 ** has the effect of yielding to a coroutine.
845 **
846 ** If the coroutine that is launched by this instruction ends with
847 ** Yield or Return then continue to the next instruction. But if
848 ** the coroutine launched by this instruction ends with
849 ** EndCoroutine, then jump to P2 rather than continuing with the
850 ** next instruction.
851 **
852 ** See also: InitCoroutine
853 */
864 }
866 /* Opcode: HaltIfNull P1 P2 P3 P4 P5
867 ** Synopsis: if r[P3]=null halt
868 **
869 ** Check the value in register P3. If it is NULL then Halt using
870 ** parameter P1, P2, and P4 as if this were a Halt instruction. If the
871 ** value in register P3 is not NULL, then this routine is a no-op.
872 ** The P5 parameter should be 1.
873 */
877 /* Fall through into OP_Halt */
878 }
880 /* Opcode: Halt P1 P2 * P4 P5
881 **
882 ** Exit immediately. All open cursors, etc are closed
883 ** automatically.
884 **
885 ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
886 ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0).
887 ** For errors, it can be some other value. If P1!=0 then P2 will determine
888 ** whether or not to rollback the current transaction. Do not rollback
889 ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort,
890 ** then back out all changes that have occurred during this execution of the
891 ** VDBE, but do not rollback the transaction.
892 **
893 ** If P4 is not null then it is an error message string.
894 **
895 ** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
896 **
897 ** 0: (no change)
898 ** 1: NOT NULL contraint failed: P4
899 ** 2: UNIQUE constraint failed: P4
900 ** 3: CHECK constraint failed: P4
901 ** 4: FOREIGN KEY constraint failed: P4
902 **
903 ** If P5 is not zero and P4 is NULL, then everything after the ":" is
904 ** omitted.
905 **
906 ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
907 ** every program. So a jump past the last instruction of the program
908 ** is the same as executing Halt.
909 */
915 /* Halt the sub-program. Return control to the parent frame. */
923 /* Instruction pc is the OP_Program that invoked the sub-program
924 ** currently being halted. If the p2 instruction of this OP_Halt
925 ** instruction is set to OE_Ignore, then the sub-program is throwing
926 ** an IGNORE exception. In this case jump to the address specified
927 ** as the p2 of the calling OP_Program. */
929 }
933 }
949 }
959 }
961 }
970 }
972 }
974 /* Opcode: Integer P1 P2 * * *
975 ** Synopsis: r[P2]=P1
976 **
977 ** The 32-bit integer value P1 is written into register P2.
978 */
982 }
984 /* Opcode: Int64 * P2 * P4 *
985 ** Synopsis: r[P2]=P4
986 **
987 ** P4 is a pointer to a 64-bit integer value.
988 ** Write that value into register P2.
989 */
994 }
996 #ifndef SQLITE_OMIT_FLOATING_POINT
997 /* Opcode: Real * P2 * P4 *
998 ** Synopsis: r[P2]=P4
999 **
1000 ** P4 is a pointer to a 64-bit floating point value.
1001 ** Write that value into register P2.
1002 */
1008 }
1009 #endif
1011 /* Opcode: String8 * P2 * P4 *
1012 ** Synopsis: r[P2]='P4'
1013 **
1014 ** P4 points to a nul terminated UTF-8 string. This opcode is transformed
1015 ** into a String before it is executed for the first time. During
1016 ** this transformation, the length of string P4 is computed and stored
1017 ** as the P1 parameter.
1018 */
1024 #ifndef SQLITE_OMIT_UTF16
1035 }
1039 }
1040 #endif
1043 }
1044 /* Fall through to the next case, OP_String */
1045 }
1047 /* Opcode: String P1 P2 * P4 *
1048 ** Synopsis: r[P2]='P4' (len=P1)
1049 **
1050 ** The string value P4 of length P1 (bytes) is stored in register P2.
1051 */
1060 }
1062 /* Opcode: Null P1 P2 P3 * *
1063 ** Synopsis: r[P2..P3]=NULL
1064 **
1065 ** Write a NULL into registers P2. If P3 greater than P2, then also write
1066 ** NULL into register P3 and every register in between P2 and P3. If P3
1067 ** is less than P2 (typically P3 is zero) then only register P2 is
1068 ** set to NULL.
1069 **
1070 ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
1071 ** NULL values will not compare equal even if SQLITE_NULLEQ is set on
1072 ** OP_Ne or OP_Eq.
1073 */
1076 u16 nullFlag;
1081 pOut++;
1085 cnt--;
1086 }
1088 }
1090 /* Opcode: SoftNull P1 * * * *
1091 ** Synopsis: r[P1]=NULL
1092 **
1093 ** Set register P1 to have the value NULL as seen by the OP_MakeRecord
1094 ** instruction, but do not free any string or blob memory associated with
1095 ** the register, so that if the value was a string or blob that was
1096 ** previously copied using OP_SCopy, the copies will continue to be valid.
1097 */
1103 }
1105 /* Opcode: Blob P1 P2 * P4 *
1106 ** Synopsis: r[P2]=P4 (len=P1)
1107 **
1108 ** P4 points to a blob of data P1 bytes long. Store this
1109 ** blob in register P2.
1110 */
1117 }
1119 /* Opcode: Variable P1 P2 * P4 *
1120 ** Synopsis: r[P2]=parameter(P1,P4)
1121 **
1122 ** Transfer the values of bound parameter P1 into register P2
1123 **
1124 ** If the parameter is named, then its name appears in P4.
1125 ** The P4 value is used by sqlite3_bind_parameter_name().
1126 */
1135 }
1139 }
1141 /* Opcode: Move P1 P2 P3 * *
1142 ** Synopsis: r[P2@P3]=r[P1@P3]
1143 **
1144 ** Move the P3 values in register P1..P1+P3-1 over into
1145 ** registers P2..P2+P3-1. Registers P1..P1+P3-1 are
1146 ** left holding a NULL. It is an error for register ranges
1147 ** P1..P1+P3-1 and P2..P2+P3-1 to overlap. It is an error
1148 ** for P3 to be less than 1.
1149 */
1169 #ifdef SQLITE_DEBUG
1172 }
1173 #endif
1175 pIn1++;
1176 pOut++;
1179 }
1181 /* Opcode: Copy P1 P2 P3 * *
1182 ** Synopsis: r[P2@P3+1]=r[P1@P3+1]
1183 **
1184 ** Make a copy of registers P1..P1+P3 into registers P2..P2+P3.
1185 **
1186 ** This instruction makes a deep copy of the value. A duplicate
1187 ** is made of any string or blob constant. See also OP_SCopy.
1188 */
1199 #ifdef SQLITE_DEBUG
1201 #endif
1204 pOut++;
1205 pIn1++;
1206 }
1208 }
1210 /* Opcode: SCopy P1 P2 * * *
1211 ** Synopsis: r[P2]=r[P1]
1212 **
1213 ** Make a shallow copy of register P1 into register P2.
1214 **
1215 ** This instruction makes a shallow copy of the value. If the value
1216 ** is a string or blob, then the copy is only a pointer to the
1217 ** original and hence if the original changes so will the copy.
1218 ** Worse, if the original is deallocated, the copy becomes invalid.
1219 ** Thus the program must guarantee that the original will not change
1220 ** during the lifetime of the copy. Use OP_Copy to make a complete
1221 ** copy.
1222 */
1228 #ifdef SQLITE_DEBUG
1230 #endif
1232 }
1234 /* Opcode: ResultRow P1 P2 * * *
1235 ** Synopsis: output=r[P1@P2]
1236 **
1237 ** The registers P1 through P1+P2-1 contain a single row of
1238 ** results. This opcode causes the sqlite3_step() call to terminate
1239 ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
1240 ** structure to provide access to the r(P1)..r(P1+P2-1) values as
1241 ** the result row.
1242 */
1250 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1251 /* Run the progress counter just before returning.
1252 */
1256 ){
1259 }
1260 #endif
1262 /* If this statement has violated immediate foreign key constraints, do
1263 ** not return the number of rows modified. And do not RELEASE the statement
1264 ** transaction. It needs to be rolled back. */
1269 }
1271 /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
1272 ** DML statements invoke this opcode to return the number of rows
1273 ** modified to the user. This is the only way that a VM that
1274 ** opens a statement transaction may invoke this opcode.
1275 **
1276 ** In case this is such a statement, close any statement transaction
1277 ** opened by this VM before returning control to the user. This is to
1278 ** ensure that statement-transactions are always nested, not overlapping.
1279 ** If the open statement-transaction is not closed here, then the user
1280 ** may step another VM that opens its own statement transaction. This
1281 ** may lead to overlapping statement transactions.
1282 **
1283 ** The statement transaction is never a top-level transaction. Hence
1284 ** the RELEASE call below can never fail.
1285 */
1290 }
1292 /* Invalidate all ephemeral cursor row caches */
1295 /* Make sure the results of the current row are \000 terminated
1296 ** and have an assigned type. The results are de-ephemeralized as
1297 ** a side effect.
1298 */
1307 }
1310 /* Return SQLITE_ROW
1311 */
1315 }
1317 /* Opcode: Concat P1 P2 P3 * *
1318 ** Synopsis: r[P3]=r[P2]+r[P1]
1319 **
1320 ** Add the text in register P1 onto the end of the text in
1321 ** register P2 and store the result in register P3.
1322 ** If either the P1 or P2 text are NULL then store NULL in P3.
1323 **
1324 ** P3 = P2 || P1
1325 **
1326 ** It is illegal for P1 and P3 to be the same register. Sometimes,
1327 ** if P3 is the same register as P2, the implementation is able
1328 ** to avoid a memcpy().
1329 */
1331 i64 nByte;
1340 }
1347 }
1350 }
1354 }
1363 }
1365 /* Opcode: Add P1 P2 P3 * *
1366 ** Synopsis: r[P3]=r[P1]+r[P2]
1367 **
1368 ** Add the value in register P1 to the value in register P2
1369 ** and store the result in register P3.
1370 ** If either input is NULL, the result is NULL.
1371 */
1372 /* Opcode: Multiply P1 P2 P3 * *
1373 ** Synopsis: r[P3]=r[P1]*r[P2]
1374 **
1375 **
1376 ** Multiply the value in register P1 by the value in register P2
1377 ** and store the result in register P3.
1378 ** If either input is NULL, the result is NULL.
1379 */
1380 /* Opcode: Subtract P1 P2 P3 * *
1381 ** Synopsis: r[P3]=r[P2]-r[P1]
1382 **
1383 ** Subtract the value in register P1 from the value in register P2
1384 ** and store the result in register P3.
1385 ** If either input is NULL, the result is NULL.
1386 */
1387 /* Opcode: Divide P1 P2 P3 * *
1388 ** Synopsis: r[P3]=r[P2]/r[P1]
1389 **
1390 ** Divide the value in register P1 by the value in register P2
1391 ** and store the result in register P3 (P3=P2/P1). If the value in
1392 ** register P1 is zero, then the result is NULL. If either input is
1393 ** NULL, the result is NULL.
1394 */
1395 /* Opcode: Remainder P1 P2 P3 * *
1396 ** Synopsis: r[P3]=r[P2]%r[P1]
1397 **
1398 ** Compute the remainder after integer register P2 is divided by
1399 ** register P1 and store the result in register P3.
1400 ** If the value in register P1 is zero the result is NULL.
1401 ** If either operand is NULL, the result is NULL.
1402 */
1437 }
1443 }
1444 }
1449 fp_math:
1457 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
1461 }
1469 }
1470 }
1471 #ifdef SQLITE_OMIT_FLOATING_POINT
1474 #else
1477 }
1482 }
1483 #endif
1484 }
1487 arithmetic_result_is_null:
1490 }
1492 /* Opcode: CollSeq P1 * * P4
1493 **
1494 ** P4 is a pointer to a CollSeq struct. If the next call to a user function
1495 ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
1496 ** be returned. This is used by the built-in min(), max() and nullif()
1497 ** functions.
1498 **
1499 ** If P1 is not zero, then it is a register that a subsequent min() or
1500 ** max() aggregate will set to 1 if the current row is not the minimum or
1501 ** maximum. The P1 register is initialized to 0 by this instruction.
1502 **
1503 ** The interface used by the implementation of the aforementioned functions
1504 ** to retrieve the collation sequence set by this opcode is not available
1505 ** publicly, only to user functions defined in func.c.
1506 */
1511 }
1513 }
1515 /* Opcode: Function P1 P2 P3 P4 P5
1516 ** Synopsis: r[P3]=func(r[P2@P5])
1517 **
1518 ** Invoke a user function (P4 is a pointer to a Function structure that
1519 ** defines the function) with P5 arguments taken from register P2 and
1520 ** successors. The result of the function is stored in register P3.
1521 ** Register P3 must not be one of the function inputs.
1522 **
1523 ** P1 is a 32-bit bitmask indicating whether or not each argument to the
1524 ** function was determined to be constant at compile time. If the first
1525 ** argument was constant then bit 0 of P1 is set. This is used to determine
1526 ** whether meta data associated with a user function argument using the
1527 ** sqlite3_set_auxdata() API may be safely retained until the next
1528 ** invocation of this opcode.
1529 **
1530 ** See also: AggStep and AggFinal
1531 */
1535 sqlite3_context ctx;
1554 }
1566 /* If the function returned an error, throw an exception */
1571 }
1573 }
1575 /* Copy the result of the function into register P3 */
1579 }
1584 }
1586 /* Opcode: BitAnd P1 P2 P3 * *
1587 ** Synopsis: r[P3]=r[P1]&r[P2]
1588 **
1589 ** Take the bit-wise AND of the values in register P1 and P2 and
1590 ** store the result in register P3.
1591 ** If either input is NULL, the result is NULL.
1592 */
1593 /* Opcode: BitOr P1 P2 P3 * *
1594 ** Synopsis: r[P3]=r[P1]|r[P2]
1595 **
1596 ** Take the bit-wise OR of the values in register P1 and P2 and
1597 ** store the result in register P3.
1598 ** If either input is NULL, the result is NULL.
1599 */
1600 /* Opcode: ShiftLeft P1 P2 P3 * *
1601 ** Synopsis: r[P3]=r[P2]<<r[P1]
1602 **
1603 ** Shift the integer value in register P2 to the left by the
1604 ** number of bits specified by the integer in register P1.
1605 ** Store the result in register P3.
1606 ** If either input is NULL, the result is NULL.
1607 */
1608 /* Opcode: ShiftRight P1 P2 P3 * *
1609 ** Synopsis: r[P3]=r[P2]>>r[P1]
1610 **
1611 ** Shift the integer value in register P2 to the right by the
1612 ** number of bits specified by the integer in register P1.
1613 ** Store the result in register P3.
1614 ** If either input is NULL, the result is NULL.
1615 */
1620 i64 iA;
1621 u64 uA;
1622 i64 iB;
1623 u8 op;
1631 }
1642 /* If shifting by a negative amount, shift in the other direction */
1647 }
1657 /* Sign-extend on a right shift of a negative number */
1659 }
1661 }
1662 }
1666 }
1668 /* Opcode: AddImm P1 P2 * * *
1669 ** Synopsis: r[P1]=r[P1]+P2
1670 **
1671 ** Add the constant P2 to the value in register P1.
1672 ** The result is always an integer.
1673 **
1674 ** To force any register to be an integer, just add 0.
1675 */
1682 }
1684 /* Opcode: MustBeInt P1 P2 * * *
1685 **
1686 ** Force the value in register P1 to be an integer. If the value
1687 ** in P1 is not an integer and cannot be converted into an integer
1688 ** without data loss, then jump immediately to P2, or if P2==0
1689 ** raise an SQLITE_MISMATCH exception.
1690 */
1703 }
1704 }
1705 }
1708 }
1710 #ifndef SQLITE_OMIT_FLOATING_POINT
1711 /* Opcode: RealAffinity P1 * * * *
1712 **
1713 ** If register P1 holds an integer convert it to a real value.
1714 **
1715 ** This opcode is used when extracting information from a column that
1716 ** has REAL affinity. Such column values may still be stored as
1717 ** integers, for space efficiency, but after extraction we want them
1718 ** to have only a real value.
1719 */
1724 }
1726 }
1727 #endif
1729 #ifndef SQLITE_OMIT_CAST
1730 /* Opcode: Cast P1 P2 * * *
1731 ** Synopsis: affinity(r[P1])
1732 **
1733 ** Force the value in register P1 to be the type defined by P2.
1734 **
1735 ** <ul>
1736 ** <li value="97"> TEXT
1737 ** <li value="98"> BLOB
1738 ** <li value="99"> NUMERIC
1739 ** <li value="100"> INTEGER
1740 ** <li value="101"> REAL
1741 ** </ul>
1742 **
1743 ** A NULL value is not changed by this routine. It remains NULL.
1744 */
1758 }
1761 /* Opcode: Lt P1 P2 P3 P4 P5
1762 ** Synopsis: if r[P1]<r[P3] goto P2
1763 **
1764 ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then
1765 ** jump to address P2.
1766 **
1767 ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
1768 ** reg(P3) is NULL then take the jump. If the SQLITE_JUMPIFNULL
1769 ** bit is clear then fall through if either operand is NULL.
1770 **
1771 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
1772 ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made
1773 ** to coerce both inputs according to this affinity before the
1774 ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
1775 ** affinity is used. Note that the affinity conversions are stored
1776 ** back into the input registers P1 and P3. So this opcode can cause
1777 ** persistent changes to registers P1 and P3.
1778 **
1779 ** Once any conversions have taken place, and neither value is NULL,
1780 ** the values are compared. If both values are blobs then memcmp() is
1781 ** used to determine the results of the comparison. If both values
1782 ** are text, then the appropriate collating function specified in
1783 ** P4 is used to do the comparison. If P4 is not specified then
1784 ** memcmp() is used to compare text string. If both values are
1785 ** numeric, then a numeric comparison is used. If the two values
1786 ** are of different types, then numbers are considered less than
1787 ** strings and strings are considered less than blobs.
1788 **
1789 ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump. Instead,
1790 ** store a boolean result (either 0, or 1, or NULL) in register P2.
1791 **
1792 ** If the SQLITE_NULLEQ bit is set in P5, then NULL values are considered
1793 ** equal to one another, provided that they do not have their MEM_Cleared
1794 ** bit set.
1795 */
1796 /* Opcode: Ne P1 P2 P3 P4 P5
1797 ** Synopsis: if r[P1]!=r[P3] goto P2
1798 **
1799 ** This works just like the Lt opcode except that the jump is taken if
1800 ** the operands in registers P1 and P3 are not equal. See the Lt opcode for
1801 ** additional information.
1802 **
1803 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
1804 ** true or false and is never NULL. If both operands are NULL then the result
1805 ** of comparison is false. If either operand is NULL then the result is true.
1806 ** If neither operand is NULL the result is the same as it would be if
1807 ** the SQLITE_NULLEQ flag were omitted from P5.
1808 */
1809 /* Opcode: Eq P1 P2 P3 P4 P5
1810 ** Synopsis: if r[P1]==r[P3] goto P2
1811 **
1812 ** This works just like the Lt opcode except that the jump is taken if
1813 ** the operands in registers P1 and P3 are equal.
1814 ** See the Lt opcode for additional information.
1815 **
1816 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
1817 ** true or false and is never NULL. If both operands are NULL then the result
1818 ** of comparison is true. If either operand is NULL then the result is false.
1819 ** If neither operand is NULL the result is the same as it would be if
1820 ** the SQLITE_NULLEQ flag were omitted from P5.
1821 */
1822 /* Opcode: Le P1 P2 P3 P4 P5
1823 ** Synopsis: if r[P1]<=r[P3] goto P2
1824 **
1825 ** This works just like the Lt opcode except that the jump is taken if
1826 ** the content of register P3 is less than or equal to the content of
1827 ** register P1. See the Lt opcode for additional information.
1828 */
1829 /* Opcode: Gt P1 P2 P3 P4 P5
1830 ** Synopsis: if r[P1]>r[P3] goto P2
1831 **
1832 ** This works just like the Lt opcode except that the jump is taken if
1833 ** the content of register P3 is greater than the content of
1834 ** register P1. See the Lt opcode for additional information.
1835 */
1836 /* Opcode: Ge P1 P2 P3 P4 P5
1837 ** Synopsis: if r[P1]>=r[P3] goto P2
1838 **
1839 ** This works just like the Lt opcode except that the jump is taken if
1840 ** the content of register P3 is greater than or equal to the content of
1841 ** register P1. See the Lt opcode for additional information.
1842 */
1859 /* One or both operands are NULL */
1861 /* If SQLITE_NULLEQ is set (which will only happen if the operator is
1862 ** OP_Eq or OP_Ne) then take the jump or not depending on whether
1863 ** or not both operands are null.
1864 */
1871 ){
1875 }
1877 /* SQLITE_NULLEQ is clear and at least one operand is NULL,
1878 ** then the result is always NULL.
1879 ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
1880 */
1889 }
1890 }
1892 }
1894 /* Neither operand is NULL. Do a comparison. */
1899 }
1902 }
1908 }
1913 }
1914 }
1919 }
1923 }
1926 }
1934 }
1946 }
1947 }
1948 /* Undo any changes made by applyAffinity() to the input registers. */
1952 }
1954 /* Opcode: Permutation * * * P4 *
1955 **
1956 ** Set the permutation used by the OP_Compare operator to be the array
1957 ** of integers in P4.
1958 **
1959 ** The permutation is only valid until the next OP_Compare that has
1960 ** the OPFLAG_PERMUTE bit set in P5. Typically the OP_Permutation should
1961 ** occur immediately prior to the OP_Compare.
1962 */
1968 }
1970 /* Opcode: Compare P1 P2 P3 P4 P5
1971 ** Synopsis: r[P1@P3] <-> r[P2@P3]
1972 **
1973 ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
1974 ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
1975 ** the comparison for use by the next OP_Jump instruct.
1976 **
1977 ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
1978 ** determined by the most recent OP_Permutation operator. If the
1979 ** OPFLAG_PERMUTE bit is clear, then register are compared in sequential
1980 ** order.
1981 **
1982 ** P4 is a KeyInfo structure that defines collating sequences and sort
1983 ** orders for the comparison. The permutation applies to registers
1984 ** only. The KeyInfo elements are used sequentially.
1985 **
1986 ** The comparison is a sort comparison, so NULLs compare equal,
1987 ** NULLs are less than numbers, numbers are less than strings,
1988 ** and strings are less than blobs.
1989 */
2007 #if SQLITE_DEBUG
2016 }
2031 }
2032 }
2035 }
2037 /* Opcode: Jump P1 P2 P3 * *
2038 **
2039 ** Jump to the instruction at address P1, P2, or P3 depending on whether
2040 ** in the most recent OP_Compare instruction the P1 vector was less than
2041 ** equal to, or greater than the P2 vector, respectively.
2042 */
2050 }
2052 }
2054 /* Opcode: And P1 P2 P3 * *
2055 ** Synopsis: r[P3]=(r[P1] && r[P2])
2056 **
2057 ** Take the logical AND of the values in registers P1 and P2 and
2058 ** write the result into register P3.
2059 **
2060 ** If either P1 or P2 is 0 (false) then the result is 0 even if
2061 ** the other input is NULL. A NULL and true or two NULLs give
2062 ** a NULL output.
2063 */
2064 /* Opcode: Or P1 P2 P3 * *
2065 ** Synopsis: r[P3]=(r[P1] || r[P2])
2066 **
2067 ** Take the logical OR of the values in register P1 and P2 and
2068 ** store the answer in register P3.
2069 **
2070 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
2071 ** even if the other input is NULL. A NULL and false or two NULLs
2072 ** give a NULL output.
2073 */
2084 }
2090 }
2097 }
2104 }
2106 }
2108 /* Opcode: Not P1 P2 * * *
2109 ** Synopsis: r[P2]= !r[P1]
2110 **
2111 ** Interpret the value in register P1 as a boolean value. Store the
2112 ** boolean complement in register P2. If the value in register P1 is
2113 ** NULL, then a NULL is stored in P2.
2114 */
2122 }
2124 }
2126 /* Opcode: BitNot P1 P2 * * *
2127 ** Synopsis: r[P1]= ~r[P1]
2128 **
2129 ** Interpret the content of register P1 as an integer. Store the
2130 ** ones-complement of the P1 value into register P2. If P1 holds
2131 ** a NULL then store a NULL in P2.
2132 */
2140 }
2142 }
2144 /* Opcode: Once P1 P2 * * *
2145 **
2146 ** Check the "once" flag number P1. If it is set, jump to instruction P2.
2147 ** Otherwise, set the flag and fall through to the next instruction.
2148 ** In other words, this opcode causes all following opcodes up through P2
2149 ** (but not including P2) to run just once and to be skipped on subsequent
2150 ** times through the loop.
2151 **
2152 ** All "once" flags are initially cleared whenever a prepared statement
2153 ** first begins to run.
2154 */
2162 }
2164 }
2166 /* Opcode: If P1 P2 P3 * *
2167 **
2168 ** Jump to P2 if the value in register P1 is true. The value
2169 ** is considered true if it is numeric and non-zero. If the value
2170 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
2171 */
2172 /* Opcode: IfNot P1 P2 P3 * *
2173 **
2174 ** Jump to P2 if the value in register P1 is False. The value
2175 ** is considered false if it has a numeric value of zero. If the value
2176 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
2177 */
2185 #ifdef SQLITE_OMIT_FLOATING_POINT
2187 #else
2189 #endif
2191 }
2195 }
2197 }
2199 /* Opcode: IsNull P1 P2 * * *
2200 ** Synopsis: if r[P1]==NULL goto P2
2201 **
2202 ** Jump to P2 if the value in register P1 is NULL.
2203 */
2209 }
2211 }
2213 /* Opcode: NotNull P1 P2 * * *
2214 ** Synopsis: if r[P1]!=NULL goto P2
2215 **
2216 ** Jump to P2 if the value in register P1 is not NULL.
2217 */
2223 }
2225 }
2227 /* Opcode: Column P1 P2 P3 P4 P5
2228 ** Synopsis: r[P3]=PX
2229 **
2230 ** Interpret the data that cursor P1 points to as a structure built using
2231 ** the MakeRecord instruction. (See the MakeRecord opcode for additional
2232 ** information about the format of the data.) Extract the P2-th column
2233 ** from this record. If there are less that (P2+1)
2234 ** values in the record, extract a NULL.
2235 **
2236 ** The value extracted is stored in register P3.
2237 **
2238 ** If the column contains fewer than P2 fields, then extract a NULL. Or,
2239 ** if the P4 argument is a P4_MEM use the value of the P4 argument as
2240 ** the result.
2241 **
2242 ** If the OPFLAG_CLEARCACHE bit is set on P5 and P1 is a pseudo-table cursor,
2243 ** then the cache of the cursor is reset prior to extracting the column.
2244 ** The first OP_Column against a pseudo-table after the value of the content
2245 ** register has changed should have this bit set.
2246 **
2247 ** If the OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG bits are set on P5 when
2248 ** the result is guaranteed to only be used as the argument of a length()
2249 ** or typeof() function, respectively. The loading of large blobs can be
2250 ** skipped for length() and all content loading can be skipped for typeof().
2251 */
2281 #ifndef SQLITE_OMIT_VIRTUALTABLE
2283 #endif
2288 /* If the cursor cache is stale, bring it up-to-date */
2303 }
2310 /* sqlite3BtreeParseCellPtr() uses getVarint32() to extract the
2311 ** payload size, so it is impossible for payloadSize64 to be
2312 ** larger than 32 bits. */
2321 }
2327 }
2330 }
2331 }
2337 /* Make sure a corrupt database has not given us an oversize header.
2338 ** Do this now to avoid an oversize memory allocation.
2339 **
2340 ** Type entries can be between 1 and 5 bytes each. But 4 and 5 byte
2341 ** types use so much data space that there can only be 4096 and 32 of
2342 ** them, respectively. So the maximum header length results from a
2343 ** 3-byte type for each of the maximum of 32768 columns plus three
2344 ** extra bytes for the header length itself. 32768*3 + 3 = 98307.
2345 */
2349 }
2352 /* pC->aRow does not have to hold the entire row, but it does at least
2353 ** need to cover the header of the record. If pC->aRow does not contain
2354 ** the complete header, then set it to zero, forcing the header to be
2355 ** dynamically allocated. */
2358 }
2360 /* The following goto is an optimization. It can be omitted and
2361 ** everything will still work. But OP_Column is measurably faster
2362 ** by skipping the subsequent conditional, which is always true.
2363 */
2366 }
2368 /* Make sure at least the first p2+1 entries of the header have been
2369 ** parsed and valid information is in aOffset[] and pC->aType[].
2370 */
2372 /* If there is more header available for parsing in the record, try
2373 ** to extract additional fields up through the p2+1-th field
2374 */
2375 op_column_read_header:
2377 /* Make sure zData points to enough of the record to cover the header. */
2384 }
2388 }
2390 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
2399 zHdr++;
2402 }
2409 }
2410 i++;
2418 }
2420 /* The record is corrupt if any of the following are true:
2421 ** (1) the bytes of the header extend past the declared header size
2422 ** (zHdr>zEndHdr)
2423 ** (2) the entire header was used but not all data was used
2424 ** (zHdr==zEndHdr && offset!=pC->payloadSize)
2425 ** (3) the end of the data extends beyond the end of the record.
2426 ** (offset > pC->payloadSize)
2427 */
2430 ){
2433 }
2434 }
2436 /* If after trying to extra new entries from the header, nHdrParsed is
2437 ** still not up to p2, that means that the record has fewer than p2
2438 ** columns. So the result will be either the default value or a NULL.
2439 */
2445 }
2447 }
2448 }
2450 /* Extract the content for the p2+1-th column. Control can only
2451 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
2452 ** all valid.
2453 */
2460 /* This is the common case where the desired content fits on the original
2461 ** page - where the content is not on an overflow page */
2464 /* This branch happens only when content is on overflow pages */
2468 ){
2469 /* Content is irrelevant for
2470 ** 1. the typeof() function,
2471 ** 2. the length(X) function if X is a blob, and
2472 ** 3. if the content length is zero.
2473 ** So we might as well use bogus content rather than reading
2474 ** content from disk. NULL will work for the value for strings
2475 ** and blobs and whatever is in the payloadSize64 variable
2476 ** will work for everything else. */
2480 pDest);
2483 }
2486 }
2487 }
2490 op_column_out:
2491 /* If the column value is an ephemeral string, go ahead and persist
2492 ** that string in case the cursor moves before the column value is
2493 ** used. The following code does the equivalent of Deephemeralize()
2494 ** but does it faster. */
2505 }
2506 op_column_error:
2510 }
2512 /* Opcode: Affinity P1 P2 * P4 *
2513 ** Synopsis: affinity(r[P1@P2])
2514 **
2515 ** Apply affinities to a range of P2 registers starting with P1.
2516 **
2517 ** P4 is a string that is P2 characters long. The nth character of the
2518 ** string indicates the column affinity that should be used for the nth
2519 ** memory cell in the range.
2520 */
2533 pIn1++;
2534 }
2536 }
2538 /* Opcode: MakeRecord P1 P2 P3 P4 *
2539 ** Synopsis: r[P3]=mkrec(r[P1@P2])
2540 **
2541 ** Convert P2 registers beginning with P1 into the [record format]
2542 ** use as a data record in a database table or as a key
2543 ** in an index. The OP_Column opcode can decode the record later.
2544 **
2545 ** P4 may be a string that is P2 characters long. The nth character of the
2546 ** string indicates the column affinity that should be used for the nth
2547 ** field of the index key.
2548 **
2549 ** The mapping from character to affinity is given by the SQLITE_AFF_
2550 ** macros defined in sqliteInt.h.
2551 **
2552 ** If P4 is NULL then all index fields have the affinity NONE.
2553 */
2572 /* Assuming the record contains N fields, the record format looks
2573 ** like this:
2574 **
2575 ** ------------------------------------------------------------------------
2576 ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
2577 ** ------------------------------------------------------------------------
2578 **
2579 ** Data(0) is taken from register P1. Data(1) comes from register P1+1
2580 ** and so forth.
2581 **
2582 ** Each type field is a varint representing the serial type of the
2583 ** corresponding data element (see sqlite3VdbeSerialType()). The
2584 ** hdr-size field is also a varint which is the offset from the beginning
2585 ** of the record to data0.
2586 */
2598 /* Identify the output register */
2603 /* Apply the requested affinity to all inputs
2604 */
2612 }
2614 /* Loop through the elements that will make up the record to figure
2615 ** out how much space is required for the new record.
2616 */
2628 }
2629 }
2636 /* Add the initial header varint and total the size */
2640 /* The common case */
2643 /* Rare case of a really large header */
2647 }
2651 }
2653 /* Make sure the output register has a buffer large enough to store
2654 ** the new record. The output register (pOp->p3) is not allowed to
2655 ** be one of the input registers (because the following call to
2656 ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used).
2657 */
2660 }
2663 /* Write the record */
2682 }
2687 }
2689 /* Opcode: Count P1 P2 * * *
2690 ** Synopsis: r[P2]=count()
2691 **
2692 ** Store the number of entries (an integer value) in the table or index
2693 ** opened by cursor P1 in register P2
2694 */
2695 #ifndef SQLITE_OMIT_BTREECOUNT
2697 i64 nEntry;
2706 }
2707 #endif
2709 /* Opcode: Savepoint P1 * * P4 *
2710 **
2711 ** Open, release or rollback the savepoint named by parameter P4, depending
2712 ** on the value of P1. To open a new savepoint, P1==0. To release (commit) an
2713 ** existing savepoint, P1==1, or to rollback an existing savepoint P1==2.
2714 */
2728 /* Assert that the p1 parameter is valid. Also that if there is no open
2729 ** transaction, then there cannot be any savepoints.
2730 */
2739 /* A new savepoint cannot be created if there are active write
2740 ** statements (i.e. open read/write incremental blob handles).
2741 */
2748 #ifndef SQLITE_OMIT_VIRTUALTABLE
2749 /* This call is Ok even if this savepoint is actually a transaction
2750 ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
2751 ** If this is a transaction savepoint being opened, it is guaranteed
2752 ** that the db->aVTrans[] array is empty. */
2757 #endif
2759 /* Create a new savepoint structure. */
2765 /* If there is no open transaction, then mark this as a special
2766 ** "transaction savepoint". */
2772 }
2774 /* Link the new savepoint into the database handle's list. */
2779 }
2780 }
2784 /* Find the named savepoint. If there is no such savepoint, then an
2785 ** an error is returned to the user. */
2790 ){
2791 iSavepoint++;
2792 }
2797 /* It is not possible to release (commit) a savepoint if there are
2798 ** active write statements.
2799 */
2801 "cannot release savepoint - SQL statements in progress"
2802 );
2806 /* Determine whether or not this is a transaction savepoint. If so,
2807 ** and this is a RELEASE command, then the current transaction
2808 ** is committed.
2809 */
2814 }
2821 }
2831 SQLITE_ABORT_ROLLBACK,
2834 }
2837 }
2842 }
2843 }
2848 }
2849 }
2851 /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
2852 ** savepoints nested inside of the savepoint being operated on. */
2858 }
2860 /* If it is a RELEASE, then destroy the savepoint being operated on
2861 ** too. If it is a ROLLBACK TO, then set the number of deferred
2862 ** constraint violations present in the database to the value stored
2863 ** when the savepoint was created. */
2870 }
2874 }
2879 }
2880 }
2881 }
2884 }
2886 /* Opcode: AutoCommit P1 P2 * * *
2887 **
2888 ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
2889 ** back any currently active btree transactions. If there are any active
2890 ** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if
2891 ** there are active writing VMs or active VMs that use shared cache.
2892 **
2893 ** This instruction causes the VM to halt.
2894 */
2908 #if 0
2910 /* If this instruction implements a ROLLBACK and other VMs are
2911 ** still running, and a transaction is active, return an error indicating
2912 ** that the other VMs must complete first.
2913 */
2918 #endif
2920 /* If this instruction implements a COMMIT and other VMs are writing
2921 ** return an error indicating that the other VMs must complete first.
2922 */
2940 }
2941 }
2948 }
2957 }
2959 }
2961 /* Opcode: Transaction P1 P2 P3 P4 P5
2962 **
2963 ** Begin a transaction on database P1 if a transaction is not already
2964 ** active.
2965 ** If P2 is non-zero, then a write-transaction is started, or if a
2966 ** read-transaction is already active, it is upgraded to a write-transaction.
2967 ** If P2 is zero, then a read-transaction is started.
2968 **
2969 ** P1 is the index of the database file on which the transaction is
2970 ** started. Index 0 is the main database file and index 1 is the
2971 ** file used for temporary tables. Indices of 2 or more are used for
2972 ** attached databases.
2973 **
2974 ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
2975 ** true (this flag is set if the Vdbe may modify more than one row and may
2976 ** throw an ABORT exception), a statement transaction may also be opened.
2977 ** More specifically, a statement transaction is opened iff the database
2978 ** connection is currently not in autocommit mode, or if there are other
2979 ** active statements. A statement transaction allows the changes made by this
2980 ** VDBE to be rolled back after an error without having to roll back the
2981 ** entire transaction. If no error is encountered, the statement transaction
2982 ** will automatically commit when the VDBE halts.
2983 **
2984 ** If P5!=0 then this opcode also checks the schema cookie against P3
2985 ** and the schema generation counter against P4.
2986 ** The cookie changes its value whenever the database schema changes.
2987 ** This operation is used to detect when that the cookie has changed
2988 ** and that the current process needs to reread the schema. If the schema
2989 ** cookie in P3 differs from the schema cookie in the database header or
2990 ** if the schema generation counter in P4 differs from the current
2991 ** generation counter, then an SQLITE_SCHEMA error is raised and execution
2992 ** halts. The sqlite3_step() wrapper function might then reprepare the
2993 ** statement and rerun it from the beginning.
2994 */
3007 }
3016 }
3019 }
3023 ){
3029 }
3034 }
3036 /* Store the current value of the database handles deferred constraint
3037 ** counter. If the statement transaction needs to be rolled back,
3038 ** the value of this counter needs to be restored too. */
3041 }
3043 /* Gather the schema version number for checking */
3048 }
3053 /* If the schema-cookie from the database file matches the cookie
3054 ** stored with the in-memory representation of the schema, do
3055 ** not reload the schema from the database file.
3056 **
3057 ** If virtual-tables are in use, this is not just an optimization.
3058 ** Often, v-tables store their data in other SQLite tables, which
3059 ** are queried from within xNext() and other v-table methods using
3060 ** prepared queries. If such a query is out-of-date, we do not want to
3061 ** discard the database schema, as the user code implementing the
3062 ** v-table would have to be ready for the sqlite3_vtab structure itself
3063 ** to be invalidated whenever sqlite3_step() is called from within
3064 ** a v-table method.
3065 */
3068 }
3071 }
3073 }
3075 /* Opcode: ReadCookie P1 P2 P3 * *
3076 **
3077 ** Read cookie number P3 from database P1 and write it into register P2.
3078 ** P3==1 is the schema version. P3==2 is the database format.
3079 ** P3==3 is the recommended pager cache size, and so forth. P1==0 is
3080 ** the main database file and P1==1 is the database file used to store
3081 ** temporary tables.
3082 **
3083 ** There must be a read-lock on the database (either a transaction
3084 ** must be started or there must be an open cursor) before
3085 ** executing this instruction.
3086 */
3103 }
3105 /* Opcode: SetCookie P1 P2 P3 * *
3106 **
3107 ** Write the content of register P3 (interpreted as an integer)
3108 ** into cookie number P2 of database P1. P2==1 is the schema version.
3109 ** P2==2 is the database format. P2==3 is the recommended pager cache
3110 ** size, and so forth. P1==0 is the main database file and P1==1 is the
3111 ** database file used to store temporary tables.
3112 **
3113 ** A transaction must be started before executing this opcode.
3114 */
3126 /* See note about index shifting on OP_ReadCookie */
3129 /* When the schema cookie changes, record the new cookie internally */
3133 /* Record changes in the file format */
3135 }
3137 /* Invalidate all prepared statements whenever the TEMP database
3138 ** schema is changed. Ticket #1644 */
3141 }
3143 }
3145 /* Opcode: OpenRead P1 P2 P3 P4 P5
3146 ** Synopsis: root=P2 iDb=P3
3147 **
3148 ** Open a read-only cursor for the database table whose root page is
3149 ** P2 in a database file. The database file is determined by P3.
3150 ** P3==0 means the main database, P3==1 means the database used for
3151 ** temporary tables, and P3>1 means used the corresponding attached
3152 ** database. Give the new cursor an identifier of P1. The P1
3153 ** values need not be contiguous but all P1 values should be small integers.
3154 ** It is an error for P1 to be negative.
3155 **
3156 ** If P5!=0 then use the content of register P2 as the root page, not
3157 ** the value of P2 itself.
3158 **
3159 ** There will be a read lock on the database whenever there is an
3160 ** open cursor. If the database was unlocked prior to this instruction
3161 ** then a read lock is acquired as part of this instruction. A read
3162 ** lock allows other processes to read the database but prohibits
3163 ** any other process from modifying the database. The read lock is
3164 ** released when all cursors are closed. If this instruction attempts
3165 ** to get a read lock but fails, the script terminates with an
3166 ** SQLITE_BUSY error code.
3167 **
3168 ** The P4 value may be either an integer (P4_INT32) or a pointer to
3169 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
3170 ** structure, then said structure defines the content and collating
3171 ** sequence of the index being opened. Otherwise, if P4 is an integer
3172 ** value, it is set to the number of columns in the table.
3173 **
3174 ** See also: OpenWrite, ReopenIdx
3175 */
3176 /* Opcode: ReopenIdx P1 P2 P3 P4 P5
3177 ** Synopsis: root=P2 iDb=P3
3178 **
3179 ** The ReopenIdx opcode works exactly like ReadOpen except that it first
3180 ** checks to see if the cursor on P1 is already open with a root page
3181 ** number of P2 and if it is this opcode becomes a no-op. In other words,
3182 ** if the cursor is already open, do not reopen it.
3183 **
3184 ** The ReopenIdx opcode may only be used with P5==0 and with P4 being
3185 ** a P4_KEYINFO object. Furthermore, the P3 value must be the same as
3186 ** every other ReopenIdx or OpenRead for the same cursor number.
3187 **
3188 ** See the OpenRead opcode documentation for additional information.
3189 */
3190 /* Opcode: OpenWrite P1 P2 P3 P4 P5
3191 ** Synopsis: root=P2 iDb=P3
3192 **
3193 ** Open a read/write cursor named P1 on the table or index whose root
3194 ** page is P2. Or if P5!=0 use the content of register P2 to find the
3195 ** root page.
3196 **
3197 ** The P4 value may be either an integer (P4_INT32) or a pointer to
3198 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
3199 ** structure, then said structure defines the content and collating
3200 ** sequence of the index being opened. Otherwise, if P4 is an integer
3201 ** value, it is set to the number of columns in the table, or to the
3202 ** largest index of any column of the table that is actually used.
3203 **
3204 ** This instruction works just like OpenRead except that it opens the cursor
3205 ** in read/write mode. For a given table, there can be one or more read-only
3206 ** cursors or a single read/write cursor but not both.
3207 **
3208 ** See also OpenRead.
3209 */
3219 }
3220 /* If the cursor is not currently open or is open on a different
3221 ** index, then fall through into OP_OpenRead to force a reopen */
3222 }
3243 }
3259 }
3262 }
3271 /* The p2 value always comes from a prior OP_CreateTable opcode and
3272 ** that opcode will always set the p2 value to 2 or more or else fail.
3273 ** If there were a failure, the prepared statement would have halted
3274 ** before reaching this instruction. */
3278 }
3279 }
3287 }
3301 /* Set the VdbeCursor.isTable variable. Previous versions of
3302 ** SQLite used to check if the root-page flags were sane at this point
3303 ** and report database corruption if they were not, but this check has
3304 ** since moved into the btree layer. */
3307 }
3309 /* Opcode: OpenEphemeral P1 P2 * P4 P5
3310 ** Synopsis: nColumn=P2
3311 **
3312 ** Open a new cursor P1 to a transient table.
3313 ** The cursor is always opened read/write even if
3314 ** the main database is read-only. The ephemeral
3315 ** table is deleted automatically when the cursor is closed.
3316 **
3317 ** P2 is the number of columns in the ephemeral table.
3318 ** The cursor points to a BTree table if P4==0 and to a BTree index
3319 ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
3320 ** that defines the format of keys in the index.
3321 **
3322 ** The P5 parameter can be a mask of the BTREE_* flags defined
3323 ** in btree.h. These flags control aspects of the operation of
3324 ** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
3325 ** added automatically.
3326 */
3327 /* Opcode: OpenAutoindex P1 P2 * P4 *
3328 ** Synopsis: nColumn=P2
3329 **
3330 ** This opcode works the same as OP_OpenEphemeral. It has a
3331 ** different name to distinguish its use. Tables created using
3332 ** by this opcode will be used for automatically created transient
3333 ** indices in joins.
3334 */
3341 SQLITE_OPEN_READWRITE |
3342 SQLITE_OPEN_CREATE |
3343 SQLITE_OPEN_EXCLUSIVE |
3344 SQLITE_OPEN_DELETEONCLOSE |
3345 SQLITE_OPEN_TRANSIENT_DB;
3356 }
3358 /* If a transient index is required, create it by calling
3359 ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
3360 ** opening it. If a transient table is required, just use the
3361 ** automatically created table with root-page 1 (an BLOB_INTKEY table).
3362 */
3373 }
3378 }
3379 }
3382 }
3384 /* Opcode: SorterOpen P1 P2 P3 P4 *
3385 **
3386 ** This opcode works like OP_OpenEphemeral except that it opens
3387 ** a transient index that is specifically designed to sort large
3388 ** tables using an external merge-sort algorithm.
3389 **
3390 ** If argument P3 is non-zero, then it indicates that the sorter may
3391 ** assume that a stable sort considering the first P3 fields of each
3392 ** key is sufficient to produce the required results.
3393 */
3406 }
3408 /* Opcode: SequenceTest P1 P2 * * *
3409 ** Synopsis: if( cursor[P1].ctr++ ) pc = P2
3410 **
3411 ** P1 is a sorter cursor. If the sequence counter is currently zero, jump
3412 ** to P2. Regardless of whether or not the jump is taken, increment the
3413 ** the sequence value.
3414 */
3422 }
3424 }
3426 /* Opcode: OpenPseudo P1 P2 P3 * *
3427 ** Synopsis: P3 columns in r[P2]
3428 **
3429 ** Open a new cursor that points to a fake table that contains a single
3430 ** row of data. The content of that one row is the content of memory
3431 ** register P2. In other words, cursor P1 becomes an alias for the
3432 ** MEM_Blob content contained in register P2.
3433 **
3434 ** A pseudo-table created by this opcode is used to hold a single
3435 ** row output from the sorter so that the row can be decomposed into
3436 ** individual columns using the OP_Column opcode. The OP_Column opcode
3437 ** is the only cursor opcode that works with a pseudo-table.
3438 **
3439 ** P3 is the number of fields in the records that will be stored by
3440 ** the pseudo-table.
3441 */
3454 }
3456 /* Opcode: Close P1 * * * *
3457 **
3458 ** Close a cursor previously opened as P1. If P1 is not
3459 ** currently open, this instruction is a no-op.
3460 */
3466 }
3468 /* Opcode: SeekGE P1 P2 P3 P4 *
3469 ** Synopsis: key=r[P3@P4]
3470 **
3471 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
3472 ** use the value in register P3 as the key. If cursor P1 refers
3473 ** to an SQL index, then P3 is the first in an array of P4 registers
3474 ** that are used as an unpacked index key.
3475 **
3476 ** Reposition cursor P1 so that it points to the smallest entry that
3477 ** is greater than or equal to the key value. If there are no records
3478 ** greater than or equal to the key and P2 is not zero, then jump to P2.
3479 **
3480 ** This opcode leaves the cursor configured to move in forward order,
3481 ** from the beginning toward the end. In other words, the cursor is
3482 ** configured to use Next, not Prev.
3483 **
3484 ** See also: Found, NotFound, SeekLt, SeekGt, SeekLe
3485 */
3486 /* Opcode: SeekGT P1 P2 P3 P4 *
3487 ** Synopsis: key=r[P3@P4]
3488 **
3489 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
3490 ** use the value in register P3 as a key. If cursor P1 refers
3491 ** to an SQL index, then P3 is the first in an array of P4 registers
3492 ** that are used as an unpacked index key.
3493 **
3494 ** Reposition cursor P1 so that it points to the smallest entry that
3495 ** is greater than the key value. If there are no records greater than
3496 ** the key and P2 is not zero, then jump to P2.
3497 **
3498 ** This opcode leaves the cursor configured to move in forward order,
3499 ** from the beginning toward the end. In other words, the cursor is
3500 ** configured to use Next, not Prev.
3501 **
3502 ** See also: Found, NotFound, SeekLt, SeekGe, SeekLe
3503 */
3504 /* Opcode: SeekLT P1 P2 P3 P4 *
3505 ** Synopsis: key=r[P3@P4]
3506 **
3507 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
3508 ** use the value in register P3 as a key. If cursor P1 refers
3509 ** to an SQL index, then P3 is the first in an array of P4 registers
3510 ** that are used as an unpacked index key.
3511 **
3512 ** Reposition cursor P1 so that it points to the largest entry that
3513 ** is less than the key value. If there are no records less than
3514 ** the key and P2 is not zero, then jump to P2.
3515 **
3516 ** This opcode leaves the cursor configured to move in reverse order,
3517 ** from the end toward the beginning. In other words, the cursor is
3518 ** configured to use Prev, not Next.
3519 **
3520 ** See also: Found, NotFound, SeekGt, SeekGe, SeekLe
3521 */
3522 /* Opcode: SeekLE P1 P2 P3 P4 *
3523 ** Synopsis: key=r[P3@P4]
3524 **
3525 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
3526 ** use the value in register P3 as a key. If cursor P1 refers
3527 ** to an SQL index, then P3 is the first in an array of P4 registers
3528 ** that are used as an unpacked index key.
3529 **
3530 ** Reposition cursor P1 so that it points to the largest entry that
3531 ** is less than or equal to the key value. If there are no records
3532 ** less than or equal to the key and P2 is not zero, then jump to P2.
3533 **
3534 ** This opcode leaves the cursor configured to move in reverse order,
3535 ** from the end toward the beginning. In other words, the cursor is
3536 ** configured to use Prev, not Next.
3537 **
3538 ** See also: Found, NotFound, SeekGt, SeekGe, SeekLt
3539 */
3547 UnpackedRecord r;
3563 #ifdef SQLITE_DEBUG
3565 #endif
3567 /* The input value in P3 might be of any type: integer, real, string,
3568 ** blob, or NULL. But it needs to be an integer before we can do
3569 ** the seek, so convert it. */
3573 }
3576 /* If the P3 value could not be converted into an integer without
3577 ** loss of information, then special processing is required... */
3580 /* If the P3 value cannot be converted into any kind of a number,
3581 ** then the seek is not possible, so jump to P2 */
3584 }
3586 /* If the approximation iKey is larger than the actual real search
3587 ** term, substitute >= for > and < for <=. e.g. if the search term
3588 ** is 4.9 and the integer approximation 5:
3589 **
3590 ** (x > 4.9) -> (x >= 5)
3591 ** (x <= 4.9) -> (x < 5)
3592 */
3598 }
3600 /* If the approximation iKey is smaller than the actual real search
3601 ** term, substitute <= for < and > for >=. */
3607 }
3608 }
3613 }
3621 /* The next line of code computes as follows, only faster:
3622 ** if( oc==OP_SeekGT || oc==OP_SeekLE ){
3623 ** r.default_rc = -1;
3624 ** }else{
3625 ** r.default_rc = +1;
3626 ** }
3627 */
3635 #ifdef SQLITE_DEBUG
3637 #endif
3642 }
3643 }
3646 #ifdef SQLITE_TEST
3647 sqlite3_search_count++;
3648 #endif
3656 }
3664 /* res might be negative because the table is empty. Check to
3665 ** see if this is the case.
3666 */
3668 }
3669 }
3674 }
3676 }
3678 /* Opcode: Seek P1 P2 * * *
3679 ** Synopsis: intkey=r[P2]
3680 **
3681 ** P1 is an open table cursor and P2 is a rowid integer. Arrange
3682 ** for P1 to move so that it points to the rowid given by P2.
3683 **
3684 ** This is actually a deferred seek. Nothing actually happens until
3685 ** the cursor is used to read a record. That way, if no reads
3686 ** occur, no unnecessary I/O happens.
3687 */
3701 }
3704 /* Opcode: Found P1 P2 P3 P4 *
3705 ** Synopsis: key=r[P3@P4]
3706 **
3707 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
3708 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
3709 ** record.
3710 **
3711 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
3712 ** is a prefix of any entry in P1 then a jump is made to P2 and
3713 ** P1 is left pointing at the matching entry.
3714 **
3715 ** This operation leaves the cursor in a state where it can be
3716 ** advanced in the forward direction. The Next instruction will work,
3717 ** but not the Prev instruction.
3718 **
3719 ** See also: NotFound, NoConflict, NotExists. SeekGe
3720 */
3721 /* Opcode: NotFound P1 P2 P3 P4 *
3722 ** Synopsis: key=r[P3@P4]
3723 **
3724 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
3725 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
3726 ** record.
3727 **
3728 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
3729 ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
3730 ** does contain an entry whose prefix matches the P3/P4 record then control
3731 ** falls through to the next instruction and P1 is left pointing at the
3732 ** matching entry.
3733 **
3734 ** This operation leaves the cursor in a state where it cannot be
3735 ** advanced in either direction. In other words, the Next and Prev
3736 ** opcodes do not work after this operation.
3737 **
3738 ** See also: Found, NotExists, NoConflict
3739 */
3740 /* Opcode: NoConflict P1 P2 P3 P4 *
3741 ** Synopsis: key=r[P3@P4]
3742 **
3743 ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
3744 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
3745 ** record.
3746 **
3747 ** Cursor P1 is on an index btree. If the record identified by P3 and P4
3748 ** contains any NULL value, jump immediately to P2. If all terms of the
3749 ** record are not-NULL then a check is done to determine if any row in the
3750 ** P1 index btree has a matching key prefix. If there are no matches, jump
3751 ** immediately to P2. If there is a match, fall through and leave the P1
3752 ** cursor pointing to the matching row.
3753 **
3754 ** This opcode is similar to OP_NotFound with the exceptions that the
3755 ** branch is always taken if any part of the search key input is NULL.
3756 **
3757 ** This operation leaves the cursor in a state where it cannot be
3758 ** advanced in either direction. In other words, the Next and Prev
3759 ** opcodes do not work after this operation.
3760 **
3761 ** See also: NotFound, Found, NotExists
3762 */
3772 UnpackedRecord r;
3775 #ifdef SQLITE_TEST
3777 #endif
3783 #ifdef SQLITE_DEBUG
3785 #endif
3797 #ifdef SQLITE_DEBUG
3799 #endif
3800 }
3805 );
3810 }
3813 /* For the OP_NoConflict opcode, take the jump if any of the
3814 ** input fields are NULL, since any key with a NULL will not
3815 ** conflict */
3820 }
3821 }
3822 }
3826 }
3829 }
3841 }
3843 }
3845 /* Opcode: NotExists P1 P2 P3 * *
3846 ** Synopsis: intkey=r[P3]
3847 **
3848 ** P1 is the index of a cursor open on an SQL table btree (with integer
3849 ** keys). P3 is an integer rowid. If P1 does not contain a record with
3850 ** rowid P3 then jump immediately to P2. If P1 does contain a record
3851 ** with rowid P3 then leave the cursor pointing at that record and fall
3852 ** through to the next instruction.
3853 **
3854 ** The OP_NotFound opcode performs the same operation on index btrees
3855 ** (with arbitrary multi-value keys).
3856 **
3857 ** This opcode leaves the cursor in a state where it cannot be advanced
3858 ** in either direction. In other words, the Next and Prev opcodes will
3859 ** not work following this opcode.
3860 **
3861 ** See also: Found, NotFound, NoConflict
3862 */
3867 u64 iKey;
3874 #ifdef SQLITE_DEBUG
3876 #endif
3891 }
3894 }
3896 /* Opcode: Sequence P1 P2 * * *
3897 ** Synopsis: r[P2]=cursor[P1].ctr++
3898 **
3899 ** Find the next available sequence number for cursor P1.
3900 ** Write the sequence number into register P2.
3901 ** The sequence number on the cursor is incremented after this
3902 ** instruction.
3903 */
3909 }
3912 /* Opcode: NewRowid P1 P2 P3 * *
3913 ** Synopsis: r[P2]=rowid
3914 **
3915 ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
3916 ** The record number is not previously used as a key in the database
3917 ** table that cursor P1 points to. The new record number is written
3918 ** written to register P2.
3919 **
3920 ** If P3>0 then P3 is a register in the root frame of this VDBE that holds
3921 ** the largest previously generated record number. No new record numbers are
3922 ** allowed to be less than this value. When this value reaches its maximum,
3923 ** an SQLITE_FULL error is generated. The P3 register is updated with the '
3924 ** generated record number. This P3 mechanism is used to help implement the
3925 ** AUTOINCREMENT feature.
3926 */
3941 /* The zero initialization above is all that is needed */
3943 /* The next rowid or record number (different terms for the same
3944 ** thing) is obtained in a two-step algorithm.
3945 **
3946 ** First we attempt to find the largest existing rowid and add one
3947 ** to that. But if the largest existing rowid is already the maximum
3948 ** positive integer, we have to fall through to the second
3949 ** probabilistic algorithm
3950 **
3951 ** The second algorithm is to select a rowid at random and see if
3952 ** it already exists in the table. If it does not exist, we have
3953 ** succeeded. If the random rowid does exist, we select a new one
3954 ** and try again, up to 100 times.
3955 */
3958 #ifdef SQLITE_32BIT_ROWID
3959 # define MAX_ROWID 0x7fffffff
3960 #else
3961 /* Some compilers complain about constants of the form 0x7fffffffffffffff.
3962 ** Others complain about 0x7ffffffffffffffffLL. The following macro seems
3963 ** to provide the constant while making all compilers happy.
3964 */
3965 # define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
3966 #endif
3972 }
3983 }
3984 }
3985 }
3987 #ifndef SQLITE_OMIT_AUTOINCREMENT
3989 /* Assert that P3 is a valid memory cell. */
3993 /* Assert that P3 is a valid memory cell. */
3997 /* Assert that P3 is a valid memory cell. */
4001 }
4010 }
4013 }
4015 }
4016 #endif
4018 /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
4019 ** largest possible integer (9223372036854775807) then the database
4020 ** engine starts picking positive candidate ROWIDs at random until
4021 ** it finds one that is not previously used. */
4023 ** an AUTOINCREMENT table. */
4035 }
4037 }
4040 }
4043 }
4045 /* Opcode: Insert P1 P2 P3 P4 P5
4046 ** Synopsis: intkey=r[P3] data=r[P2]
4047 **
4048 ** Write an entry into the table of cursor P1. A new entry is
4049 ** created if it doesn't already exist or the data for an existing
4050 ** entry is overwritten. The data is the value MEM_Blob stored in register
4051 ** number P2. The key is stored in register P3. The key must
4052 ** be a MEM_Int.
4053 **
4054 ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
4055 ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set,
4056 ** then rowid is stored for subsequent return by the
4057 ** sqlite3_last_insert_rowid() function (otherwise it is unmodified).
4058 **
4059 ** If the OPFLAG_USESEEKRESULT flag of P5 is set and if the result of
4060 ** the last seek operation (OP_NotExists) was a success, then this
4061 ** operation will not attempt to find the appropriate row before doing
4062 ** the insert but will instead overwrite the row that the cursor is
4063 ** currently pointing to. Presumably, the prior OP_NotExists opcode
4064 ** has already positioned the cursor correctly. This is an optimization
4065 ** that boosts performance by avoiding redundant seeks.
4066 **
4067 ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
4068 ** UPDATE operation. Otherwise (if the flag is clear) then this opcode
4069 ** is part of an INSERT operation. The difference is only important to
4070 ** the update hook.
4071 **
4072 ** Parameter P4 may point to a string containing the table-name, or
4073 ** may be NULL. If it is not NULL, then the update-hook
4074 ** (sqlite3.xUpdateCallback) is invoked following a successful insert.
4075 **
4076 ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
4077 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
4078 ** and register P2 becomes ephemeral. If the cursor is changed, the
4079 ** value of register P2 will then change. Make sure this does not
4080 ** cause any problems.)
4081 **
4082 ** This instruction only works on tables. The equivalent instruction
4083 ** for indices is OP_IdxInsert.
4084 */
4085 /* Opcode: InsertInt P1 P2 P3 P4 P5
4086 ** Synopsis: intkey=P3 data=r[P2]
4087 **
4088 ** This works exactly like OP_Insert except that the key is the
4089 ** integer value P3, not the value of the integer stored in register P3.
4090 */
4122 }
4131 }
4137 }
4141 );
4145 /* Invoke the update-hook if required. */
4153 }
4155 }
4157 /* Opcode: Delete P1 P2 * P4 *
4158 **
4159 ** Delete the record at which the P1 cursor is currently pointing.
4160 **
4161 ** The cursor will be left pointing at either the next or the previous
4162 ** record in the table. If it is left pointing at the next record, then
4163 ** the next Next instruction will be a no-op. Hence it is OK to delete
4164 ** a record from within a Next loop.
4165 **
4166 ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
4167 ** incremented (otherwise not).
4168 **
4169 ** P1 must not be pseudo-table. It has to be a real table with
4170 ** multiple rows.
4171 **
4172 ** If P4 is not NULL, then it is the name of the table that P1 is
4173 ** pointing to. The update hook will be invoked, if it exists.
4174 ** If P4 is not NULL then the P1 cursor must have been positioned
4175 ** using OP_NotFound prior to invoking this opcode.
4176 */
4186 #ifdef SQLITE_DEBUG
4187 /* The seek operation that positioned the cursor prior to OP_Delete will
4188 ** have also set the pC->movetoTarget field to the rowid of the row that
4189 ** is being deleted */
4194 }
4195 #endif
4200 /* Invoke the update-hook if required. */
4205 }
4208 }
4209 /* Opcode: ResetCount * * * * *
4210 **
4211 ** The value of the change counter is copied to the database handle
4212 ** change counter (returned by subsequent calls to sqlite3_changes()).
4213 ** Then the VMs internal change counter resets to 0.
4214 ** This is used by trigger programs.
4215 */
4220 }
4222 /* Opcode: SorterCompare P1 P2 P3 P4
4223 ** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2
4224 **
4225 ** P1 is a sorter cursor. This instruction compares a prefix of the
4226 ** record blob in register P3 against a prefix of the entry that
4227 ** the sorter cursor currently points to. Only the first P4 fields
4228 ** of r[P3] and the sorter record are compared.
4229 **
4230 ** If either P3 or the sorter contains a NULL in one of their significant
4231 ** fields (not counting the P4 fields at the end which are ignored) then
4232 ** the comparison is assumed to be equal.
4233 **
4234 ** Fall through to next instruction if the two records compare equal to
4235 ** each other. Jump to P2 if they are different.
4236 */
4252 }
4254 };
4256 /* Opcode: SorterData P1 P2 P3 * *
4257 ** Synopsis: r[P2]=data
4258 **
4259 ** Write into register P2 the current sorter data for sorter cursor P1.
4260 ** Then clear the column header cache on cursor P3.
4261 **
4262 ** This opcode is normally use to move a record out of the sorter and into
4263 ** a register that is the source for a pseudo-table cursor created using
4264 ** OpenPseudo. That pseudo-table cursor is the one that is identified by
4265 ** parameter P3. Clearing the P3 column cache as part of this opcode saves
4266 ** us from having to issue a separate NullRow instruction to clear that cache.
4267 */
4279 }
4281 /* Opcode: RowData P1 P2 * * *
4282 ** Synopsis: r[P2]=data
4283 **
4284 ** Write into register P2 the complete row data for cursor P1.
4285 ** There is no interpretation of the data.
4286 ** It is just copied onto the P2 register exactly as
4287 ** it is found in the database file.
4288 **
4289 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
4290 ** of a real table, not a pseudo-table.
4291 */
4292 /* Opcode: RowKey P1 P2 * * *
4293 ** Synopsis: r[P2]=key
4294 **
4295 ** Write into register P2 the complete row key for cursor P1.
4296 ** There is no interpretation of the data.
4297 ** The key is copied onto the P2 register exactly as
4298 ** it is found in the database file.
4299 **
4300 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
4301 ** of a real table, not a pseudo-table.
4302 */
4307 u32 n;
4308 i64 n64;
4313 /* Note that RowKey and RowData are really exactly the same instruction */
4325 /* The OP_RowKey and OP_RowData opcodes always follow OP_NotExists or
4326 ** OP_Rewind/Op_Next with no intervening instructions that might invalidate
4327 ** the cursor. If this where not the case, on of the following assert()s
4328 ** would fail. Should this ever change (because of changes in the code
4329 ** generator) then the fix would be to insert a call to
4330 ** sqlite3VdbeCursorMoveto().
4331 */
4337 #endif
4345 }
4352 }
4353 }
4357 }
4364 }
4369 }
4371 /* Opcode: Rowid P1 P2 * * *
4372 ** Synopsis: r[P2]=rowid
4373 **
4374 ** Store in register P2 an integer which is the key of the table entry that
4375 ** P1 is currently point to.
4376 **
4377 ** P1 can be either an ordinary table or a virtual table. There used to
4378 ** be a separate OP_VRowid opcode for use with virtual tables, but this
4379 ** one opcode now works for both table types.
4380 */
4383 i64 v;
4396 #ifndef SQLITE_OMIT_VIRTUALTABLE
4411 }
4414 }
4417 }
4419 /* Opcode: NullRow P1 * * * *
4420 **
4421 ** Move the cursor P1 to a null row. Any OP_Column operations
4422 ** that occur while the cursor is on the null row will always
4423 ** write a NULL.
4424 */
4435 }
4437 }
4439 /* Opcode: Last P1 P2 * * *
4440 **
4441 ** The next use of the Rowid or Column or Prev instruction for P1
4442 ** will refer to the last entry in the database table or index.
4443 ** If the table or index is empty and P2>0, then jump immediately to P2.
4444 ** If P2 is 0 or if the table or index is not empty, fall through
4445 ** to the following instruction.
4446 **
4447 ** This opcode leaves the cursor configured to move in reverse order,
4448 ** from the end toward the beginning. In other words, the cursor is
4449 ** configured to use Prev, not Next.
4450 */
4466 #ifdef SQLITE_DEBUG
4468 #endif
4472 }
4474 }
4477 /* Opcode: Sort P1 P2 * * *
4478 **
4479 ** This opcode does exactly the same thing as OP_Rewind except that
4480 ** it increments an undocumented global variable used for testing.
4481 **
4482 ** Sorting is accomplished by writing records into a sorting index,
4483 ** then rewinding that index and playing it back from beginning to
4484 ** end. We use the OP_Sort opcode instead of OP_Rewind to do the
4485 ** rewinding so that the global variable will be incremented and
4486 ** regression tests can determine whether or not the optimizer is
4487 ** correctly optimizing out sorts.
4488 */
4491 #ifdef SQLITE_TEST
4492 sqlite3_sort_count++;
4493 sqlite3_search_count--;
4494 #endif
4496 /* Fall through into OP_Rewind */
4497 }
4498 /* Opcode: Rewind P1 P2 * * *
4499 **
4500 ** The next use of the Rowid or Column or Next instruction for P1
4501 ** will refer to the first entry in the database table or index.
4502 ** If the table or index is empty and P2>0, then jump immediately to P2.
4503 ** If P2 is 0 or if the table or index is not empty, fall through
4504 ** to the following instruction.
4505 **
4506 ** This opcode leaves the cursor configured to move in forward order,
4507 ** from the beginning toward the end. In other words, the cursor is
4508 ** configured to use Next, not Prev.
4509 */
4520 #ifdef SQLITE_DEBUG
4522 #endif
4531 }
4537 }
4539 }
4541 /* Opcode: Next P1 P2 P3 P4 P5
4542 **
4543 ** Advance cursor P1 so that it points to the next key/data pair in its
4544 ** table or index. If there are no more key/value pairs then fall through
4545 ** to the following instruction. But if the cursor advance was successful,
4546 ** jump immediately to P2.
4547 **
4548 ** The Next opcode is only valid following an SeekGT, SeekGE, or
4549 ** OP_Rewind opcode used to position the cursor. Next is not allowed
4550 ** to follow SeekLT, SeekLE, or OP_Last.
4551 **
4552 ** The P1 cursor must be for a real table, not a pseudo-table. P1 must have
4553 ** been opened prior to this opcode or the program will segfault.
4554 **
4555 ** The P3 value is a hint to the btree implementation. If P3==1, that
4556 ** means P1 is an SQL index and that this instruction could have been
4557 ** omitted if that index had been unique. P3 is usually 0. P3 is
4558 ** always either 0 or 1.
4559 **
4560 ** P4 is always of type P4_ADVANCE. The function pointer points to
4561 ** sqlite3BtreeNext().
4562 **
4563 ** If P5 is positive and the jump is taken, then event counter
4564 ** number P5-1 in the prepared statement is incremented.
4565 **
4566 ** See also: Prev, NextIfOpen
4567 */
4568 /* Opcode: NextIfOpen P1 P2 P3 P4 P5
4569 **
4570 ** This opcode works just like Next except that if cursor P1 is not
4571 ** open it behaves a no-op.
4572 */
4573 /* Opcode: Prev P1 P2 P3 P4 P5
4574 **
4575 ** Back up cursor P1 so that it points to the previous key/data pair in its
4576 ** table or index. If there is no previous key/value pairs then fall through
4577 ** to the following instruction. But if the cursor backup was successful,
4578 ** jump immediately to P2.
4579 **
4580 **
4581 ** The Prev opcode is only valid following an SeekLT, SeekLE, or
4582 ** OP_Last opcode used to position the cursor. Prev is not allowed
4583 ** to follow SeekGT, SeekGE, or OP_Rewind.
4584 **
4585 ** The P1 cursor must be for a real table, not a pseudo-table. If P1 is
4586 ** not open then the behavior is undefined.
4587 **
4588 ** The P3 value is a hint to the btree implementation. If P3==1, that
4589 ** means P1 is an SQL index and that this instruction could have been
4590 ** omitted if that index had been unique. P3 is usually 0. P3 is
4591 ** always either 0 or 1.
4592 **
4593 ** P4 is always of type P4_ADVANCE. The function pointer points to
4594 ** sqlite3BtreePrevious().
4595 **
4596 ** If P5 is positive and the jump is taken, then event counter
4597 ** number P5-1 in the prepared statement is incremented.
4598 */
4599 /* Opcode: PrevIfOpen P1 P2 P3 P4 P5
4600 **
4601 ** This opcode works just like Prev except that if cursor P1 is not
4602 ** open it behaves a no-op.
4603 */
4616 /* Fall through */
4633 /* The Next opcode is only used after SeekGT, SeekGE, and Rewind.
4634 ** The Prev opcode is only used after SeekLT, SeekLE, and Last. */
4643 next_tail:
4650 #ifdef SQLITE_TEST
4651 sqlite3_search_count++;
4652 #endif
4655 }
4657 }
4659 /* Opcode: IdxInsert P1 P2 P3 * P5
4660 ** Synopsis: key=r[P2]
4661 **
4662 ** Register P2 holds an SQL index key made using the
4663 ** MakeRecord instructions. This opcode writes that key
4664 ** into the index P1. Data for the entry is nil.
4665 **
4666 ** P3 is a flag that provides a hint to the b-tree layer that this
4667 ** insert is likely to be an append.
4668 **
4669 ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
4670 ** incremented by this instruction. If the OPFLAG_NCHANGE bit is clear,
4671 ** then the change counter is unchanged.
4672 **
4673 ** If P5 has the OPFLAG_USESEEKRESULT bit set, then the cursor must have
4674 ** just done a seek to the spot where the new entry is to be inserted.
4675 ** This flag avoids doing an extra seek.
4676 **
4677 ** This instruction only works for indices. The equivalent instruction
4678 ** for tables is OP_Insert.
4679 */
4706 );
4709 }
4710 }
4712 }
4714 /* Opcode: IdxDelete P1 P2 P3 * *
4715 ** Synopsis: key=r[P2@P3]
4716 **
4717 ** The content of P3 registers starting at register P2 form
4718 ** an unpacked index key. This opcode removes that entry from the
4719 ** index opened by cursor P1.
4720 */
4725 UnpackedRecord r;
4739 #ifdef SQLITE_DEBUG
4741 #endif
4745 }
4749 }
4751 /* Opcode: IdxRowid P1 P2 * * *
4752 ** Synopsis: r[P2]=rowid
4753 **
4754 ** Write into register P2 an integer which is the last entry in the record at
4755 ** the end of the index key pointed to by cursor P1. This integer should be
4756 ** the rowid of the table entry to which this index entry points.
4757 **
4758 ** See also: Rowid, MakeRecord.
4759 */
4763 i64 rowid;
4774 /* sqlite3VbeCursorRestore() can only fail if the record has been deleted
4775 ** out from under the cursor. That will never happend for an IdxRowid
4776 ** opcode, hence the NEVER() arround the check of the return value.
4777 */
4786 }
4789 }
4791 }
4793 /* Opcode: IdxGE P1 P2 P3 P4 P5
4794 ** Synopsis: key=r[P3@P4]
4795 **
4796 ** The P4 register values beginning with P3 form an unpacked index
4797 ** key that omits the PRIMARY KEY. Compare this key value against the index
4798 ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID
4799 ** fields at the end.
4800 **
4801 ** If the P1 index entry is greater than or equal to the key value
4802 ** then jump to P2. Otherwise fall through to the next instruction.
4803 */
4804 /* Opcode: IdxGT P1 P2 P3 P4 P5
4805 ** Synopsis: key=r[P3@P4]
4806 **
4807 ** The P4 register values beginning with P3 form an unpacked index
4808 ** key that omits the PRIMARY KEY. Compare this key value against the index
4809 ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID
4810 ** fields at the end.
4811 **
4812 ** If the P1 index entry is greater than the key value
4813 ** then jump to P2. Otherwise fall through to the next instruction.
4814 */
4815 /* Opcode: IdxLT P1 P2 P3 P4 P5
4816 ** Synopsis: key=r[P3@P4]
4817 **
4818 ** The P4 register values beginning with P3 form an unpacked index
4819 ** key that omits the PRIMARY KEY or ROWID. Compare this key value against
4820 ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
4821 ** ROWID on the P1 index.
4822 **
4823 ** If the P1 index entry is less than the key value then jump to P2.
4824 ** Otherwise fall through to the next instruction.
4825 */
4826 /* Opcode: IdxLE P1 P2 P3 P4 P5
4827 ** Synopsis: key=r[P3@P4]
4828 **
4829 ** The P4 register values beginning with P3 form an unpacked index
4830 ** key that omits the PRIMARY KEY or ROWID. Compare this key value against
4831 ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
4832 ** ROWID on the P1 index.
4833 **
4834 ** If the P1 index entry is less than or equal to the key value then jump
4835 ** to P2. Otherwise fall through to the next instruction.
4836 */
4843 UnpackedRecord r;
4861 }
4863 #ifdef SQLITE_DEBUG
4865 #endif
4874 res++;
4875 }
4879 }
4881 }
4883 /* Opcode: Destroy P1 P2 P3 * *
4884 **
4885 ** Delete an entire database table or index whose root page in the database
4886 ** file is given by P1.
4887 **
4888 ** The table being destroyed is in the main database file if P3==0. If
4889 ** P3==1 then the table to be clear is in the auxiliary database file
4890 ** that is used to store tables create using CREATE TEMPORARY TABLE.
4891 **
4892 ** If AUTOVACUUM is enabled then it is possible that another root page
4893 ** might be moved into the newly deleted root page in order to keep all
4894 ** root pages contiguous at the beginning of the database. The former
4895 ** value of the root page that moved - its value before the move occurred -
4896 ** is stored in register P2. If no page
4897 ** movement was required (because the table being dropped was already
4898 ** the last one in the database) then a zero is stored in register P2.
4899 ** If AUTOVACUUM is disabled then a zero is stored in register P2.
4900 **
4901 ** See also: Clear
4902 */
4910 #ifndef SQLITE_OMIT_VIRTUALTABLE
4915 ){
4916 iCnt++;
4917 }
4918 }
4919 #else
4921 #endif
4934 #ifndef SQLITE_OMIT_AUTOVACUUM
4937 /* All OP_Destroy operations occur on the same btree */
4940 }
4941 #endif
4942 }
4944 }
4946 /* Opcode: Clear P1 P2 P3
4947 **
4948 ** Delete all contents of the database table or index whose root page
4949 ** in the database file is given by P1. But, unlike Destroy, do not
4950 ** remove the table or index from the database file.
4951 **
4952 ** The table being clear is in the main database file if P2==0. If
4953 ** P2==1 then the table to be clear is in the auxiliary database file
4954 ** that is used to store tables create using CREATE TEMPORARY TABLE.
4955 **
4956 ** If the P3 value is non-zero, then the table referred to must be an
4957 ** intkey table (an SQL table, not an index). In this case the row change
4958 ** count is incremented by the number of rows in the table being cleared.
4959 ** If P3 is greater than zero, then the value stored in register P3 is
4960 ** also incremented by the number of rows in the table being cleared.
4961 **
4962 ** See also: Destroy
4963 */
4972 );
4979 }
4980 }
4982 }
4984 /* Opcode: ResetSorter P1 * * * *
4985 **
4986 ** Delete all contents from the ephemeral table or sorter
4987 ** that is open on cursor P1.
4988 **
4989 ** This opcode only works for cursors used for sorting and
4990 ** opened with OP_OpenEphemeral or OP_SorterOpen.
4991 */
5003 }
5005 }
5007 /* Opcode: CreateTable P1 P2 * * *
5008 ** Synopsis: r[P2]=root iDb=P1
5009 **
5010 ** Allocate a new table in the main database file if P1==0 or in the
5011 ** auxiliary database file if P1==1 or in an attached database if
5012 ** P1>1. Write the root page number of the new table into
5013 ** register P2
5014 **
5015 ** The difference between a table and an index is this: A table must
5016 ** have a 4-byte integer key and can have arbitrary data. An index
5017 ** has an arbitrary key but no data.
5018 **
5019 ** See also: CreateIndex
5020 */
5021 /* Opcode: CreateIndex P1 P2 * * *
5022 ** Synopsis: r[P2]=root iDb=P1
5023 **
5024 ** Allocate a new index in the main database file if P1==0 or in the
5025 ** auxiliary database file if P1==1 or in an attached database if
5026 ** P1>1. Write the root page number of the new table into
5027 ** register P2.
5028 **
5029 ** See documentation on OP_CreateTable for additional information.
5030 */
5044 /* flags = BTREE_INTKEY; */
5048 }
5052 }
5054 /* Opcode: ParseSchema P1 * * P4 *
5055 **
5056 ** Read and parse all entries from the SQLITE_MASTER table of database P1
5057 ** that match the WHERE clause P4.
5058 **
5059 ** This opcode invokes the parser to create a new virtual machine,
5060 ** then runs the new virtual machine. It is thus a re-entrant opcode.
5061 */
5066 InitData initData;
5068 /* Any prepared statement that invokes this opcode will hold mutexes
5069 ** on every btree. This is a prerequisite for invoking
5070 ** sqlite3InitCallback().
5071 */
5072 #ifdef SQLITE_DEBUG
5075 }
5076 #endif
5100 }
5101 }
5105 }
5107 }
5109 #if !defined(SQLITE_OMIT_ANALYZE)
5110 /* Opcode: LoadAnalysis P1 * * * *
5111 **
5112 ** Read the sqlite_stat1 table for database P1 and load the content
5113 ** of that table into the internal index hash table. This will cause
5114 ** the analysis to be used when preparing all subsequent queries.
5115 */
5120 }
5123 /* Opcode: DropTable P1 * * P4 *
5124 **
5125 ** Remove the internal (in-memory) data structures that describe
5126 ** the table named P4 in database P1. This is called after a table
5127 ** is dropped from disk (using the Destroy opcode) in order to keep
5128 ** the internal representation of the
5129 ** schema consistent with what is on disk.
5130 */
5134 }
5136 /* Opcode: DropIndex P1 * * P4 *
5137 **
5138 ** Remove the internal (in-memory) data structures that describe
5139 ** the index named P4 in database P1. This is called after an index
5140 ** is dropped from disk (using the Destroy opcode)
5141 ** in order to keep the internal representation of the
5142 ** schema consistent with what is on disk.
5143 */
5147 }
5149 /* Opcode: DropTrigger P1 * * P4 *
5150 **
5151 ** Remove the internal (in-memory) data structures that describe
5152 ** the trigger named P4 in database P1. This is called after a trigger
5153 ** is dropped from disk (using the Destroy opcode) in order to keep
5154 ** the internal representation of the
5155 ** schema consistent with what is on disk.
5156 */
5160 }
5163 #ifndef SQLITE_OMIT_INTEGRITY_CHECK
5164 /* Opcode: IntegrityCk P1 P2 P3 * P5
5165 **
5166 ** Do an analysis of the currently open database. Store in
5167 ** register P1 the text of an error message describing any problems.
5168 ** If no problems are found, store a NULL in register P1.
5169 **
5170 ** The register P3 contains the maximum number of allowed errors.
5171 ** At most reg(P3) errors will be reported.
5172 ** In other words, the analysis stops as soon as reg(P1) errors are
5173 ** seen. Reg(P1) is updated with the number of errors remaining.
5174 **
5175 ** The root page numbers of all tables in the database are integer
5176 ** stored in reg(P1), reg(P1+1), reg(P1+2), .... There are P2 tables
5177 ** total.
5178 **
5179 ** If P5 is not zero, the check is done on the auxiliary database
5180 ** file, not the main database file.
5181 **
5182 ** This opcode is used to implement the integrity_check pragma.
5183 */
5204 }
5219 }
5223 }
5226 /* Opcode: RowSetAdd P1 P2 * * *
5227 ** Synopsis: rowset(P1)=r[P2]
5228 **
5229 ** Insert the integer value held by register P2 into a boolean index
5230 ** held in register P1.
5231 **
5232 ** An assertion fails if P2 is not an integer.
5233 */
5241 }
5244 }
5246 /* Opcode: RowSetRead P1 P2 P3 * *
5247 ** Synopsis: r[P3]=rowset(P1)
5248 **
5249 ** Extract the smallest value from boolean index P1 and put that value into
5250 ** register P3. Or, if boolean index P1 is initially empty, leave P3
5251 ** unchanged and jump to instruction P2.
5252 */
5254 i64 val;
5259 ){
5260 /* The boolean index is empty */
5265 /* A value was pulled from the index */
5268 }
5270 }
5272 /* Opcode: RowSetTest P1 P2 P3 P4
5273 ** Synopsis: if r[P3] in rowset(P1) goto P2
5274 **
5275 ** Register P3 is assumed to hold a 64-bit integer value. If register P1
5276 ** contains a RowSet object and that RowSet object contains
5277 ** the value held in P3, jump to register P2. Otherwise, insert the
5278 ** integer in P3 into the RowSet and continue on to the
5279 ** next opcode.
5280 **
5281 ** The RowSet object is optimized for the case where successive sets
5282 ** of integers, where each set contains no duplicates. Each set
5283 ** of values is identified by a unique P4 value. The first set
5284 ** must have P4==0, the final set P4=-1. P4 must be either -1 or
5285 ** non-negative. For non-negative values of P4 only the lower 4
5286 ** bits are significant.
5287 **
5288 ** This allows optimizations: (a) when P4==0 there is no need to test
5289 ** the rowset object for P3, as it is guaranteed not to contain it,
5290 ** (b) when P4==-1 there is no need to insert the value, as it will
5291 ** never be tested for, and (c) when a value that is part of set X is
5292 ** inserted, there is no need to search to see if the same value was
5293 ** previously inserted as part of set X (only if it was previously
5294 ** inserted as part of some other set).
5295 */
5305 /* If there is anything other than a rowset object in memory cell P1,
5306 ** delete it now and initialize P1 with an empty rowset
5307 */
5311 }
5321 }
5322 }
5325 }
5327 }
5330 #ifndef SQLITE_OMIT_TRIGGER
5332 /* Opcode: Program P1 P2 P3 P4 P5
5333 **
5334 ** Execute the trigger program passed as P4 (type P4_SUBPROGRAM).
5335 **
5336 ** P1 contains the address of the memory cell that contains the first memory
5337 ** cell in an array of values used as arguments to the sub-program. P2
5338 ** contains the address to jump to if the sub-program throws an IGNORE
5339 ** exception using the RAISE() function. Register P3 contains the address
5340 ** of a memory cell in this (the parent) VM that is used to allocate the
5341 ** memory required by the sub-vdbe at runtime.
5342 **
5343 ** P4 is a pointer to the VM containing the trigger program.
5344 **
5345 ** If P5 is non-zero, then recursive program invocation is enabled.
5346 */
5361 /* If the p5 flag is clear, then recursive invocation of triggers is
5362 ** disabled for backwards compatibility (p5 is set if this sub-program
5363 ** is really a trigger, not a foreign key action, and the flag set
5364 ** and cleared by the "PRAGMA recursive_triggers" command is clear).
5365 **
5366 ** It is recursive invocation of triggers, at the SQL level, that is
5367 ** disabled. In some cases a single trigger may generate more than one
5368 ** SubProgram (if the trigger may be executed with more than one different
5369 ** ON CONFLICT algorithm). SubProgram structures associated with a
5370 ** single trigger all have the same value for the SubProgram.token
5371 ** variable. */
5376 }
5382 }
5384 /* Register pRt is used to store the memory required to save the state
5385 ** of the current program, and the memory required at runtime to execute
5386 ** the trigger program. If this trigger has been fired before, then pRt
5387 ** is already allocated. Otherwise, it must be initialized. */
5389 /* SubProgram.nMem is set to the number of memory cells used by the
5390 ** program stored in SubProgram.aOp. As well as these, one memory
5391 ** cell is required for each cursor used by the program. Set local
5392 ** variable nMem (and later, VdbeFrame.nChildMem) to this value.
5393 */
5402 }
5425 }
5431 }
5451 }
5453 /* Opcode: Param P1 P2 * * *
5454 **
5455 ** This opcode is only ever present in sub-programs called via the
5456 ** OP_Program instruction. Copy a value currently stored in a memory
5457 ** cell of the calling (parent) frame to cell P2 in the current frames
5458 ** address space. This is used by trigger programs to access the new.*
5459 ** and old.* values.
5460 **
5461 ** The address of the cell in the parent frame is determined by adding
5462 ** the value of the P1 argument to the value of the P1 argument to the
5463 ** calling OP_Program instruction.
5464 */
5472 }
5476 #ifndef SQLITE_OMIT_FOREIGN_KEY
5477 /* Opcode: FkCounter P1 P2 * * *
5478 ** Synopsis: fkctr[P1]+=P2
5479 **
5480 ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
5481 ** If P1 is non-zero, the database constraint counter is incremented
5482 ** (deferred foreign key constraints). Otherwise, if P1 is zero, the
5483 ** statement counter is incremented (immediate foreign key constraints).
5484 */
5492 }
5494 }
5496 /* Opcode: FkIfZero P1 P2 * * *
5497 ** Synopsis: if fkctr[P1]==0 goto P2
5498 **
5499 ** This opcode tests if a foreign key constraint-counter is currently zero.
5500 ** If so, jump to instruction P2. Otherwise, fall through to the next
5501 ** instruction.
5502 **
5503 ** If P1 is non-zero, then the jump is taken if the database constraint-counter
5504 ** is zero (the one that counts deferred constraint violations). If P1 is
5505 ** zero, the jump is taken if the statement constraint-counter is zero
5506 ** (immediate foreign key constraint violations).
5507 */
5515 }
5517 }
5520 #ifndef SQLITE_OMIT_AUTOINCREMENT
5521 /* Opcode: MemMax P1 P2 * * *
5522 ** Synopsis: r[P1]=max(r[P1],r[P2])
5523 **
5524 ** P1 is a register in the root frame of this VM (the root frame is
5525 ** different from the current frame if this instruction is being executed
5526 ** within a sub-program). Set the value of register P1 to the maximum of
5527 ** its current value and the value in register P2.
5528 **
5529 ** This instruction throws an error if the memory cell is not initially
5530 ** an integer.
5531 */
5539 }
5546 }
5548 }
5551 /* Opcode: IfPos P1 P2 * * *
5552 ** Synopsis: if r[P1]>0 goto P2
5553 **
5554 ** If the value of register P1 is 1 or greater, jump to P2.
5555 **
5556 ** It is illegal to use this instruction on a register that does
5557 ** not contain an integer. An assertion fault will result if you try.
5558 */
5565 }
5567 }
5569 /* Opcode: IfNeg P1 P2 P3 * *
5570 ** Synopsis: r[P1]+=P3, if r[P1]<0 goto P2
5571 **
5572 ** Register P1 must contain an integer. Add literal P3 to the value in
5573 ** register P1 then if the value of register P1 is less than zero, jump to P2.
5574 */
5582 }
5584 }
5586 /* Opcode: IfZero P1 P2 P3 * *
5587 ** Synopsis: r[P1]+=P3, if r[P1]==0 goto P2
5588 **
5589 ** The register P1 must contain an integer. Add literal P3 to the
5590 ** value in register P1. If the result is exactly 0, jump to P2.
5591 */
5599 }
5601 }
5603 /* Opcode: AggStep * P2 P3 P4 P5
5604 ** Synopsis: accum=r[P3] step(r[P2@P5])
5605 **
5606 ** Execute the step function for an aggregate. The
5607 ** function has P5 arguments. P4 is a pointer to the FuncDef
5608 ** structure that specifies the function. Use register
5609 ** P3 as the accumulator.
5610 **
5611 ** The P5 arguments are taken from register P2 and its
5612 ** successors.
5613 */
5619 Mem t;
5620 sqlite3_context ctx;
5632 }
5647 }
5652 }
5655 }
5657 /* Opcode: AggFinal P1 P2 * P4 *
5658 ** Synopsis: accum=r[P1] N=P2
5659 **
5660 ** Execute the finalizer function for an aggregate. P1 is
5661 ** the memory location that is the accumulator for the aggregate.
5662 **
5663 ** P2 is the number of arguments that the step function takes and
5664 ** P4 is a pointer to the FuncDef for this function. The P2
5665 ** argument is not used by this opcode. It is only there to disambiguate
5666 ** functions that can take varying numbers of arguments. The
5667 ** P4 argument is only needed for the degenerate case where
5668 ** the step function was not previously called.
5669 */
5678 }
5683 }
5685 }
5687 #ifndef SQLITE_OMIT_WAL
5688 /* Opcode: Checkpoint P1 P2 P3 * *
5689 **
5690 ** Checkpoint database P1. This is a no-op if P1 is not currently in
5691 ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL
5692 ** or RESTART. Write 1 or 0 into mem[P3] if the checkpoint returns
5693 ** SQLITE_BUSY or not, respectively. Write the number of pages in the
5694 ** WAL after the checkpoint into mem[P3+1] and the number of pages
5695 ** in the WAL that have been checkpointed after the checkpoint
5696 ** completes into mem[P3+2]. However on an error, mem[P3+1] and
5697 ** mem[P3+2] are initialized to -1.
5698 */
5710 );
5715 }
5718 }
5720 };
5721 #endif
5723 #ifndef SQLITE_OMIT_PRAGMA
5724 /* Opcode: JournalMode P1 P2 P3 * *
5725 **
5726 ** Change the journal mode of database P1 to P3. P3 must be one of the
5727 ** PAGER_JOURNALMODE_XXX values. If changing between the various rollback
5728 ** modes (delete, truncate, persist, off and memory), this is a simple
5729 ** operation. No IO is required.
5730 **
5731 ** If changing into or out of WAL mode the procedure is more complicated.
5732 **
5733 ** Write a string containing the final journal-mode to register P2.
5734 */
5740 #ifndef SQLITE_OMIT_WAL
5742 #endif
5752 );
5762 #ifndef SQLITE_OMIT_WAL
5765 /* Do not allow a transition to journal_mode=WAL for a database
5766 ** in temporary storage or if the VFS does not support shared memory
5767 */
5771 ){
5773 }
5777 ){
5783 );
5788 /* If leaving WAL mode, close the log file. If successful, the call
5789 ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
5790 ** file. An EXCLUSIVE lock may still be held on the database file
5791 ** after a successful return.
5792 */
5796 }
5798 /* Cannot transition directly from MEMORY to WAL. Use mode OFF
5799 ** as an intermediate */
5801 }
5803 /* Open a transaction on the database file. Regardless of the journal
5804 ** mode, this transaction always uses a rollback journal.
5805 */
5809 }
5810 }
5811 }
5816 }
5826 };
5829 #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
5830 /* Opcode: Vacuum * * * * *
5831 **
5832 ** Vacuum the entire database. This opcode will cause other virtual
5833 ** machines to be created and run. It may not be called from within
5834 ** a transaction.
5835 */
5840 }
5841 #endif
5843 #if !defined(SQLITE_OMIT_AUTOVACUUM)
5844 /* Opcode: IncrVacuum P1 P2 * * *
5845 **
5846 ** Perform a single step of the incremental vacuum procedure on
5847 ** the P1 database. If the vacuum has finished, jump to instruction
5848 ** P2. Otherwise, fall through to the next instruction.
5849 */
5862 }
5864 }
5865 #endif
5867 /* Opcode: Expire P1 * * * *
5868 **
5869 ** Cause precompiled statements to expire. When an expired statement
5870 ** is executed using sqlite3_step() it will either automatically
5871 ** reprepare itself (if it was originally created using sqlite3_prepare_v2())
5872 ** or it will fail with SQLITE_SCHEMA.
5873 **
5874 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
5875 ** then only the currently executing statement is expired.
5876 */
5882 }
5884 }
5886 #ifndef SQLITE_OMIT_SHARED_CACHE
5887 /* Opcode: TableLock P1 P2 P3 P4 *
5888 ** Synopsis: iDb=P1 root=P2 write=P3
5889 **
5890 ** Obtain a lock on a particular table. This instruction is only used when
5891 ** the shared-cache feature is enabled.
5892 **
5893 ** P1 is the index of the database in sqlite3.aDb[] of the database
5894 ** on which the lock is acquired. A readlock is obtained if P3==0 or
5895 ** a write lock if P3==1.
5896 **
5897 ** P2 contains the root-page of the table to lock.
5898 **
5899 ** P4 contains a pointer to the name of the table being locked. This is only
5900 ** used to generate an error message if the lock cannot be obtained.
5901 */
5913 }
5914 }
5916 }
5919 #ifndef SQLITE_OMIT_VIRTUALTABLE
5920 /* Opcode: VBegin * * * P4 *
5921 **
5922 ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the
5923 ** xBegin method for that table.
5924 **
5925 ** Also, whether or not P4 is set, check that this is not being called from
5926 ** within a callback to a virtual table xSync() method. If it is, the error
5927 ** code will be set to SQLITE_LOCKED.
5928 */
5935 }
5938 #ifndef SQLITE_OMIT_VIRTUALTABLE
5939 /* Opcode: VCreate P1 * * P4 *
5940 **
5941 ** P4 is the name of a virtual table in database P1. Call the xCreate method
5942 ** for that table.
5943 */
5947 }
5950 #ifndef SQLITE_OMIT_VIRTUALTABLE
5951 /* Opcode: VDestroy P1 * * P4 *
5952 **
5953 ** P4 is the name of a virtual table in database P1. Call the xDestroy method
5954 ** of that table.
5955 */
5961 }
5964 #ifndef SQLITE_OMIT_VIRTUALTABLE
5965 /* Opcode: VOpen P1 * * P4 *
5966 **
5967 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
5968 ** P1 is a cursor number. This opcode opens a cursor to the virtual
5969 ** table and stores that cursor in P1.
5970 */
5986 /* Initialize sqlite3_vtab_cursor base class */
5989 /* Initialize vdbe cursor object */
5996 }
5997 }
5999 }
6002 #ifndef SQLITE_OMIT_VIRTUALTABLE
6003 /* Opcode: VFilter P1 P2 P3 P4 *
6004 ** Synopsis: iplan=r[P3] zplan='P4'
6005 **
6006 ** P1 is a cursor opened using VOpen. P2 is an address to jump to if
6007 ** the filtered result set is empty.
6008 **
6009 ** P4 is either NULL or a string that was generated by the xBestIndex
6010 ** method of the module. The interpretation of the P4 string is left
6011 ** to the module implementation.
6012 **
6013 ** This opcode invokes the xFilter method on the virtual table specified
6014 ** by P1. The integer query plan parameter to xFilter is stored in register
6015 ** P3. Register P3+1 stores the argc parameter to be passed to the
6016 ** xFilter method. Registers P3+2..P3+1+argc are the argc
6017 ** additional parameters which are passed to
6018 ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
6019 **
6020 ** A jump is made to P2 if the result set after filtering would be empty.
6021 */
6045 /* Grab the index number and argc parameters */
6050 /* Invoke the xFilter method */
6051 {
6056 }
6064 }
6068 }
6069 }
6073 }
6076 #ifndef SQLITE_OMIT_VIRTUALTABLE
6077 /* Opcode: VColumn P1 P2 P3 * *
6078 ** Synopsis: r[P3]=vcolumn(P2)
6079 **
6080 ** Store the value of the P2-th column of
6081 ** the row of the virtual-table that the
6082 ** P1 cursor is pointing to into register P3.
6083 */
6088 sqlite3_context sContext;
6098 }
6109 }
6116 }
6118 }
6121 #ifndef SQLITE_OMIT_VIRTUALTABLE
6122 /* Opcode: VNext P1 P2 * * *
6123 **
6124 ** Advance virtual table P1 to the next row in its result set and
6125 ** jump to instruction P2. Or, if the virtual table has reached
6126 ** the end of its result set, then fall through to the next instruction.
6127 */
6139 }
6144 /* Invoke the xNext() method of the module. There is no way for the
6145 ** underlying implementation to return an error if one occurs during
6146 ** xNext(). Instead, if an error occurs, true is returned (indicating that
6147 ** data is available) and the error code returned when xColumn or
6148 ** some other method is next invoked on the save virtual table cursor.
6149 */
6156 }
6159 /* If there is data, jump to P2 */
6161 }
6163 }
6166 #ifndef SQLITE_OMIT_VIRTUALTABLE
6167 /* Opcode: VRename P1 * * P4 *
6168 **
6169 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
6170 ** This opcode invokes the corresponding xRename method. The value
6171 ** in register P1 is passed as the zName argument to the xRename method.
6172 */
6192 }
6194 }
6195 #endif
6197 #ifndef SQLITE_OMIT_VIRTUALTABLE
6198 /* Opcode: VUpdate P1 P2 P3 P4 P5
6199 ** Synopsis: data=r[P3@P2]
6200 **
6201 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
6202 ** This opcode invokes the corresponding xUpdate method. P2 values
6203 ** are contiguous memory cells starting at P3 to pass to the xUpdate
6204 ** invocation. The value in register (P3+P2-1) corresponds to the
6205 ** p2th element of the argv array passed to xUpdate.
6206 **
6207 ** The xUpdate method will do a DELETE or an INSERT or both.
6208 ** The argv[0] element (which corresponds to memory cell P3)
6209 ** is the rowid of a row to delete. If argv[0] is NULL then no
6210 ** deletion occurs. The argv[1] element is the rowid of the new
6211 ** row. This can be NULL to have the virtual table select the new
6212 ** rowid for itself. The subsequent elements in the array are
6213 ** the values of columns in the new row.
6214 **
6215 ** If P2==1 then no insert is performed. argv[0] is the rowid of
6216 ** a row to delete.
6217 **
6218 ** P1 is a boolean flag. If it is set to true and the xUpdate call
6219 ** is successful, then the value returned by sqlite3_last_insert_rowid()
6220 ** is set to the value of the rowid for the row just inserted.
6221 **
6222 ** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to
6223 ** apply in the case of a constraint failure on an insert or update.
6224 */
6230 sqlite_int64 rowid;
6236 );
6250 pX++;
6251 }
6259 }
6265 }
6268 }
6269 }
6271 }
6274 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
6275 /* Opcode: Pagecount P1 P2 * * *
6276 **
6277 ** Write the current number of pages in database P1 to memory cell P2.
6278 */
6282 }
6283 #endif
6286 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
6287 /* Opcode: MaxPgcnt P1 P2 P3 * *
6288 **
6289 ** Try to set the maximum page count for database P1 to the value in P3.
6290 ** Do not let the maximum page count fall below the current page count and
6291 ** do not change the maximum page count value if P3==0.
6292 **
6293 ** Store the maximum page count after the change in register P2.
6294 */
6304 }
6307 }
6308 #endif
6311 /* Opcode: Init * P2 * P4 *
6312 ** Synopsis: Start at P2
6313 **
6314 ** Programs contain a single instance of this opcode as the very first
6315 ** opcode.
6316 **
6317 ** If tracing is enabled (by the sqlite3_trace()) interface, then
6318 ** the UTF-8 string contained in P4 is emitted on the trace callback.
6319 ** Or if P4 is blank, use the string returned by sqlite3_sql().
6320 **
6321 ** If P2 is not zero, jump to instruction P2.
6322 */
6329 }
6330 #ifndef SQLITE_OMIT_TRACE
6334 ){
6338 }
6339 #ifdef SQLITE_USE_FCNTL_TRACE
6346 }
6347 }
6349 #ifdef SQLITE_DEBUG
6352 ){
6354 }
6358 }
6361 /* Opcode: Noop * * * * *
6362 **
6363 ** Do nothing. This instruction is often useful as a jump
6364 ** destination.
6365 */
6366 /*
6367 ** The magic Explain opcode are only inserted when explain==2 (which
6368 ** is to say when the EXPLAIN QUERY PLAN syntax is used.)
6369 ** This opcode records information from the optimizer. It is the
6370 ** the same as a no-op. This opcodesnever appears in a real VM program.
6371 */
6375 }
6377 /*****************************************************************************
6378 ** The cases of the switch statement above this line should all be indented
6379 ** by 6 spaces. But the left-most 6 spaces have been removed to improve the
6380 ** readability. From this point on down, the normal indentation rules are
6381 ** restored.
6382 *****************************************************************************/
6383 }
6385 #ifdef VDBE_PROFILE
6386 {
6390 }
6391 #endif
6393 /* The following code adds nothing to the actual functionality
6394 ** of the program. It is only here for testing and debugging.
6395 ** On the other hand, it does burn CPU cycles every time through
6396 ** the evaluator loop. So we can leave it out when NDEBUG is defined.
6397 */
6398 #ifndef NDEBUG
6401 #ifdef SQLITE_DEBUG
6406 }
6409 }
6410 }
6415 /* If we reach this point, it means that execution is finished with
6416 ** an error of some kind.
6417 */
6418 vdbe_error_halt:
6429 }
6431 /* This is the only way out of this procedure. We have to
6432 ** release the mutexes on btrees that were acquired at the
6433 ** top. */
6434 vdbe_return:
6441 /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
6442 ** is encountered.
6443 */
6444 too_big:
6449 /* Jump to here if a malloc() fails.
6450 */
6451 no_mem:
6457 /* Jump to here for any other kind of fatal error. The "rc" variable
6458 ** should hold the error number.
6459 */
6460 abort_due_to_error:
6465 }
6468 /* Jump to here if the sqlite3_interrupt() API sets the interrupt
6469 ** flag.
6470 */
6471 abort_due_to_interrupt:
6477 }