1 | /* |
2 | ** 2001 September 15 |
3 | ** |
4 | ** The author disclaims copyright to this source code. In place of |
5 | ** a legal notice, here is a blessing: |
6 | ** |
7 | ** May you do good and not evil. |
8 | ** May you find forgiveness for yourself and forgive others. |
9 | ** May you share freely, never taking more than you give. |
10 | ** |
11 | ************************************************************************* |
12 | ** The code in this file implements the function that runs the |
13 | ** bytecode of a prepared statement. |
14 | ** |
15 | ** Various scripts scan this source file in order to generate HTML |
16 | ** documentation, headers files, or other derived files. The formatting |
17 | ** of the code in this file is, therefore, important. See other comments |
18 | ** in this file for details. If in doubt, do not deviate from existing |
19 | ** commenting and indentation practices when changing or adding code. |
20 | */ |
21 | #include "sqliteInt.h" |
22 | #include "vdbeInt.h" |
23 | |
24 | /* |
25 | ** Invoke this macro on memory cells just prior to changing the |
26 | ** value of the cell. This macro verifies that shallow copies are |
27 | ** not misused. A shallow copy of a string or blob just copies a |
28 | ** pointer to the string or blob, not the content. If the original |
29 | ** is changed while the copy is still in use, the string or blob might |
30 | ** be changed out from under the copy. This macro verifies that nothing |
31 | ** like that ever happens. |
32 | */ |
33 | #ifdef SQLITE_DEBUG |
34 | # define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M) |
35 | #else |
36 | # define memAboutToChange(P,M) |
37 | #endif |
38 | |
39 | /* |
40 | ** The following global variable is incremented every time a cursor |
41 | ** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes. The test |
42 | ** procedures use this information to make sure that indices are |
43 | ** working correctly. This variable has no function other than to |
44 | ** help verify the correct operation of the library. |
45 | */ |
46 | #ifdef SQLITE_TEST |
47 | int sqlite3_search_count = 0; |
48 | #endif |
49 | |
50 | /* |
51 | ** When this global variable is positive, it gets decremented once before |
52 | ** each instruction in the VDBE. When it reaches zero, the u1.isInterrupted |
53 | ** field of the sqlite3 structure is set in order to simulate an interrupt. |
54 | ** |
55 | ** This facility is used for testing purposes only. It does not function |
56 | ** in an ordinary build. |
57 | */ |
58 | #ifdef SQLITE_TEST |
59 | int sqlite3_interrupt_count = 0; |
60 | #endif |
61 | |
62 | /* |
63 | ** The next global variable is incremented each type the OP_Sort opcode |
64 | ** is executed. The test procedures use this information to make sure that |
65 | ** sorting is occurring or not occurring at appropriate times. This variable |
66 | ** has no function other than to help verify the correct operation of the |
67 | ** library. |
68 | */ |
69 | #ifdef SQLITE_TEST |
70 | int sqlite3_sort_count = 0; |
71 | #endif |
72 | |
73 | /* |
74 | ** The next global variable records the size of the largest MEM_Blob |
75 | ** or MEM_Str that has been used by a VDBE opcode. The test procedures |
76 | ** use this information to make sure that the zero-blob functionality |
77 | ** is working correctly. This variable has no function other than to |
78 | ** help verify the correct operation of the library. |
79 | */ |
80 | #ifdef SQLITE_TEST |
81 | int sqlite3_max_blobsize = 0; |
82 | static void updateMaxBlobsize(Mem *p){ |
83 | if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){ |
84 | sqlite3_max_blobsize = p->n; |
85 | } |
86 | } |
87 | #endif |
88 | |
89 | /* |
90 | ** This macro evaluates to true if either the update hook or the preupdate |
91 | ** hook are enabled for database connect DB. |
92 | */ |
93 | #ifdef SQLITE_ENABLE_PREUPDATE_HOOK |
94 | # define HAS_UPDATE_HOOK(DB) ((DB)->xPreUpdateCallback||(DB)->xUpdateCallback) |
95 | #else |
96 | # define HAS_UPDATE_HOOK(DB) ((DB)->xUpdateCallback) |
97 | #endif |
98 | |
99 | /* |
100 | ** The next global variable is incremented each time the OP_Found opcode |
101 | ** is executed. This is used to test whether or not the foreign key |
102 | ** operation implemented using OP_FkIsZero is working. This variable |
103 | ** has no function other than to help verify the correct operation of the |
104 | ** library. |
105 | */ |
106 | #ifdef SQLITE_TEST |
107 | int sqlite3_found_count = 0; |
108 | #endif |
109 | |
110 | /* |
111 | ** Test a register to see if it exceeds the current maximum blob size. |
112 | ** If it does, record the new maximum blob size. |
113 | */ |
114 | #if defined(SQLITE_TEST) && !defined(SQLITE_UNTESTABLE) |
115 | # define UPDATE_MAX_BLOBSIZE(P) updateMaxBlobsize(P) |
116 | #else |
117 | # define UPDATE_MAX_BLOBSIZE(P) |
118 | #endif |
119 | |
120 | #ifdef SQLITE_DEBUG |
121 | /* This routine provides a convenient place to set a breakpoint during |
122 | ** tracing with PRAGMA vdbe_trace=on. The breakpoint fires right after |
123 | ** each opcode is printed. Variables "pc" (program counter) and pOp are |
124 | ** available to add conditionals to the breakpoint. GDB example: |
125 | ** |
126 | ** break test_trace_breakpoint if pc=22 |
127 | ** |
128 | ** Other useful labels for breakpoints include: |
129 | ** test_addop_breakpoint(pc,pOp) |
130 | ** sqlite3CorruptError(lineno) |
131 | ** sqlite3MisuseError(lineno) |
132 | ** sqlite3CantopenError(lineno) |
133 | */ |
134 | static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){ |
135 | static int n = 0; |
136 | n++; |
137 | } |
138 | #endif |
139 | |
140 | /* |
141 | ** Invoke the VDBE coverage callback, if that callback is defined. This |
142 | ** feature is used for test suite validation only and does not appear an |
143 | ** production builds. |
144 | ** |
145 | ** M is the type of branch. I is the direction taken for this instance of |
146 | ** the branch. |
147 | ** |
148 | ** M: 2 - two-way branch (I=0: fall-thru 1: jump ) |
149 | ** 3 - two-way + NULL (I=0: fall-thru 1: jump 2: NULL ) |
150 | ** 4 - OP_Jump (I=0: jump p1 1: jump p2 2: jump p3) |
151 | ** |
152 | ** In other words, if M is 2, then I is either 0 (for fall-through) or |
153 | ** 1 (for when the branch is taken). If M is 3, the I is 0 for an |
154 | ** ordinary fall-through, I is 1 if the branch was taken, and I is 2 |
155 | ** if the result of comparison is NULL. For M=3, I=2 the jump may or |
156 | ** may not be taken, depending on the SQLITE_JUMPIFNULL flags in p5. |
157 | ** When M is 4, that means that an OP_Jump is being run. I is 0, 1, or 2 |
158 | ** depending on if the operands are less than, equal, or greater than. |
159 | ** |
160 | ** iSrcLine is the source code line (from the __LINE__ macro) that |
161 | ** generated the VDBE instruction combined with flag bits. The source |
162 | ** code line number is in the lower 24 bits of iSrcLine and the upper |
163 | ** 8 bytes are flags. The lower three bits of the flags indicate |
164 | ** values for I that should never occur. For example, if the branch is |
165 | ** always taken, the flags should be 0x05 since the fall-through and |
166 | ** alternate branch are never taken. If a branch is never taken then |
167 | ** flags should be 0x06 since only the fall-through approach is allowed. |
168 | ** |
169 | ** Bit 0x08 of the flags indicates an OP_Jump opcode that is only |
170 | ** interested in equal or not-equal. In other words, I==0 and I==2 |
171 | ** should be treated as equivalent |
172 | ** |
173 | ** Since only a line number is retained, not the filename, this macro |
174 | ** only works for amalgamation builds. But that is ok, since these macros |
175 | ** should be no-ops except for special builds used to measure test coverage. |
176 | */ |
177 | #if !defined(SQLITE_VDBE_COVERAGE) |
178 | # define VdbeBranchTaken(I,M) |
179 | #else |
180 | # define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M) |
181 | static void vdbeTakeBranch(u32 iSrcLine, u8 I, u8 M){ |
182 | u8 mNever; |
183 | assert( I<=2 ); /* 0: fall through, 1: taken, 2: alternate taken */ |
184 | assert( M<=4 ); /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */ |
185 | assert( I<M ); /* I can only be 2 if M is 3 or 4 */ |
186 | /* Transform I from a integer [0,1,2] into a bitmask of [1,2,4] */ |
187 | I = 1<<I; |
188 | /* The upper 8 bits of iSrcLine are flags. The lower three bits of |
189 | ** the flags indicate directions that the branch can never go. If |
190 | ** a branch really does go in one of those directions, assert right |
191 | ** away. */ |
192 | mNever = iSrcLine >> 24; |
193 | assert( (I & mNever)==0 ); |
194 | if( sqlite3GlobalConfig.xVdbeBranch==0 ) return; /*NO_TEST*/ |
195 | /* Invoke the branch coverage callback with three arguments: |
196 | ** iSrcLine - the line number of the VdbeCoverage() macro, with |
197 | ** flags removed. |
198 | ** I - Mask of bits 0x07 indicating which cases are are |
199 | ** fulfilled by this instance of the jump. 0x01 means |
200 | ** fall-thru, 0x02 means taken, 0x04 means NULL. Any |
201 | ** impossible cases (ex: if the comparison is never NULL) |
202 | ** are filled in automatically so that the coverage |
203 | ** measurement logic does not flag those impossible cases |
204 | ** as missed coverage. |
205 | ** M - Type of jump. Same as M argument above |
206 | */ |
207 | I |= mNever; |
208 | if( M==2 ) I |= 0x04; |
209 | if( M==4 ){ |
210 | I |= 0x08; |
211 | if( (mNever&0x08)!=0 && (I&0x05)!=0) I |= 0x05; /*NO_TEST*/ |
212 | } |
213 | sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg, |
214 | iSrcLine&0xffffff, I, M); |
215 | } |
216 | #endif |
217 | |
218 | /* |
219 | ** An ephemeral string value (signified by the MEM_Ephem flag) contains |
220 | ** a pointer to a dynamically allocated string where some other entity |
221 | ** is responsible for deallocating that string. Because the register |
222 | ** does not control the string, it might be deleted without the register |
223 | ** knowing it. |
224 | ** |
225 | ** This routine converts an ephemeral string into a dynamically allocated |
226 | ** string that the register itself controls. In other words, it |
227 | ** converts an MEM_Ephem string into a string with P.z==P.zMalloc. |
228 | */ |
229 | #define Deephemeralize(P) \ |
230 | if( ((P)->flags&MEM_Ephem)!=0 \ |
231 | && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;} |
232 | |
233 | /* Return true if the cursor was opened using the OP_OpenSorter opcode. */ |
234 | #define isSorter(x) ((x)->eCurType==CURTYPE_SORTER) |
235 | |
236 | /* |
237 | ** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL |
238 | ** if we run out of memory. |
239 | */ |
240 | static VdbeCursor *allocateCursor( |
241 | Vdbe *p, /* The virtual machine */ |
242 | int iCur, /* Index of the new VdbeCursor */ |
243 | int nField, /* Number of fields in the table or index */ |
244 | u8 eCurType /* Type of the new cursor */ |
245 | ){ |
246 | /* Find the memory cell that will be used to store the blob of memory |
247 | ** required for this VdbeCursor structure. It is convenient to use a |
248 | ** vdbe memory cell to manage the memory allocation required for a |
249 | ** VdbeCursor structure for the following reasons: |
250 | ** |
251 | ** * Sometimes cursor numbers are used for a couple of different |
252 | ** purposes in a vdbe program. The different uses might require |
253 | ** different sized allocations. Memory cells provide growable |
254 | ** allocations. |
255 | ** |
256 | ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can |
257 | ** be freed lazily via the sqlite3_release_memory() API. This |
258 | ** minimizes the number of malloc calls made by the system. |
259 | ** |
260 | ** The memory cell for cursor 0 is aMem[0]. The rest are allocated from |
261 | ** the top of the register space. Cursor 1 is at Mem[p->nMem-1]. |
262 | ** Cursor 2 is at Mem[p->nMem-2]. And so forth. |
263 | */ |
264 | Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem; |
265 | |
266 | int nByte; |
267 | VdbeCursor *pCx = 0; |
268 | nByte = |
269 | ROUND8P(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField + |
270 | (eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0); |
271 | |
272 | assert( iCur>=0 && iCur<p->nCursor ); |
273 | if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/ |
274 | sqlite3VdbeFreeCursorNN(p, p->apCsr[iCur]); |
275 | p->apCsr[iCur] = 0; |
276 | } |
277 | |
278 | /* There used to be a call to sqlite3VdbeMemClearAndResize() to make sure |
279 | ** the pMem used to hold space for the cursor has enough storage available |
280 | ** in pMem->zMalloc. But for the special case of the aMem[] entries used |
281 | ** to hold cursors, it is faster to in-line the logic. */ |
282 | assert( pMem->flags==MEM_Undefined ); |
283 | assert( (pMem->flags & MEM_Dyn)==0 ); |
284 | assert( pMem->szMalloc==0 || pMem->z==pMem->zMalloc ); |
285 | if( pMem->szMalloc<nByte ){ |
286 | if( pMem->szMalloc>0 ){ |
287 | sqlite3DbFreeNN(pMem->db, pMem->zMalloc); |
288 | } |
289 | pMem->z = pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, nByte); |
290 | if( pMem->zMalloc==0 ){ |
291 | pMem->szMalloc = 0; |
292 | return 0; |
293 | } |
294 | pMem->szMalloc = nByte; |
295 | } |
296 | |
297 | p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->zMalloc; |
298 | memset(pCx, 0, offsetof(VdbeCursor,pAltCursor)); |
299 | pCx->eCurType = eCurType; |
300 | pCx->nField = nField; |
301 | pCx->aOffset = &pCx->aType[nField]; |
302 | if( eCurType==CURTYPE_BTREE ){ |
303 | pCx->uc.pCursor = (BtCursor*) |
304 | &pMem->z[ROUND8P(sizeof(VdbeCursor))+2*sizeof(u32)*nField]; |
305 | sqlite3BtreeCursorZero(pCx->uc.pCursor); |
306 | } |
307 | return pCx; |
308 | } |
309 | |
310 | /* |
311 | ** The string in pRec is known to look like an integer and to have a |
312 | ** floating point value of rValue. Return true and set *piValue to the |
313 | ** integer value if the string is in range to be an integer. Otherwise, |
314 | ** return false. |
315 | */ |
316 | static int alsoAnInt(Mem *pRec, double rValue, i64 *piValue){ |
317 | i64 iValue; |
318 | iValue = sqlite3RealToI64(rValue); |
319 | if( sqlite3RealSameAsInt(rValue,iValue) ){ |
320 | *piValue = iValue; |
321 | return 1; |
322 | } |
323 | return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc); |
324 | } |
325 | |
326 | /* |
327 | ** Try to convert a value into a numeric representation if we can |
328 | ** do so without loss of information. In other words, if the string |
329 | ** looks like a number, convert it into a number. If it does not |
330 | ** look like a number, leave it alone. |
331 | ** |
332 | ** If the bTryForInt flag is true, then extra effort is made to give |
333 | ** an integer representation. Strings that look like floating point |
334 | ** values but which have no fractional component (example: '48.00') |
335 | ** will have a MEM_Int representation when bTryForInt is true. |
336 | ** |
337 | ** If bTryForInt is false, then if the input string contains a decimal |
338 | ** point or exponential notation, the result is only MEM_Real, even |
339 | ** if there is an exact integer representation of the quantity. |
340 | */ |
341 | static void applyNumericAffinity(Mem *pRec, int bTryForInt){ |
342 | double rValue; |
343 | u8 enc = pRec->enc; |
344 | int rc; |
345 | assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str ); |
346 | rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc); |
347 | if( rc<=0 ) return; |
348 | if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){ |
349 | pRec->flags |= MEM_Int; |
350 | }else{ |
351 | pRec->u.r = rValue; |
352 | pRec->flags |= MEM_Real; |
353 | if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec); |
354 | } |
355 | /* TEXT->NUMERIC is many->one. Hence, it is important to invalidate the |
356 | ** string representation after computing a numeric equivalent, because the |
357 | ** string representation might not be the canonical representation for the |
358 | ** numeric value. Ticket [343634942dd54ab57b7024] 2018-01-31. */ |
359 | pRec->flags &= ~MEM_Str; |
360 | } |
361 | |
362 | /* |
363 | ** Processing is determine by the affinity parameter: |
364 | ** |
365 | ** SQLITE_AFF_INTEGER: |
366 | ** SQLITE_AFF_REAL: |
367 | ** SQLITE_AFF_NUMERIC: |
368 | ** Try to convert pRec to an integer representation or a |
369 | ** floating-point representation if an integer representation |
370 | ** is not possible. Note that the integer representation is |
371 | ** always preferred, even if the affinity is REAL, because |
372 | ** an integer representation is more space efficient on disk. |
373 | ** |
374 | ** SQLITE_AFF_TEXT: |
375 | ** Convert pRec to a text representation. |
376 | ** |
377 | ** SQLITE_AFF_BLOB: |
378 | ** SQLITE_AFF_NONE: |
379 | ** No-op. pRec is unchanged. |
380 | */ |
381 | static void applyAffinity( |
382 | Mem *pRec, /* The value to apply affinity to */ |
383 | char affinity, /* The affinity to be applied */ |
384 | u8 enc /* Use this text encoding */ |
385 | ){ |
386 | if( affinity>=SQLITE_AFF_NUMERIC ){ |
387 | assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL |
388 | || affinity==SQLITE_AFF_NUMERIC ); |
389 | if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/ |
390 | if( (pRec->flags & MEM_Real)==0 ){ |
391 | if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1); |
392 | }else{ |
393 | sqlite3VdbeIntegerAffinity(pRec); |
394 | } |
395 | } |
396 | }else if( affinity==SQLITE_AFF_TEXT ){ |
397 | /* Only attempt the conversion to TEXT if there is an integer or real |
398 | ** representation (blob and NULL do not get converted) but no string |
399 | ** representation. It would be harmless to repeat the conversion if |
400 | ** there is already a string rep, but it is pointless to waste those |
401 | ** CPU cycles. */ |
402 | if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/ |
403 | if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){ |
404 | testcase( pRec->flags & MEM_Int ); |
405 | testcase( pRec->flags & MEM_Real ); |
406 | testcase( pRec->flags & MEM_IntReal ); |
407 | sqlite3VdbeMemStringify(pRec, enc, 1); |
408 | } |
409 | } |
410 | pRec->flags &= ~(MEM_Real|MEM_Int|MEM_IntReal); |
411 | } |
412 | } |
413 | |
414 | /* |
415 | ** Try to convert the type of a function argument or a result column |
416 | ** into a numeric representation. Use either INTEGER or REAL whichever |
417 | ** is appropriate. But only do the conversion if it is possible without |
418 | ** loss of information and return the revised type of the argument. |
419 | */ |
420 | int sqlite3_value_numeric_type(sqlite3_value *pVal){ |
421 | int eType = sqlite3_value_type(pVal); |
422 | if( eType==SQLITE_TEXT ){ |
423 | Mem *pMem = (Mem*)pVal; |
424 | applyNumericAffinity(pMem, 0); |
425 | eType = sqlite3_value_type(pVal); |
426 | } |
427 | return eType; |
428 | } |
429 | |
430 | /* |
431 | ** Exported version of applyAffinity(). This one works on sqlite3_value*, |
432 | ** not the internal Mem* type. |
433 | */ |
434 | void sqlite3ValueApplyAffinity( |
435 | sqlite3_value *pVal, |
436 | u8 affinity, |
437 | u8 enc |
438 | ){ |
439 | applyAffinity((Mem *)pVal, affinity, enc); |
440 | } |
441 | |
442 | /* |
443 | ** pMem currently only holds a string type (or maybe a BLOB that we can |
444 | ** interpret as a string if we want to). Compute its corresponding |
445 | ** numeric type, if has one. Set the pMem->u.r and pMem->u.i fields |
446 | ** accordingly. |
447 | */ |
448 | static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){ |
449 | int rc; |
450 | sqlite3_int64 ix; |
451 | assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ); |
452 | assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ); |
453 | if( ExpandBlob(pMem) ){ |
454 | pMem->u.i = 0; |
455 | return MEM_Int; |
456 | } |
457 | rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc); |
458 | if( rc<=0 ){ |
459 | if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){ |
460 | pMem->u.i = ix; |
461 | return MEM_Int; |
462 | }else{ |
463 | return MEM_Real; |
464 | } |
465 | }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){ |
466 | pMem->u.i = ix; |
467 | return MEM_Int; |
468 | } |
469 | return MEM_Real; |
470 | } |
471 | |
472 | /* |
473 | ** Return the numeric type for pMem, either MEM_Int or MEM_Real or both or |
474 | ** none. |
475 | ** |
476 | ** Unlike applyNumericAffinity(), this routine does not modify pMem->flags. |
477 | ** But it does set pMem->u.r and pMem->u.i appropriately. |
478 | */ |
479 | static u16 numericType(Mem *pMem){ |
480 | assert( (pMem->flags & MEM_Null)==0 |
481 | || pMem->db==0 || pMem->db->mallocFailed ); |
482 | if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null) ){ |
483 | testcase( pMem->flags & MEM_Int ); |
484 | testcase( pMem->flags & MEM_Real ); |
485 | testcase( pMem->flags & MEM_IntReal ); |
486 | return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null); |
487 | } |
488 | assert( pMem->flags & (MEM_Str|MEM_Blob) ); |
489 | testcase( pMem->flags & MEM_Str ); |
490 | testcase( pMem->flags & MEM_Blob ); |
491 | return computeNumericType(pMem); |
492 | return 0; |
493 | } |
494 | |
495 | #ifdef SQLITE_DEBUG |
496 | /* |
497 | ** Write a nice string representation of the contents of cell pMem |
498 | ** into buffer zBuf, length nBuf. |
499 | */ |
500 | void sqlite3VdbeMemPrettyPrint(Mem *pMem, StrAccum *pStr){ |
501 | int f = pMem->flags; |
502 | static const char *const encnames[] = {"(X)" , "(8)" , "(16LE)" , "(16BE)" }; |
503 | if( f&MEM_Blob ){ |
504 | int i; |
505 | char c; |
506 | if( f & MEM_Dyn ){ |
507 | c = 'z'; |
508 | assert( (f & (MEM_Static|MEM_Ephem))==0 ); |
509 | }else if( f & MEM_Static ){ |
510 | c = 't'; |
511 | assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); |
512 | }else if( f & MEM_Ephem ){ |
513 | c = 'e'; |
514 | assert( (f & (MEM_Static|MEM_Dyn))==0 ); |
515 | }else{ |
516 | c = 's'; |
517 | } |
518 | sqlite3_str_appendf(pStr, "%cx[" , c); |
519 | for(i=0; i<25 && i<pMem->n; i++){ |
520 | sqlite3_str_appendf(pStr, "%02X" , ((int)pMem->z[i] & 0xFF)); |
521 | } |
522 | sqlite3_str_appendf(pStr, "|" ); |
523 | for(i=0; i<25 && i<pMem->n; i++){ |
524 | char z = pMem->z[i]; |
525 | sqlite3_str_appendchar(pStr, 1, (z<32||z>126)?'.':z); |
526 | } |
527 | sqlite3_str_appendf(pStr,"]" ); |
528 | if( f & MEM_Zero ){ |
529 | sqlite3_str_appendf(pStr, "+%dz" ,pMem->u.nZero); |
530 | } |
531 | }else if( f & MEM_Str ){ |
532 | int j; |
533 | u8 c; |
534 | if( f & MEM_Dyn ){ |
535 | c = 'z'; |
536 | assert( (f & (MEM_Static|MEM_Ephem))==0 ); |
537 | }else if( f & MEM_Static ){ |
538 | c = 't'; |
539 | assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); |
540 | }else if( f & MEM_Ephem ){ |
541 | c = 'e'; |
542 | assert( (f & (MEM_Static|MEM_Dyn))==0 ); |
543 | }else{ |
544 | c = 's'; |
545 | } |
546 | sqlite3_str_appendf(pStr, " %c%d[" , c, pMem->n); |
547 | for(j=0; j<25 && j<pMem->n; j++){ |
548 | c = pMem->z[j]; |
549 | sqlite3_str_appendchar(pStr, 1, (c>=0x20&&c<=0x7f) ? c : '.'); |
550 | } |
551 | sqlite3_str_appendf(pStr, "]%s" , encnames[pMem->enc]); |
552 | } |
553 | } |
554 | #endif |
555 | |
556 | #ifdef SQLITE_DEBUG |
557 | /* |
558 | ** Print the value of a register for tracing purposes: |
559 | */ |
560 | static void memTracePrint(Mem *p){ |
561 | if( p->flags & MEM_Undefined ){ |
562 | printf(" undefined" ); |
563 | }else if( p->flags & MEM_Null ){ |
564 | printf(p->flags & MEM_Zero ? " NULL-nochng" : " NULL" ); |
565 | }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){ |
566 | printf(" si:%lld" , p->u.i); |
567 | }else if( (p->flags & (MEM_IntReal))!=0 ){ |
568 | printf(" ir:%lld" , p->u.i); |
569 | }else if( p->flags & MEM_Int ){ |
570 | printf(" i:%lld" , p->u.i); |
571 | #ifndef SQLITE_OMIT_FLOATING_POINT |
572 | }else if( p->flags & MEM_Real ){ |
573 | printf(" r:%.17g" , p->u.r); |
574 | #endif |
575 | }else if( sqlite3VdbeMemIsRowSet(p) ){ |
576 | printf(" (rowset)" ); |
577 | }else{ |
578 | StrAccum acc; |
579 | char zBuf[1000]; |
580 | sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); |
581 | sqlite3VdbeMemPrettyPrint(p, &acc); |
582 | printf(" %s" , sqlite3StrAccumFinish(&acc)); |
583 | } |
584 | if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x" , p->eSubtype); |
585 | } |
586 | static void registerTrace(int iReg, Mem *p){ |
587 | printf("R[%d] = " , iReg); |
588 | memTracePrint(p); |
589 | if( p->pScopyFrom ){ |
590 | printf(" <== R[%d]" , (int)(p->pScopyFrom - &p[-iReg])); |
591 | } |
592 | printf("\n" ); |
593 | sqlite3VdbeCheckMemInvariants(p); |
594 | } |
595 | /**/ void sqlite3PrintMem(Mem *pMem){ |
596 | memTracePrint(pMem); |
597 | printf("\n" ); |
598 | fflush(stdout); |
599 | } |
600 | #endif |
601 | |
602 | #ifdef SQLITE_DEBUG |
603 | /* |
604 | ** Show the values of all registers in the virtual machine. Used for |
605 | ** interactive debugging. |
606 | */ |
607 | void sqlite3VdbeRegisterDump(Vdbe *v){ |
608 | int i; |
609 | for(i=1; i<v->nMem; i++) registerTrace(i, v->aMem+i); |
610 | } |
611 | #endif /* SQLITE_DEBUG */ |
612 | |
613 | |
614 | #ifdef SQLITE_DEBUG |
615 | # define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M) |
616 | #else |
617 | # define REGISTER_TRACE(R,M) |
618 | #endif |
619 | |
620 | |
621 | #ifdef VDBE_PROFILE |
622 | |
623 | /* |
624 | ** hwtime.h contains inline assembler code for implementing |
625 | ** high-performance timing routines. |
626 | */ |
627 | #include "hwtime.h" |
628 | |
629 | #endif |
630 | |
631 | #ifndef NDEBUG |
632 | /* |
633 | ** This function is only called from within an assert() expression. It |
634 | ** checks that the sqlite3.nTransaction variable is correctly set to |
635 | ** the number of non-transaction savepoints currently in the |
636 | ** linked list starting at sqlite3.pSavepoint. |
637 | ** |
638 | ** Usage: |
639 | ** |
640 | ** assert( checkSavepointCount(db) ); |
641 | */ |
642 | static int checkSavepointCount(sqlite3 *db){ |
643 | int n = 0; |
644 | Savepoint *p; |
645 | for(p=db->pSavepoint; p; p=p->pNext) n++; |
646 | assert( n==(db->nSavepoint + db->isTransactionSavepoint) ); |
647 | return 1; |
648 | } |
649 | #endif |
650 | |
651 | /* |
652 | ** Return the register of pOp->p2 after first preparing it to be |
653 | ** overwritten with an integer value. |
654 | */ |
655 | static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){ |
656 | sqlite3VdbeMemSetNull(pOut); |
657 | pOut->flags = MEM_Int; |
658 | return pOut; |
659 | } |
660 | static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){ |
661 | Mem *pOut; |
662 | assert( pOp->p2>0 ); |
663 | assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); |
664 | pOut = &p->aMem[pOp->p2]; |
665 | memAboutToChange(p, pOut); |
666 | if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/ |
667 | return out2PrereleaseWithClear(pOut); |
668 | }else{ |
669 | pOut->flags = MEM_Int; |
670 | return pOut; |
671 | } |
672 | } |
673 | |
674 | /* |
675 | ** Compute a bloom filter hash using pOp->p4.i registers from aMem[] beginning |
676 | ** with pOp->p3. Return the hash. |
677 | */ |
678 | static u64 filterHash(const Mem *aMem, const Op *pOp){ |
679 | int i, mx; |
680 | u64 h = 0; |
681 | |
682 | assert( pOp->p4type==P4_INT32 ); |
683 | for(i=pOp->p3, mx=i+pOp->p4.i; i<mx; i++){ |
684 | const Mem *p = &aMem[i]; |
685 | if( p->flags & (MEM_Int|MEM_IntReal) ){ |
686 | h += p->u.i; |
687 | }else if( p->flags & MEM_Real ){ |
688 | h += sqlite3VdbeIntValue(p); |
689 | }else if( p->flags & (MEM_Str|MEM_Blob) ){ |
690 | h += p->n; |
691 | if( p->flags & MEM_Zero ) h += p->u.nZero; |
692 | } |
693 | } |
694 | return h; |
695 | } |
696 | |
697 | /* |
698 | ** Return the symbolic name for the data type of a pMem |
699 | */ |
700 | static const char *vdbeMemTypeName(Mem *pMem){ |
701 | static const char *azTypes[] = { |
702 | /* SQLITE_INTEGER */ "INT" , |
703 | /* SQLITE_FLOAT */ "REAL" , |
704 | /* SQLITE_TEXT */ "TEXT" , |
705 | /* SQLITE_BLOB */ "BLOB" , |
706 | /* SQLITE_NULL */ "NULL" |
707 | }; |
708 | return azTypes[sqlite3_value_type(pMem)-1]; |
709 | } |
710 | |
711 | /* |
712 | ** Execute as much of a VDBE program as we can. |
713 | ** This is the core of sqlite3_step(). |
714 | */ |
715 | int sqlite3VdbeExec( |
716 | Vdbe *p /* The VDBE */ |
717 | ){ |
718 | Op *aOp = p->aOp; /* Copy of p->aOp */ |
719 | Op *pOp = aOp; /* Current operation */ |
720 | #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) |
721 | Op *pOrigOp; /* Value of pOp at the top of the loop */ |
722 | #endif |
723 | #ifdef SQLITE_DEBUG |
724 | int = 0; /* Verifies FORDELETE and AUXDELETE flags */ |
725 | #endif |
726 | int rc = SQLITE_OK; /* Value to return */ |
727 | sqlite3 *db = p->db; /* The database */ |
728 | u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */ |
729 | u8 encoding = ENC(db); /* The database encoding */ |
730 | int iCompare = 0; /* Result of last comparison */ |
731 | u64 nVmStep = 0; /* Number of virtual machine steps */ |
732 | #ifndef SQLITE_OMIT_PROGRESS_CALLBACK |
733 | u64 nProgressLimit; /* Invoke xProgress() when nVmStep reaches this */ |
734 | #endif |
735 | Mem *aMem = p->aMem; /* Copy of p->aMem */ |
736 | Mem *pIn1 = 0; /* 1st input operand */ |
737 | Mem *pIn2 = 0; /* 2nd input operand */ |
738 | Mem *pIn3 = 0; /* 3rd input operand */ |
739 | Mem *pOut = 0; /* Output operand */ |
740 | #ifdef VDBE_PROFILE |
741 | u64 start; /* CPU clock count at start of opcode */ |
742 | #endif |
743 | /*** INSERT STACK UNION HERE ***/ |
744 | |
745 | assert( p->eVdbeState==VDBE_RUN_STATE ); /* sqlite3_step() verifies this */ |
746 | sqlite3VdbeEnter(p); |
747 | #ifndef SQLITE_OMIT_PROGRESS_CALLBACK |
748 | if( db->xProgress ){ |
749 | u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP]; |
750 | assert( 0 < db->nProgressOps ); |
751 | nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps); |
752 | }else{ |
753 | nProgressLimit = LARGEST_UINT64; |
754 | } |
755 | #endif |
756 | if( p->rc==SQLITE_NOMEM ){ |
757 | /* This happens if a malloc() inside a call to sqlite3_column_text() or |
758 | ** sqlite3_column_text16() failed. */ |
759 | goto no_mem; |
760 | } |
761 | assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY ); |
762 | testcase( p->rc!=SQLITE_OK ); |
763 | p->rc = SQLITE_OK; |
764 | assert( p->bIsReader || p->readOnly!=0 ); |
765 | p->iCurrentTime = 0; |
766 | assert( p->explain==0 ); |
767 | p->pResultSet = 0; |
768 | db->busyHandler.nBusy = 0; |
769 | if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt; |
770 | sqlite3VdbeIOTraceSql(p); |
771 | #ifdef SQLITE_DEBUG |
772 | sqlite3BeginBenignMalloc(); |
773 | if( p->pc==0 |
774 | && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0 |
775 | ){ |
776 | int i; |
777 | int once = 1; |
778 | sqlite3VdbePrintSql(p); |
779 | if( p->db->flags & SQLITE_VdbeListing ){ |
780 | printf("VDBE Program Listing:\n" ); |
781 | for(i=0; i<p->nOp; i++){ |
782 | sqlite3VdbePrintOp(stdout, i, &aOp[i]); |
783 | } |
784 | } |
785 | if( p->db->flags & SQLITE_VdbeEQP ){ |
786 | for(i=0; i<p->nOp; i++){ |
787 | if( aOp[i].opcode==OP_Explain ){ |
788 | if( once ) printf("VDBE Query Plan:\n" ); |
789 | printf("%s\n" , aOp[i].p4.z); |
790 | once = 0; |
791 | } |
792 | } |
793 | } |
794 | if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n" ); |
795 | } |
796 | sqlite3EndBenignMalloc(); |
797 | #endif |
798 | for(pOp=&aOp[p->pc]; 1; pOp++){ |
799 | /* Errors are detected by individual opcodes, with an immediate |
800 | ** jumps to abort_due_to_error. */ |
801 | assert( rc==SQLITE_OK ); |
802 | |
803 | assert( pOp>=aOp && pOp<&aOp[p->nOp]); |
804 | #ifdef VDBE_PROFILE |
805 | start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime(); |
806 | #endif |
807 | nVmStep++; |
808 | #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
809 | if( p->anExec ) p->anExec[(int)(pOp-aOp)]++; |
810 | #endif |
811 | |
812 | /* Only allow tracing if SQLITE_DEBUG is defined. |
813 | */ |
814 | #ifdef SQLITE_DEBUG |
815 | if( db->flags & SQLITE_VdbeTrace ){ |
816 | sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp); |
817 | test_trace_breakpoint((int)(pOp - aOp),pOp,p); |
818 | } |
819 | #endif |
820 | |
821 | |
822 | /* Check to see if we need to simulate an interrupt. This only happens |
823 | ** if we have a special test build. |
824 | */ |
825 | #ifdef SQLITE_TEST |
826 | if( sqlite3_interrupt_count>0 ){ |
827 | sqlite3_interrupt_count--; |
828 | if( sqlite3_interrupt_count==0 ){ |
829 | sqlite3_interrupt(db); |
830 | } |
831 | } |
832 | #endif |
833 | |
834 | /* Sanity checking on other operands */ |
835 | #ifdef SQLITE_DEBUG |
836 | { |
837 | u8 opProperty = sqlite3OpcodeProperty[pOp->opcode]; |
838 | if( (opProperty & OPFLG_IN1)!=0 ){ |
839 | assert( pOp->p1>0 ); |
840 | assert( pOp->p1<=(p->nMem+1 - p->nCursor) ); |
841 | assert( memIsValid(&aMem[pOp->p1]) ); |
842 | assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) ); |
843 | REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]); |
844 | } |
845 | if( (opProperty & OPFLG_IN2)!=0 ){ |
846 | assert( pOp->p2>0 ); |
847 | assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); |
848 | assert( memIsValid(&aMem[pOp->p2]) ); |
849 | assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) ); |
850 | REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]); |
851 | } |
852 | if( (opProperty & OPFLG_IN3)!=0 ){ |
853 | assert( pOp->p3>0 ); |
854 | assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
855 | assert( memIsValid(&aMem[pOp->p3]) ); |
856 | assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) ); |
857 | REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]); |
858 | } |
859 | if( (opProperty & OPFLG_OUT2)!=0 ){ |
860 | assert( pOp->p2>0 ); |
861 | assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); |
862 | memAboutToChange(p, &aMem[pOp->p2]); |
863 | } |
864 | if( (opProperty & OPFLG_OUT3)!=0 ){ |
865 | assert( pOp->p3>0 ); |
866 | assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
867 | memAboutToChange(p, &aMem[pOp->p3]); |
868 | } |
869 | } |
870 | #endif |
871 | #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) |
872 | pOrigOp = pOp; |
873 | #endif |
874 | |
875 | switch( pOp->opcode ){ |
876 | |
877 | /***************************************************************************** |
878 | ** What follows is a massive switch statement where each case implements a |
879 | ** separate instruction in the virtual machine. If we follow the usual |
880 | ** indentation conventions, each case should be indented by 6 spaces. But |
881 | ** that is a lot of wasted space on the left margin. So the code within |
882 | ** the switch statement will break with convention and be flush-left. Another |
883 | ** big comment (similar to this one) will mark the point in the code where |
884 | ** we transition back to normal indentation. |
885 | ** |
886 | ** The formatting of each case is important. The makefile for SQLite |
887 | ** generates two C files "opcodes.h" and "opcodes.c" by scanning this |
888 | ** file looking for lines that begin with "case OP_". The opcodes.h files |
889 | ** will be filled with #defines that give unique integer values to each |
890 | ** opcode and the opcodes.c file is filled with an array of strings where |
891 | ** each string is the symbolic name for the corresponding opcode. If the |
892 | ** case statement is followed by a comment of the form "/# same as ... #/" |
893 | ** that comment is used to determine the particular value of the opcode. |
894 | ** |
895 | ** Other keywords in the comment that follows each case are used to |
896 | ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[]. |
897 | ** Keywords include: in1, in2, in3, out2, out3. See |
898 | ** the mkopcodeh.awk script for additional information. |
899 | ** |
900 | ** Documentation about VDBE opcodes is generated by scanning this file |
901 | ** for lines of that contain "Opcode:". That line and all subsequent |
902 | ** comment lines are used in the generation of the opcode.html documentation |
903 | ** file. |
904 | ** |
905 | ** SUMMARY: |
906 | ** |
907 | ** Formatting is important to scripts that scan this file. |
908 | ** Do not deviate from the formatting style currently in use. |
909 | ** |
910 | *****************************************************************************/ |
911 | |
912 | /* Opcode: Goto * P2 * * * |
913 | ** |
914 | ** An unconditional jump to address P2. |
915 | ** The next instruction executed will be |
916 | ** the one at index P2 from the beginning of |
917 | ** the program. |
918 | ** |
919 | ** The P1 parameter is not actually used by this opcode. However, it |
920 | ** is sometimes set to 1 instead of 0 as a hint to the command-line shell |
921 | ** that this Goto is the bottom of a loop and that the lines from P2 down |
922 | ** to the current line should be indented for EXPLAIN output. |
923 | */ |
924 | case OP_Goto: { /* jump */ |
925 | |
926 | #ifdef SQLITE_DEBUG |
927 | /* In debuggging mode, when the p5 flags is set on an OP_Goto, that |
928 | ** means we should really jump back to the preceeding OP_ReleaseReg |
929 | ** instruction. */ |
930 | if( pOp->p5 ){ |
931 | assert( pOp->p2 < (int)(pOp - aOp) ); |
932 | assert( pOp->p2 > 1 ); |
933 | pOp = &aOp[pOp->p2 - 2]; |
934 | assert( pOp[1].opcode==OP_ReleaseReg ); |
935 | goto check_for_interrupt; |
936 | } |
937 | #endif |
938 | |
939 | jump_to_p2_and_check_for_interrupt: |
940 | pOp = &aOp[pOp->p2 - 1]; |
941 | |
942 | /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev, |
943 | ** OP_VNext, or OP_SorterNext) all jump here upon |
944 | ** completion. Check to see if sqlite3_interrupt() has been called |
945 | ** or if the progress callback needs to be invoked. |
946 | ** |
947 | ** This code uses unstructured "goto" statements and does not look clean. |
948 | ** But that is not due to sloppy coding habits. The code is written this |
949 | ** way for performance, to avoid having to run the interrupt and progress |
950 | ** checks on every opcode. This helps sqlite3_step() to run about 1.5% |
951 | ** faster according to "valgrind --tool=cachegrind" */ |
952 | check_for_interrupt: |
953 | if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt; |
954 | #ifndef SQLITE_OMIT_PROGRESS_CALLBACK |
955 | /* Call the progress callback if it is configured and the required number |
956 | ** of VDBE ops have been executed (either since this invocation of |
957 | ** sqlite3VdbeExec() or since last time the progress callback was called). |
958 | ** If the progress callback returns non-zero, exit the virtual machine with |
959 | ** a return code SQLITE_ABORT. |
960 | */ |
961 | while( nVmStep>=nProgressLimit && db->xProgress!=0 ){ |
962 | assert( db->nProgressOps!=0 ); |
963 | nProgressLimit += db->nProgressOps; |
964 | if( db->xProgress(db->pProgressArg) ){ |
965 | nProgressLimit = LARGEST_UINT64; |
966 | rc = SQLITE_INTERRUPT; |
967 | goto abort_due_to_error; |
968 | } |
969 | } |
970 | #endif |
971 | |
972 | break; |
973 | } |
974 | |
975 | /* Opcode: Gosub P1 P2 * * * |
976 | ** |
977 | ** Write the current address onto register P1 |
978 | ** and then jump to address P2. |
979 | */ |
980 | case OP_Gosub: { /* jump */ |
981 | assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
982 | pIn1 = &aMem[pOp->p1]; |
983 | assert( VdbeMemDynamic(pIn1)==0 ); |
984 | memAboutToChange(p, pIn1); |
985 | pIn1->flags = MEM_Int; |
986 | pIn1->u.i = (int)(pOp-aOp); |
987 | REGISTER_TRACE(pOp->p1, pIn1); |
988 | goto jump_to_p2_and_check_for_interrupt; |
989 | } |
990 | |
991 | /* Opcode: Return P1 P2 P3 * * |
992 | ** |
993 | ** Jump to the address stored in register P1. If P1 is a return address |
994 | ** register, then this accomplishes a return from a subroutine. |
995 | ** |
996 | ** If P3 is 1, then the jump is only taken if register P1 holds an integer |
997 | ** values, otherwise execution falls through to the next opcode, and the |
998 | ** OP_Return becomes a no-op. If P3 is 0, then register P1 must hold an |
999 | ** integer or else an assert() is raised. P3 should be set to 1 when |
1000 | ** this opcode is used in combination with OP_BeginSubrtn, and set to 0 |
1001 | ** otherwise. |
1002 | ** |
1003 | ** The value in register P1 is unchanged by this opcode. |
1004 | ** |
1005 | ** P2 is not used by the byte-code engine. However, if P2 is positive |
1006 | ** and also less than the current address, then the "EXPLAIN" output |
1007 | ** formatter in the CLI will indent all opcodes from the P2 opcode up |
1008 | ** to be not including the current Return. P2 should be the first opcode |
1009 | ** in the subroutine from which this opcode is returning. Thus the P2 |
1010 | ** value is a byte-code indentation hint. See tag-20220407a in |
1011 | ** wherecode.c and shell.c. |
1012 | */ |
1013 | case OP_Return: { /* in1 */ |
1014 | pIn1 = &aMem[pOp->p1]; |
1015 | if( pIn1->flags & MEM_Int ){ |
1016 | if( pOp->p3 ){ VdbeBranchTaken(1, 2); } |
1017 | pOp = &aOp[pIn1->u.i]; |
1018 | }else if( ALWAYS(pOp->p3) ){ |
1019 | VdbeBranchTaken(0, 2); |
1020 | } |
1021 | break; |
1022 | } |
1023 | |
1024 | /* Opcode: InitCoroutine P1 P2 P3 * * |
1025 | ** |
1026 | ** Set up register P1 so that it will Yield to the coroutine |
1027 | ** located at address P3. |
1028 | ** |
1029 | ** If P2!=0 then the coroutine implementation immediately follows |
1030 | ** this opcode. So jump over the coroutine implementation to |
1031 | ** address P2. |
1032 | ** |
1033 | ** See also: EndCoroutine |
1034 | */ |
1035 | case OP_InitCoroutine: { /* jump */ |
1036 | assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
1037 | assert( pOp->p2>=0 && pOp->p2<p->nOp ); |
1038 | assert( pOp->p3>=0 && pOp->p3<p->nOp ); |
1039 | pOut = &aMem[pOp->p1]; |
1040 | assert( !VdbeMemDynamic(pOut) ); |
1041 | pOut->u.i = pOp->p3 - 1; |
1042 | pOut->flags = MEM_Int; |
1043 | if( pOp->p2==0 ) break; |
1044 | |
1045 | /* Most jump operations do a goto to this spot in order to update |
1046 | ** the pOp pointer. */ |
1047 | jump_to_p2: |
1048 | assert( pOp->p2>0 ); /* There are never any jumps to instruction 0 */ |
1049 | assert( pOp->p2<p->nOp ); /* Jumps must be in range */ |
1050 | pOp = &aOp[pOp->p2 - 1]; |
1051 | break; |
1052 | } |
1053 | |
1054 | /* Opcode: EndCoroutine P1 * * * * |
1055 | ** |
1056 | ** The instruction at the address in register P1 is a Yield. |
1057 | ** Jump to the P2 parameter of that Yield. |
1058 | ** After the jump, register P1 becomes undefined. |
1059 | ** |
1060 | ** See also: InitCoroutine |
1061 | */ |
1062 | case OP_EndCoroutine: { /* in1 */ |
1063 | VdbeOp *pCaller; |
1064 | pIn1 = &aMem[pOp->p1]; |
1065 | assert( pIn1->flags==MEM_Int ); |
1066 | assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp ); |
1067 | pCaller = &aOp[pIn1->u.i]; |
1068 | assert( pCaller->opcode==OP_Yield ); |
1069 | assert( pCaller->p2>=0 && pCaller->p2<p->nOp ); |
1070 | pOp = &aOp[pCaller->p2 - 1]; |
1071 | pIn1->flags = MEM_Undefined; |
1072 | break; |
1073 | } |
1074 | |
1075 | /* Opcode: Yield P1 P2 * * * |
1076 | ** |
1077 | ** Swap the program counter with the value in register P1. This |
1078 | ** has the effect of yielding to a coroutine. |
1079 | ** |
1080 | ** If the coroutine that is launched by this instruction ends with |
1081 | ** Yield or Return then continue to the next instruction. But if |
1082 | ** the coroutine launched by this instruction ends with |
1083 | ** EndCoroutine, then jump to P2 rather than continuing with the |
1084 | ** next instruction. |
1085 | ** |
1086 | ** See also: InitCoroutine |
1087 | */ |
1088 | case OP_Yield: { /* in1, jump */ |
1089 | int pcDest; |
1090 | pIn1 = &aMem[pOp->p1]; |
1091 | assert( VdbeMemDynamic(pIn1)==0 ); |
1092 | pIn1->flags = MEM_Int; |
1093 | pcDest = (int)pIn1->u.i; |
1094 | pIn1->u.i = (int)(pOp - aOp); |
1095 | REGISTER_TRACE(pOp->p1, pIn1); |
1096 | pOp = &aOp[pcDest]; |
1097 | break; |
1098 | } |
1099 | |
1100 | /* Opcode: HaltIfNull P1 P2 P3 P4 P5 |
1101 | ** Synopsis: if r[P3]=null halt |
1102 | ** |
1103 | ** Check the value in register P3. If it is NULL then Halt using |
1104 | ** parameter P1, P2, and P4 as if this were a Halt instruction. If the |
1105 | ** value in register P3 is not NULL, then this routine is a no-op. |
1106 | ** The P5 parameter should be 1. |
1107 | */ |
1108 | case OP_HaltIfNull: { /* in3 */ |
1109 | pIn3 = &aMem[pOp->p3]; |
1110 | #ifdef SQLITE_DEBUG |
1111 | if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } |
1112 | #endif |
1113 | if( (pIn3->flags & MEM_Null)==0 ) break; |
1114 | /* Fall through into OP_Halt */ |
1115 | /* no break */ deliberate_fall_through |
1116 | } |
1117 | |
1118 | /* Opcode: Halt P1 P2 * P4 P5 |
1119 | ** |
1120 | ** Exit immediately. All open cursors, etc are closed |
1121 | ** automatically. |
1122 | ** |
1123 | ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(), |
1124 | ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0). |
1125 | ** For errors, it can be some other value. If P1!=0 then P2 will determine |
1126 | ** whether or not to rollback the current transaction. Do not rollback |
1127 | ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort, |
1128 | ** then back out all changes that have occurred during this execution of the |
1129 | ** VDBE, but do not rollback the transaction. |
1130 | ** |
1131 | ** If P4 is not null then it is an error message string. |
1132 | ** |
1133 | ** P5 is a value between 0 and 4, inclusive, that modifies the P4 string. |
1134 | ** |
1135 | ** 0: (no change) |
1136 | ** 1: NOT NULL contraint failed: P4 |
1137 | ** 2: UNIQUE constraint failed: P4 |
1138 | ** 3: CHECK constraint failed: P4 |
1139 | ** 4: FOREIGN KEY constraint failed: P4 |
1140 | ** |
1141 | ** If P5 is not zero and P4 is NULL, then everything after the ":" is |
1142 | ** omitted. |
1143 | ** |
1144 | ** There is an implied "Halt 0 0 0" instruction inserted at the very end of |
1145 | ** every program. So a jump past the last instruction of the program |
1146 | ** is the same as executing Halt. |
1147 | */ |
1148 | case OP_Halt: { |
1149 | VdbeFrame *pFrame; |
1150 | int pcx; |
1151 | |
1152 | #ifdef SQLITE_DEBUG |
1153 | if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } |
1154 | #endif |
1155 | if( p->pFrame && pOp->p1==SQLITE_OK ){ |
1156 | /* Halt the sub-program. Return control to the parent frame. */ |
1157 | pFrame = p->pFrame; |
1158 | p->pFrame = pFrame->pParent; |
1159 | p->nFrame--; |
1160 | sqlite3VdbeSetChanges(db, p->nChange); |
1161 | pcx = sqlite3VdbeFrameRestore(pFrame); |
1162 | if( pOp->p2==OE_Ignore ){ |
1163 | /* Instruction pcx is the OP_Program that invoked the sub-program |
1164 | ** currently being halted. If the p2 instruction of this OP_Halt |
1165 | ** instruction is set to OE_Ignore, then the sub-program is throwing |
1166 | ** an IGNORE exception. In this case jump to the address specified |
1167 | ** as the p2 of the calling OP_Program. */ |
1168 | pcx = p->aOp[pcx].p2-1; |
1169 | } |
1170 | aOp = p->aOp; |
1171 | aMem = p->aMem; |
1172 | pOp = &aOp[pcx]; |
1173 | break; |
1174 | } |
1175 | p->rc = pOp->p1; |
1176 | p->errorAction = (u8)pOp->p2; |
1177 | assert( pOp->p5<=4 ); |
1178 | if( p->rc ){ |
1179 | if( pOp->p5 ){ |
1180 | static const char * const azType[] = { "NOT NULL" , "UNIQUE" , "CHECK" , |
1181 | "FOREIGN KEY" }; |
1182 | testcase( pOp->p5==1 ); |
1183 | testcase( pOp->p5==2 ); |
1184 | testcase( pOp->p5==3 ); |
1185 | testcase( pOp->p5==4 ); |
1186 | sqlite3VdbeError(p, "%s constraint failed" , azType[pOp->p5-1]); |
1187 | if( pOp->p4.z ){ |
1188 | p->zErrMsg = sqlite3MPrintf(db, "%z: %s" , p->zErrMsg, pOp->p4.z); |
1189 | } |
1190 | }else{ |
1191 | sqlite3VdbeError(p, "%s" , pOp->p4.z); |
1192 | } |
1193 | pcx = (int)(pOp - aOp); |
1194 | sqlite3_log(pOp->p1, "abort at %d in [%s]: %s" , pcx, p->zSql, p->zErrMsg); |
1195 | } |
1196 | rc = sqlite3VdbeHalt(p); |
1197 | assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR ); |
1198 | if( rc==SQLITE_BUSY ){ |
1199 | p->rc = SQLITE_BUSY; |
1200 | }else{ |
1201 | assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ); |
1202 | assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 ); |
1203 | rc = p->rc ? SQLITE_ERROR : SQLITE_DONE; |
1204 | } |
1205 | goto vdbe_return; |
1206 | } |
1207 | |
1208 | /* Opcode: Integer P1 P2 * * * |
1209 | ** Synopsis: r[P2]=P1 |
1210 | ** |
1211 | ** The 32-bit integer value P1 is written into register P2. |
1212 | */ |
1213 | case OP_Integer: { /* out2 */ |
1214 | pOut = out2Prerelease(p, pOp); |
1215 | pOut->u.i = pOp->p1; |
1216 | break; |
1217 | } |
1218 | |
1219 | /* Opcode: Int64 * P2 * P4 * |
1220 | ** Synopsis: r[P2]=P4 |
1221 | ** |
1222 | ** P4 is a pointer to a 64-bit integer value. |
1223 | ** Write that value into register P2. |
1224 | */ |
1225 | case OP_Int64: { /* out2 */ |
1226 | pOut = out2Prerelease(p, pOp); |
1227 | assert( pOp->p4.pI64!=0 ); |
1228 | pOut->u.i = *pOp->p4.pI64; |
1229 | break; |
1230 | } |
1231 | |
1232 | #ifndef SQLITE_OMIT_FLOATING_POINT |
1233 | /* Opcode: Real * P2 * P4 * |
1234 | ** Synopsis: r[P2]=P4 |
1235 | ** |
1236 | ** P4 is a pointer to a 64-bit floating point value. |
1237 | ** Write that value into register P2. |
1238 | */ |
1239 | case OP_Real: { /* same as TK_FLOAT, out2 */ |
1240 | pOut = out2Prerelease(p, pOp); |
1241 | pOut->flags = MEM_Real; |
1242 | assert( !sqlite3IsNaN(*pOp->p4.pReal) ); |
1243 | pOut->u.r = *pOp->p4.pReal; |
1244 | break; |
1245 | } |
1246 | #endif |
1247 | |
1248 | /* Opcode: String8 * P2 * P4 * |
1249 | ** Synopsis: r[P2]='P4' |
1250 | ** |
1251 | ** P4 points to a nul terminated UTF-8 string. This opcode is transformed |
1252 | ** into a String opcode before it is executed for the first time. During |
1253 | ** this transformation, the length of string P4 is computed and stored |
1254 | ** as the P1 parameter. |
1255 | */ |
1256 | case OP_String8: { /* same as TK_STRING, out2 */ |
1257 | assert( pOp->p4.z!=0 ); |
1258 | pOut = out2Prerelease(p, pOp); |
1259 | pOp->p1 = sqlite3Strlen30(pOp->p4.z); |
1260 | |
1261 | #ifndef SQLITE_OMIT_UTF16 |
1262 | if( encoding!=SQLITE_UTF8 ){ |
1263 | rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC); |
1264 | assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG ); |
1265 | if( rc ) goto too_big; |
1266 | if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem; |
1267 | assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z ); |
1268 | assert( VdbeMemDynamic(pOut)==0 ); |
1269 | pOut->szMalloc = 0; |
1270 | pOut->flags |= MEM_Static; |
1271 | if( pOp->p4type==P4_DYNAMIC ){ |
1272 | sqlite3DbFree(db, pOp->p4.z); |
1273 | } |
1274 | pOp->p4type = P4_DYNAMIC; |
1275 | pOp->p4.z = pOut->z; |
1276 | pOp->p1 = pOut->n; |
1277 | } |
1278 | #endif |
1279 | if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ |
1280 | goto too_big; |
1281 | } |
1282 | pOp->opcode = OP_String; |
1283 | assert( rc==SQLITE_OK ); |
1284 | /* Fall through to the next case, OP_String */ |
1285 | /* no break */ deliberate_fall_through |
1286 | } |
1287 | |
1288 | /* Opcode: String P1 P2 P3 P4 P5 |
1289 | ** Synopsis: r[P2]='P4' (len=P1) |
1290 | ** |
1291 | ** The string value P4 of length P1 (bytes) is stored in register P2. |
1292 | ** |
1293 | ** If P3 is not zero and the content of register P3 is equal to P5, then |
1294 | ** the datatype of the register P2 is converted to BLOB. The content is |
1295 | ** the same sequence of bytes, it is merely interpreted as a BLOB instead |
1296 | ** of a string, as if it had been CAST. In other words: |
1297 | ** |
1298 | ** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB) |
1299 | */ |
1300 | case OP_String: { /* out2 */ |
1301 | assert( pOp->p4.z!=0 ); |
1302 | pOut = out2Prerelease(p, pOp); |
1303 | pOut->flags = MEM_Str|MEM_Static|MEM_Term; |
1304 | pOut->z = pOp->p4.z; |
1305 | pOut->n = pOp->p1; |
1306 | pOut->enc = encoding; |
1307 | UPDATE_MAX_BLOBSIZE(pOut); |
1308 | #ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS |
1309 | if( pOp->p3>0 ){ |
1310 | assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
1311 | pIn3 = &aMem[pOp->p3]; |
1312 | assert( pIn3->flags & MEM_Int ); |
1313 | if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term; |
1314 | } |
1315 | #endif |
1316 | break; |
1317 | } |
1318 | |
1319 | /* Opcode: BeginSubrtn * P2 * * * |
1320 | ** Synopsis: r[P2]=NULL |
1321 | ** |
1322 | ** Mark the beginning of a subroutine that can be entered in-line |
1323 | ** or that can be called using OP_Gosub. The subroutine should |
1324 | ** be terminated by an OP_Return instruction that has a P1 operand that |
1325 | ** is the same as the P2 operand to this opcode and that has P3 set to 1. |
1326 | ** If the subroutine is entered in-line, then the OP_Return will simply |
1327 | ** fall through. But if the subroutine is entered using OP_Gosub, then |
1328 | ** the OP_Return will jump back to the first instruction after the OP_Gosub. |
1329 | ** |
1330 | ** This routine works by loading a NULL into the P2 register. When the |
1331 | ** return address register contains a NULL, the OP_Return instruction is |
1332 | ** a no-op that simply falls through to the next instruction (assuming that |
1333 | ** the OP_Return opcode has a P3 value of 1). Thus if the subroutine is |
1334 | ** entered in-line, then the OP_Return will cause in-line execution to |
1335 | ** continue. But if the subroutine is entered via OP_Gosub, then the |
1336 | ** OP_Return will cause a return to the address following the OP_Gosub. |
1337 | ** |
1338 | ** This opcode is identical to OP_Null. It has a different name |
1339 | ** only to make the byte code easier to read and verify. |
1340 | */ |
1341 | /* Opcode: Null P1 P2 P3 * * |
1342 | ** Synopsis: r[P2..P3]=NULL |
1343 | ** |
1344 | ** Write a NULL into registers P2. If P3 greater than P2, then also write |
1345 | ** NULL into register P3 and every register in between P2 and P3. If P3 |
1346 | ** is less than P2 (typically P3 is zero) then only register P2 is |
1347 | ** set to NULL. |
1348 | ** |
1349 | ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that |
1350 | ** NULL values will not compare equal even if SQLITE_NULLEQ is set on |
1351 | ** OP_Ne or OP_Eq. |
1352 | */ |
1353 | case OP_BeginSubrtn: |
1354 | case OP_Null: { /* out2 */ |
1355 | int cnt; |
1356 | u16 nullFlag; |
1357 | pOut = out2Prerelease(p, pOp); |
1358 | cnt = pOp->p3-pOp->p2; |
1359 | assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
1360 | pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null; |
1361 | pOut->n = 0; |
1362 | #ifdef SQLITE_DEBUG |
1363 | pOut->uTemp = 0; |
1364 | #endif |
1365 | while( cnt>0 ){ |
1366 | pOut++; |
1367 | memAboutToChange(p, pOut); |
1368 | sqlite3VdbeMemSetNull(pOut); |
1369 | pOut->flags = nullFlag; |
1370 | pOut->n = 0; |
1371 | cnt--; |
1372 | } |
1373 | break; |
1374 | } |
1375 | |
1376 | /* Opcode: SoftNull P1 * * * * |
1377 | ** Synopsis: r[P1]=NULL |
1378 | ** |
1379 | ** Set register P1 to have the value NULL as seen by the OP_MakeRecord |
1380 | ** instruction, but do not free any string or blob memory associated with |
1381 | ** the register, so that if the value was a string or blob that was |
1382 | ** previously copied using OP_SCopy, the copies will continue to be valid. |
1383 | */ |
1384 | case OP_SoftNull: { |
1385 | assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
1386 | pOut = &aMem[pOp->p1]; |
1387 | pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null; |
1388 | break; |
1389 | } |
1390 | |
1391 | /* Opcode: Blob P1 P2 * P4 * |
1392 | ** Synopsis: r[P2]=P4 (len=P1) |
1393 | ** |
1394 | ** P4 points to a blob of data P1 bytes long. Store this |
1395 | ** blob in register P2. If P4 is a NULL pointer, then construct |
1396 | ** a zero-filled blob that is P1 bytes long in P2. |
1397 | */ |
1398 | case OP_Blob: { /* out2 */ |
1399 | assert( pOp->p1 <= SQLITE_MAX_LENGTH ); |
1400 | pOut = out2Prerelease(p, pOp); |
1401 | if( pOp->p4.z==0 ){ |
1402 | sqlite3VdbeMemSetZeroBlob(pOut, pOp->p1); |
1403 | if( sqlite3VdbeMemExpandBlob(pOut) ) goto no_mem; |
1404 | }else{ |
1405 | sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0); |
1406 | } |
1407 | pOut->enc = encoding; |
1408 | UPDATE_MAX_BLOBSIZE(pOut); |
1409 | break; |
1410 | } |
1411 | |
1412 | /* Opcode: Variable P1 P2 * P4 * |
1413 | ** Synopsis: r[P2]=parameter(P1,P4) |
1414 | ** |
1415 | ** Transfer the values of bound parameter P1 into register P2 |
1416 | ** |
1417 | ** If the parameter is named, then its name appears in P4. |
1418 | ** The P4 value is used by sqlite3_bind_parameter_name(). |
1419 | */ |
1420 | case OP_Variable: { /* out2 */ |
1421 | Mem *pVar; /* Value being transferred */ |
1422 | |
1423 | assert( pOp->p1>0 && pOp->p1<=p->nVar ); |
1424 | assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) ); |
1425 | pVar = &p->aVar[pOp->p1 - 1]; |
1426 | if( sqlite3VdbeMemTooBig(pVar) ){ |
1427 | goto too_big; |
1428 | } |
1429 | pOut = &aMem[pOp->p2]; |
1430 | if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut); |
1431 | memcpy(pOut, pVar, MEMCELLSIZE); |
1432 | pOut->flags &= ~(MEM_Dyn|MEM_Ephem); |
1433 | pOut->flags |= MEM_Static|MEM_FromBind; |
1434 | UPDATE_MAX_BLOBSIZE(pOut); |
1435 | break; |
1436 | } |
1437 | |
1438 | /* Opcode: Move P1 P2 P3 * * |
1439 | ** Synopsis: r[P2@P3]=r[P1@P3] |
1440 | ** |
1441 | ** Move the P3 values in register P1..P1+P3-1 over into |
1442 | ** registers P2..P2+P3-1. Registers P1..P1+P3-1 are |
1443 | ** left holding a NULL. It is an error for register ranges |
1444 | ** P1..P1+P3-1 and P2..P2+P3-1 to overlap. It is an error |
1445 | ** for P3 to be less than 1. |
1446 | */ |
1447 | case OP_Move: { |
1448 | int n; /* Number of registers left to copy */ |
1449 | int p1; /* Register to copy from */ |
1450 | int p2; /* Register to copy to */ |
1451 | |
1452 | n = pOp->p3; |
1453 | p1 = pOp->p1; |
1454 | p2 = pOp->p2; |
1455 | assert( n>0 && p1>0 && p2>0 ); |
1456 | assert( p1+n<=p2 || p2+n<=p1 ); |
1457 | |
1458 | pIn1 = &aMem[p1]; |
1459 | pOut = &aMem[p2]; |
1460 | do{ |
1461 | assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] ); |
1462 | assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] ); |
1463 | assert( memIsValid(pIn1) ); |
1464 | memAboutToChange(p, pOut); |
1465 | sqlite3VdbeMemMove(pOut, pIn1); |
1466 | #ifdef SQLITE_DEBUG |
1467 | pIn1->pScopyFrom = 0; |
1468 | { int i; |
1469 | for(i=1; i<p->nMem; i++){ |
1470 | if( aMem[i].pScopyFrom==pIn1 ){ |
1471 | aMem[i].pScopyFrom = pOut; |
1472 | } |
1473 | } |
1474 | } |
1475 | #endif |
1476 | Deephemeralize(pOut); |
1477 | REGISTER_TRACE(p2++, pOut); |
1478 | pIn1++; |
1479 | pOut++; |
1480 | }while( --n ); |
1481 | break; |
1482 | } |
1483 | |
1484 | /* Opcode: Copy P1 P2 P3 * P5 |
1485 | ** Synopsis: r[P2@P3+1]=r[P1@P3+1] |
1486 | ** |
1487 | ** Make a copy of registers P1..P1+P3 into registers P2..P2+P3. |
1488 | ** |
1489 | ** If the 0x0002 bit of P5 is set then also clear the MEM_Subtype flag in the |
1490 | ** destination. The 0x0001 bit of P5 indicates that this Copy opcode cannot |
1491 | ** be merged. The 0x0001 bit is used by the query planner and does not |
1492 | ** come into play during query execution. |
1493 | ** |
1494 | ** This instruction makes a deep copy of the value. A duplicate |
1495 | ** is made of any string or blob constant. See also OP_SCopy. |
1496 | */ |
1497 | case OP_Copy: { |
1498 | int n; |
1499 | |
1500 | n = pOp->p3; |
1501 | pIn1 = &aMem[pOp->p1]; |
1502 | pOut = &aMem[pOp->p2]; |
1503 | assert( pOut!=pIn1 ); |
1504 | while( 1 ){ |
1505 | memAboutToChange(p, pOut); |
1506 | sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); |
1507 | Deephemeralize(pOut); |
1508 | if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){ |
1509 | pOut->flags &= ~MEM_Subtype; |
1510 | } |
1511 | #ifdef SQLITE_DEBUG |
1512 | pOut->pScopyFrom = 0; |
1513 | #endif |
1514 | REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut); |
1515 | if( (n--)==0 ) break; |
1516 | pOut++; |
1517 | pIn1++; |
1518 | } |
1519 | break; |
1520 | } |
1521 | |
1522 | /* Opcode: SCopy P1 P2 * * * |
1523 | ** Synopsis: r[P2]=r[P1] |
1524 | ** |
1525 | ** Make a shallow copy of register P1 into register P2. |
1526 | ** |
1527 | ** This instruction makes a shallow copy of the value. If the value |
1528 | ** is a string or blob, then the copy is only a pointer to the |
1529 | ** original and hence if the original changes so will the copy. |
1530 | ** Worse, if the original is deallocated, the copy becomes invalid. |
1531 | ** Thus the program must guarantee that the original will not change |
1532 | ** during the lifetime of the copy. Use OP_Copy to make a complete |
1533 | ** copy. |
1534 | */ |
1535 | case OP_SCopy: { /* out2 */ |
1536 | pIn1 = &aMem[pOp->p1]; |
1537 | pOut = &aMem[pOp->p2]; |
1538 | assert( pOut!=pIn1 ); |
1539 | sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); |
1540 | #ifdef SQLITE_DEBUG |
1541 | pOut->pScopyFrom = pIn1; |
1542 | pOut->mScopyFlags = pIn1->flags; |
1543 | #endif |
1544 | break; |
1545 | } |
1546 | |
1547 | /* Opcode: IntCopy P1 P2 * * * |
1548 | ** Synopsis: r[P2]=r[P1] |
1549 | ** |
1550 | ** Transfer the integer value held in register P1 into register P2. |
1551 | ** |
1552 | ** This is an optimized version of SCopy that works only for integer |
1553 | ** values. |
1554 | */ |
1555 | case OP_IntCopy: { /* out2 */ |
1556 | pIn1 = &aMem[pOp->p1]; |
1557 | assert( (pIn1->flags & MEM_Int)!=0 ); |
1558 | pOut = &aMem[pOp->p2]; |
1559 | sqlite3VdbeMemSetInt64(pOut, pIn1->u.i); |
1560 | break; |
1561 | } |
1562 | |
1563 | /* Opcode: FkCheck * * * * * |
1564 | ** |
1565 | ** Halt with an SQLITE_CONSTRAINT error if there are any unresolved |
1566 | ** foreign key constraint violations. If there are no foreign key |
1567 | ** constraint violations, this is a no-op. |
1568 | ** |
1569 | ** FK constraint violations are also checked when the prepared statement |
1570 | ** exits. This opcode is used to raise foreign key constraint errors prior |
1571 | ** to returning results such as a row change count or the result of a |
1572 | ** RETURNING clause. |
1573 | */ |
1574 | case OP_FkCheck: { |
1575 | if( (rc = sqlite3VdbeCheckFk(p,0))!=SQLITE_OK ){ |
1576 | goto abort_due_to_error; |
1577 | } |
1578 | break; |
1579 | } |
1580 | |
1581 | /* Opcode: ResultRow P1 P2 * * * |
1582 | ** Synopsis: output=r[P1@P2] |
1583 | ** |
1584 | ** The registers P1 through P1+P2-1 contain a single row of |
1585 | ** results. This opcode causes the sqlite3_step() call to terminate |
1586 | ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt |
1587 | ** structure to provide access to the r(P1)..r(P1+P2-1) values as |
1588 | ** the result row. |
1589 | */ |
1590 | case OP_ResultRow: { |
1591 | assert( p->nResColumn==pOp->p2 ); |
1592 | assert( pOp->p1>0 || CORRUPT_DB ); |
1593 | assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 ); |
1594 | |
1595 | p->cacheCtr = (p->cacheCtr + 2)|1; |
1596 | p->pResultSet = &aMem[pOp->p1]; |
1597 | #ifdef SQLITE_DEBUG |
1598 | { |
1599 | Mem *pMem = p->pResultSet; |
1600 | int i; |
1601 | for(i=0; i<pOp->p2; i++){ |
1602 | assert( memIsValid(&pMem[i]) ); |
1603 | REGISTER_TRACE(pOp->p1+i, &pMem[i]); |
1604 | /* The registers in the result will not be used again when the |
1605 | ** prepared statement restarts. This is because sqlite3_column() |
1606 | ** APIs might have caused type conversions of made other changes to |
1607 | ** the register values. Therefore, we can go ahead and break any |
1608 | ** OP_SCopy dependencies. */ |
1609 | pMem[i].pScopyFrom = 0; |
1610 | } |
1611 | } |
1612 | #endif |
1613 | if( db->mallocFailed ) goto no_mem; |
1614 | if( db->mTrace & SQLITE_TRACE_ROW ){ |
1615 | db->trace.xV2(SQLITE_TRACE_ROW, db->pTraceArg, p, 0); |
1616 | } |
1617 | p->pc = (int)(pOp - aOp) + 1; |
1618 | rc = SQLITE_ROW; |
1619 | goto vdbe_return; |
1620 | } |
1621 | |
1622 | /* Opcode: Concat P1 P2 P3 * * |
1623 | ** Synopsis: r[P3]=r[P2]+r[P1] |
1624 | ** |
1625 | ** Add the text in register P1 onto the end of the text in |
1626 | ** register P2 and store the result in register P3. |
1627 | ** If either the P1 or P2 text are NULL then store NULL in P3. |
1628 | ** |
1629 | ** P3 = P2 || P1 |
1630 | ** |
1631 | ** It is illegal for P1 and P3 to be the same register. Sometimes, |
1632 | ** if P3 is the same register as P2, the implementation is able |
1633 | ** to avoid a memcpy(). |
1634 | */ |
1635 | case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */ |
1636 | i64 nByte; /* Total size of the output string or blob */ |
1637 | u16 flags1; /* Initial flags for P1 */ |
1638 | u16 flags2; /* Initial flags for P2 */ |
1639 | |
1640 | pIn1 = &aMem[pOp->p1]; |
1641 | pIn2 = &aMem[pOp->p2]; |
1642 | pOut = &aMem[pOp->p3]; |
1643 | testcase( pOut==pIn2 ); |
1644 | assert( pIn1!=pOut ); |
1645 | flags1 = pIn1->flags; |
1646 | testcase( flags1 & MEM_Null ); |
1647 | testcase( pIn2->flags & MEM_Null ); |
1648 | if( (flags1 | pIn2->flags) & MEM_Null ){ |
1649 | sqlite3VdbeMemSetNull(pOut); |
1650 | break; |
1651 | } |
1652 | if( (flags1 & (MEM_Str|MEM_Blob))==0 ){ |
1653 | if( sqlite3VdbeMemStringify(pIn1,encoding,0) ) goto no_mem; |
1654 | flags1 = pIn1->flags & ~MEM_Str; |
1655 | }else if( (flags1 & MEM_Zero)!=0 ){ |
1656 | if( sqlite3VdbeMemExpandBlob(pIn1) ) goto no_mem; |
1657 | flags1 = pIn1->flags & ~MEM_Str; |
1658 | } |
1659 | flags2 = pIn2->flags; |
1660 | if( (flags2 & (MEM_Str|MEM_Blob))==0 ){ |
1661 | if( sqlite3VdbeMemStringify(pIn2,encoding,0) ) goto no_mem; |
1662 | flags2 = pIn2->flags & ~MEM_Str; |
1663 | }else if( (flags2 & MEM_Zero)!=0 ){ |
1664 | if( sqlite3VdbeMemExpandBlob(pIn2) ) goto no_mem; |
1665 | flags2 = pIn2->flags & ~MEM_Str; |
1666 | } |
1667 | nByte = pIn1->n + pIn2->n; |
1668 | if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ |
1669 | goto too_big; |
1670 | } |
1671 | if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){ |
1672 | goto no_mem; |
1673 | } |
1674 | MemSetTypeFlag(pOut, MEM_Str); |
1675 | if( pOut!=pIn2 ){ |
1676 | memcpy(pOut->z, pIn2->z, pIn2->n); |
1677 | assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) ); |
1678 | pIn2->flags = flags2; |
1679 | } |
1680 | memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n); |
1681 | assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); |
1682 | pIn1->flags = flags1; |
1683 | if( encoding>SQLITE_UTF8 ) nByte &= ~1; |
1684 | pOut->z[nByte]=0; |
1685 | pOut->z[nByte+1] = 0; |
1686 | pOut->flags |= MEM_Term; |
1687 | pOut->n = (int)nByte; |
1688 | pOut->enc = encoding; |
1689 | UPDATE_MAX_BLOBSIZE(pOut); |
1690 | break; |
1691 | } |
1692 | |
1693 | /* Opcode: Add P1 P2 P3 * * |
1694 | ** Synopsis: r[P3]=r[P1]+r[P2] |
1695 | ** |
1696 | ** Add the value in register P1 to the value in register P2 |
1697 | ** and store the result in register P3. |
1698 | ** If either input is NULL, the result is NULL. |
1699 | */ |
1700 | /* Opcode: Multiply P1 P2 P3 * * |
1701 | ** Synopsis: r[P3]=r[P1]*r[P2] |
1702 | ** |
1703 | ** |
1704 | ** Multiply the value in register P1 by the value in register P2 |
1705 | ** and store the result in register P3. |
1706 | ** If either input is NULL, the result is NULL. |
1707 | */ |
1708 | /* Opcode: Subtract P1 P2 P3 * * |
1709 | ** Synopsis: r[P3]=r[P2]-r[P1] |
1710 | ** |
1711 | ** Subtract the value in register P1 from the value in register P2 |
1712 | ** and store the result in register P3. |
1713 | ** If either input is NULL, the result is NULL. |
1714 | */ |
1715 | /* Opcode: Divide P1 P2 P3 * * |
1716 | ** Synopsis: r[P3]=r[P2]/r[P1] |
1717 | ** |
1718 | ** Divide the value in register P1 by the value in register P2 |
1719 | ** and store the result in register P3 (P3=P2/P1). If the value in |
1720 | ** register P1 is zero, then the result is NULL. If either input is |
1721 | ** NULL, the result is NULL. |
1722 | */ |
1723 | /* Opcode: Remainder P1 P2 P3 * * |
1724 | ** Synopsis: r[P3]=r[P2]%r[P1] |
1725 | ** |
1726 | ** Compute the remainder after integer register P2 is divided by |
1727 | ** register P1 and store the result in register P3. |
1728 | ** If the value in register P1 is zero the result is NULL. |
1729 | ** If either operand is NULL, the result is NULL. |
1730 | */ |
1731 | case OP_Add: /* same as TK_PLUS, in1, in2, out3 */ |
1732 | case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */ |
1733 | case OP_Multiply: /* same as TK_STAR, in1, in2, out3 */ |
1734 | case OP_Divide: /* same as TK_SLASH, in1, in2, out3 */ |
1735 | case OP_Remainder: { /* same as TK_REM, in1, in2, out3 */ |
1736 | u16 type1; /* Numeric type of left operand */ |
1737 | u16 type2; /* Numeric type of right operand */ |
1738 | i64 iA; /* Integer value of left operand */ |
1739 | i64 iB; /* Integer value of right operand */ |
1740 | double rA; /* Real value of left operand */ |
1741 | double rB; /* Real value of right operand */ |
1742 | |
1743 | pIn1 = &aMem[pOp->p1]; |
1744 | type1 = pIn1->flags; |
1745 | pIn2 = &aMem[pOp->p2]; |
1746 | type2 = pIn2->flags; |
1747 | pOut = &aMem[pOp->p3]; |
1748 | if( (type1 & type2 & MEM_Int)!=0 ){ |
1749 | int_math: |
1750 | iA = pIn1->u.i; |
1751 | iB = pIn2->u.i; |
1752 | switch( pOp->opcode ){ |
1753 | case OP_Add: if( sqlite3AddInt64(&iB,iA) ) goto fp_math; break; |
1754 | case OP_Subtract: if( sqlite3SubInt64(&iB,iA) ) goto fp_math; break; |
1755 | case OP_Multiply: if( sqlite3MulInt64(&iB,iA) ) goto fp_math; break; |
1756 | case OP_Divide: { |
1757 | if( iA==0 ) goto arithmetic_result_is_null; |
1758 | if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math; |
1759 | iB /= iA; |
1760 | break; |
1761 | } |
1762 | default: { |
1763 | if( iA==0 ) goto arithmetic_result_is_null; |
1764 | if( iA==-1 ) iA = 1; |
1765 | iB %= iA; |
1766 | break; |
1767 | } |
1768 | } |
1769 | pOut->u.i = iB; |
1770 | MemSetTypeFlag(pOut, MEM_Int); |
1771 | }else if( ((type1 | type2) & MEM_Null)!=0 ){ |
1772 | goto arithmetic_result_is_null; |
1773 | }else{ |
1774 | type1 = numericType(pIn1); |
1775 | type2 = numericType(pIn2); |
1776 | if( (type1 & type2 & MEM_Int)!=0 ) goto int_math; |
1777 | fp_math: |
1778 | rA = sqlite3VdbeRealValue(pIn1); |
1779 | rB = sqlite3VdbeRealValue(pIn2); |
1780 | switch( pOp->opcode ){ |
1781 | case OP_Add: rB += rA; break; |
1782 | case OP_Subtract: rB -= rA; break; |
1783 | case OP_Multiply: rB *= rA; break; |
1784 | case OP_Divide: { |
1785 | /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ |
1786 | if( rA==(double)0 ) goto arithmetic_result_is_null; |
1787 | rB /= rA; |
1788 | break; |
1789 | } |
1790 | default: { |
1791 | iA = sqlite3VdbeIntValue(pIn1); |
1792 | iB = sqlite3VdbeIntValue(pIn2); |
1793 | if( iA==0 ) goto arithmetic_result_is_null; |
1794 | if( iA==-1 ) iA = 1; |
1795 | rB = (double)(iB % iA); |
1796 | break; |
1797 | } |
1798 | } |
1799 | #ifdef SQLITE_OMIT_FLOATING_POINT |
1800 | pOut->u.i = rB; |
1801 | MemSetTypeFlag(pOut, MEM_Int); |
1802 | #else |
1803 | if( sqlite3IsNaN(rB) ){ |
1804 | goto arithmetic_result_is_null; |
1805 | } |
1806 | pOut->u.r = rB; |
1807 | MemSetTypeFlag(pOut, MEM_Real); |
1808 | #endif |
1809 | } |
1810 | break; |
1811 | |
1812 | arithmetic_result_is_null: |
1813 | sqlite3VdbeMemSetNull(pOut); |
1814 | break; |
1815 | } |
1816 | |
1817 | /* Opcode: CollSeq P1 * * P4 |
1818 | ** |
1819 | ** P4 is a pointer to a CollSeq object. If the next call to a user function |
1820 | ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will |
1821 | ** be returned. This is used by the built-in min(), max() and nullif() |
1822 | ** functions. |
1823 | ** |
1824 | ** If P1 is not zero, then it is a register that a subsequent min() or |
1825 | ** max() aggregate will set to 1 if the current row is not the minimum or |
1826 | ** maximum. The P1 register is initialized to 0 by this instruction. |
1827 | ** |
1828 | ** The interface used by the implementation of the aforementioned functions |
1829 | ** to retrieve the collation sequence set by this opcode is not available |
1830 | ** publicly. Only built-in functions have access to this feature. |
1831 | */ |
1832 | case OP_CollSeq: { |
1833 | assert( pOp->p4type==P4_COLLSEQ ); |
1834 | if( pOp->p1 ){ |
1835 | sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0); |
1836 | } |
1837 | break; |
1838 | } |
1839 | |
1840 | /* Opcode: BitAnd P1 P2 P3 * * |
1841 | ** Synopsis: r[P3]=r[P1]&r[P2] |
1842 | ** |
1843 | ** Take the bit-wise AND of the values in register P1 and P2 and |
1844 | ** store the result in register P3. |
1845 | ** If either input is NULL, the result is NULL. |
1846 | */ |
1847 | /* Opcode: BitOr P1 P2 P3 * * |
1848 | ** Synopsis: r[P3]=r[P1]|r[P2] |
1849 | ** |
1850 | ** Take the bit-wise OR of the values in register P1 and P2 and |
1851 | ** store the result in register P3. |
1852 | ** If either input is NULL, the result is NULL. |
1853 | */ |
1854 | /* Opcode: ShiftLeft P1 P2 P3 * * |
1855 | ** Synopsis: r[P3]=r[P2]<<r[P1] |
1856 | ** |
1857 | ** Shift the integer value in register P2 to the left by the |
1858 | ** number of bits specified by the integer in register P1. |
1859 | ** Store the result in register P3. |
1860 | ** If either input is NULL, the result is NULL. |
1861 | */ |
1862 | /* Opcode: ShiftRight P1 P2 P3 * * |
1863 | ** Synopsis: r[P3]=r[P2]>>r[P1] |
1864 | ** |
1865 | ** Shift the integer value in register P2 to the right by the |
1866 | ** number of bits specified by the integer in register P1. |
1867 | ** Store the result in register P3. |
1868 | ** If either input is NULL, the result is NULL. |
1869 | */ |
1870 | case OP_BitAnd: /* same as TK_BITAND, in1, in2, out3 */ |
1871 | case OP_BitOr: /* same as TK_BITOR, in1, in2, out3 */ |
1872 | case OP_ShiftLeft: /* same as TK_LSHIFT, in1, in2, out3 */ |
1873 | case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */ |
1874 | i64 iA; |
1875 | u64 uA; |
1876 | i64 iB; |
1877 | u8 op; |
1878 | |
1879 | pIn1 = &aMem[pOp->p1]; |
1880 | pIn2 = &aMem[pOp->p2]; |
1881 | pOut = &aMem[pOp->p3]; |
1882 | if( (pIn1->flags | pIn2->flags) & MEM_Null ){ |
1883 | sqlite3VdbeMemSetNull(pOut); |
1884 | break; |
1885 | } |
1886 | iA = sqlite3VdbeIntValue(pIn2); |
1887 | iB = sqlite3VdbeIntValue(pIn1); |
1888 | op = pOp->opcode; |
1889 | if( op==OP_BitAnd ){ |
1890 | iA &= iB; |
1891 | }else if( op==OP_BitOr ){ |
1892 | iA |= iB; |
1893 | }else if( iB!=0 ){ |
1894 | assert( op==OP_ShiftRight || op==OP_ShiftLeft ); |
1895 | |
1896 | /* If shifting by a negative amount, shift in the other direction */ |
1897 | if( iB<0 ){ |
1898 | assert( OP_ShiftRight==OP_ShiftLeft+1 ); |
1899 | op = 2*OP_ShiftLeft + 1 - op; |
1900 | iB = iB>(-64) ? -iB : 64; |
1901 | } |
1902 | |
1903 | if( iB>=64 ){ |
1904 | iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1; |
1905 | }else{ |
1906 | memcpy(&uA, &iA, sizeof(uA)); |
1907 | if( op==OP_ShiftLeft ){ |
1908 | uA <<= iB; |
1909 | }else{ |
1910 | uA >>= iB; |
1911 | /* Sign-extend on a right shift of a negative number */ |
1912 | if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB); |
1913 | } |
1914 | memcpy(&iA, &uA, sizeof(iA)); |
1915 | } |
1916 | } |
1917 | pOut->u.i = iA; |
1918 | MemSetTypeFlag(pOut, MEM_Int); |
1919 | break; |
1920 | } |
1921 | |
1922 | /* Opcode: AddImm P1 P2 * * * |
1923 | ** Synopsis: r[P1]=r[P1]+P2 |
1924 | ** |
1925 | ** Add the constant P2 to the value in register P1. |
1926 | ** The result is always an integer. |
1927 | ** |
1928 | ** To force any register to be an integer, just add 0. |
1929 | */ |
1930 | case OP_AddImm: { /* in1 */ |
1931 | pIn1 = &aMem[pOp->p1]; |
1932 | memAboutToChange(p, pIn1); |
1933 | sqlite3VdbeMemIntegerify(pIn1); |
1934 | pIn1->u.i += pOp->p2; |
1935 | break; |
1936 | } |
1937 | |
1938 | /* Opcode: MustBeInt P1 P2 * * * |
1939 | ** |
1940 | ** Force the value in register P1 to be an integer. If the value |
1941 | ** in P1 is not an integer and cannot be converted into an integer |
1942 | ** without data loss, then jump immediately to P2, or if P2==0 |
1943 | ** raise an SQLITE_MISMATCH exception. |
1944 | */ |
1945 | case OP_MustBeInt: { /* jump, in1 */ |
1946 | pIn1 = &aMem[pOp->p1]; |
1947 | if( (pIn1->flags & MEM_Int)==0 ){ |
1948 | applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding); |
1949 | if( (pIn1->flags & MEM_Int)==0 ){ |
1950 | VdbeBranchTaken(1, 2); |
1951 | if( pOp->p2==0 ){ |
1952 | rc = SQLITE_MISMATCH; |
1953 | goto abort_due_to_error; |
1954 | }else{ |
1955 | goto jump_to_p2; |
1956 | } |
1957 | } |
1958 | } |
1959 | VdbeBranchTaken(0, 2); |
1960 | MemSetTypeFlag(pIn1, MEM_Int); |
1961 | break; |
1962 | } |
1963 | |
1964 | #ifndef SQLITE_OMIT_FLOATING_POINT |
1965 | /* Opcode: RealAffinity P1 * * * * |
1966 | ** |
1967 | ** If register P1 holds an integer convert it to a real value. |
1968 | ** |
1969 | ** This opcode is used when extracting information from a column that |
1970 | ** has REAL affinity. Such column values may still be stored as |
1971 | ** integers, for space efficiency, but after extraction we want them |
1972 | ** to have only a real value. |
1973 | */ |
1974 | case OP_RealAffinity: { /* in1 */ |
1975 | pIn1 = &aMem[pOp->p1]; |
1976 | if( pIn1->flags & (MEM_Int|MEM_IntReal) ){ |
1977 | testcase( pIn1->flags & MEM_Int ); |
1978 | testcase( pIn1->flags & MEM_IntReal ); |
1979 | sqlite3VdbeMemRealify(pIn1); |
1980 | REGISTER_TRACE(pOp->p1, pIn1); |
1981 | } |
1982 | break; |
1983 | } |
1984 | #endif |
1985 | |
1986 | #ifndef SQLITE_OMIT_CAST |
1987 | /* Opcode: Cast P1 P2 * * * |
1988 | ** Synopsis: affinity(r[P1]) |
1989 | ** |
1990 | ** Force the value in register P1 to be the type defined by P2. |
1991 | ** |
1992 | ** <ul> |
1993 | ** <li> P2=='A' → BLOB |
1994 | ** <li> P2=='B' → TEXT |
1995 | ** <li> P2=='C' → NUMERIC |
1996 | ** <li> P2=='D' → INTEGER |
1997 | ** <li> P2=='E' → REAL |
1998 | ** </ul> |
1999 | ** |
2000 | ** A NULL value is not changed by this routine. It remains NULL. |
2001 | */ |
2002 | case OP_Cast: { /* in1 */ |
2003 | assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL ); |
2004 | testcase( pOp->p2==SQLITE_AFF_TEXT ); |
2005 | testcase( pOp->p2==SQLITE_AFF_BLOB ); |
2006 | testcase( pOp->p2==SQLITE_AFF_NUMERIC ); |
2007 | testcase( pOp->p2==SQLITE_AFF_INTEGER ); |
2008 | testcase( pOp->p2==SQLITE_AFF_REAL ); |
2009 | pIn1 = &aMem[pOp->p1]; |
2010 | memAboutToChange(p, pIn1); |
2011 | rc = ExpandBlob(pIn1); |
2012 | if( rc ) goto abort_due_to_error; |
2013 | rc = sqlite3VdbeMemCast(pIn1, pOp->p2, encoding); |
2014 | if( rc ) goto abort_due_to_error; |
2015 | UPDATE_MAX_BLOBSIZE(pIn1); |
2016 | REGISTER_TRACE(pOp->p1, pIn1); |
2017 | break; |
2018 | } |
2019 | #endif /* SQLITE_OMIT_CAST */ |
2020 | |
2021 | /* Opcode: Eq P1 P2 P3 P4 P5 |
2022 | ** Synopsis: IF r[P3]==r[P1] |
2023 | ** |
2024 | ** Compare the values in register P1 and P3. If reg(P3)==reg(P1) then |
2025 | ** jump to address P2. |
2026 | ** |
2027 | ** The SQLITE_AFF_MASK portion of P5 must be an affinity character - |
2028 | ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made |
2029 | ** to coerce both inputs according to this affinity before the |
2030 | ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric |
2031 | ** affinity is used. Note that the affinity conversions are stored |
2032 | ** back into the input registers P1 and P3. So this opcode can cause |
2033 | ** persistent changes to registers P1 and P3. |
2034 | ** |
2035 | ** Once any conversions have taken place, and neither value is NULL, |
2036 | ** the values are compared. If both values are blobs then memcmp() is |
2037 | ** used to determine the results of the comparison. If both values |
2038 | ** are text, then the appropriate collating function specified in |
2039 | ** P4 is used to do the comparison. If P4 is not specified then |
2040 | ** memcmp() is used to compare text string. If both values are |
2041 | ** numeric, then a numeric comparison is used. If the two values |
2042 | ** are of different types, then numbers are considered less than |
2043 | ** strings and strings are considered less than blobs. |
2044 | ** |
2045 | ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either |
2046 | ** true or false and is never NULL. If both operands are NULL then the result |
2047 | ** of comparison is true. If either operand is NULL then the result is false. |
2048 | ** If neither operand is NULL the result is the same as it would be if |
2049 | ** the SQLITE_NULLEQ flag were omitted from P5. |
2050 | ** |
2051 | ** This opcode saves the result of comparison for use by the new |
2052 | ** OP_Jump opcode. |
2053 | */ |
2054 | /* Opcode: Ne P1 P2 P3 P4 P5 |
2055 | ** Synopsis: IF r[P3]!=r[P1] |
2056 | ** |
2057 | ** This works just like the Eq opcode except that the jump is taken if |
2058 | ** the operands in registers P1 and P3 are not equal. See the Eq opcode for |
2059 | ** additional information. |
2060 | */ |
2061 | /* Opcode: Lt P1 P2 P3 P4 P5 |
2062 | ** Synopsis: IF r[P3]<r[P1] |
2063 | ** |
2064 | ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then |
2065 | ** jump to address P2. |
2066 | ** |
2067 | ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or |
2068 | ** reg(P3) is NULL then the take the jump. If the SQLITE_JUMPIFNULL |
2069 | ** bit is clear then fall through if either operand is NULL. |
2070 | ** |
2071 | ** The SQLITE_AFF_MASK portion of P5 must be an affinity character - |
2072 | ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made |
2073 | ** to coerce both inputs according to this affinity before the |
2074 | ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric |
2075 | ** affinity is used. Note that the affinity conversions are stored |
2076 | ** back into the input registers P1 and P3. So this opcode can cause |
2077 | ** persistent changes to registers P1 and P3. |
2078 | ** |
2079 | ** Once any conversions have taken place, and neither value is NULL, |
2080 | ** the values are compared. If both values are blobs then memcmp() is |
2081 | ** used to determine the results of the comparison. If both values |
2082 | ** are text, then the appropriate collating function specified in |
2083 | ** P4 is used to do the comparison. If P4 is not specified then |
2084 | ** memcmp() is used to compare text string. If both values are |
2085 | ** numeric, then a numeric comparison is used. If the two values |
2086 | ** are of different types, then numbers are considered less than |
2087 | ** strings and strings are considered less than blobs. |
2088 | ** |
2089 | ** This opcode saves the result of comparison for use by the new |
2090 | ** OP_Jump opcode. |
2091 | */ |
2092 | /* Opcode: Le P1 P2 P3 P4 P5 |
2093 | ** Synopsis: IF r[P3]<=r[P1] |
2094 | ** |
2095 | ** This works just like the Lt opcode except that the jump is taken if |
2096 | ** the content of register P3 is less than or equal to the content of |
2097 | ** register P1. See the Lt opcode for additional information. |
2098 | */ |
2099 | /* Opcode: Gt P1 P2 P3 P4 P5 |
2100 | ** Synopsis: IF r[P3]>r[P1] |
2101 | ** |
2102 | ** This works just like the Lt opcode except that the jump is taken if |
2103 | ** the content of register P3 is greater than the content of |
2104 | ** register P1. See the Lt opcode for additional information. |
2105 | */ |
2106 | /* Opcode: Ge P1 P2 P3 P4 P5 |
2107 | ** Synopsis: IF r[P3]>=r[P1] |
2108 | ** |
2109 | ** This works just like the Lt opcode except that the jump is taken if |
2110 | ** the content of register P3 is greater than or equal to the content of |
2111 | ** register P1. See the Lt opcode for additional information. |
2112 | */ |
2113 | case OP_Eq: /* same as TK_EQ, jump, in1, in3 */ |
2114 | case OP_Ne: /* same as TK_NE, jump, in1, in3 */ |
2115 | case OP_Lt: /* same as TK_LT, jump, in1, in3 */ |
2116 | case OP_Le: /* same as TK_LE, jump, in1, in3 */ |
2117 | case OP_Gt: /* same as TK_GT, jump, in1, in3 */ |
2118 | case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ |
2119 | int res, res2; /* Result of the comparison of pIn1 against pIn3 */ |
2120 | char affinity; /* Affinity to use for comparison */ |
2121 | u16 flags1; /* Copy of initial value of pIn1->flags */ |
2122 | u16 flags3; /* Copy of initial value of pIn3->flags */ |
2123 | |
2124 | pIn1 = &aMem[pOp->p1]; |
2125 | pIn3 = &aMem[pOp->p3]; |
2126 | flags1 = pIn1->flags; |
2127 | flags3 = pIn3->flags; |
2128 | if( (flags1 & flags3 & MEM_Int)!=0 ){ |
2129 | assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT || CORRUPT_DB ); |
2130 | /* Common case of comparison of two integers */ |
2131 | if( pIn3->u.i > pIn1->u.i ){ |
2132 | if( sqlite3aGTb[pOp->opcode] ){ |
2133 | VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3); |
2134 | goto jump_to_p2; |
2135 | } |
2136 | iCompare = +1; |
2137 | }else if( pIn3->u.i < pIn1->u.i ){ |
2138 | if( sqlite3aLTb[pOp->opcode] ){ |
2139 | VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3); |
2140 | goto jump_to_p2; |
2141 | } |
2142 | iCompare = -1; |
2143 | }else{ |
2144 | if( sqlite3aEQb[pOp->opcode] ){ |
2145 | VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3); |
2146 | goto jump_to_p2; |
2147 | } |
2148 | iCompare = 0; |
2149 | } |
2150 | VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3); |
2151 | break; |
2152 | } |
2153 | if( (flags1 | flags3)&MEM_Null ){ |
2154 | /* One or both operands are NULL */ |
2155 | if( pOp->p5 & SQLITE_NULLEQ ){ |
2156 | /* If SQLITE_NULLEQ is set (which will only happen if the operator is |
2157 | ** OP_Eq or OP_Ne) then take the jump or not depending on whether |
2158 | ** or not both operands are null. |
2159 | */ |
2160 | assert( (flags1 & MEM_Cleared)==0 ); |
2161 | assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB ); |
2162 | testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 ); |
2163 | if( (flags1&flags3&MEM_Null)!=0 |
2164 | && (flags3&MEM_Cleared)==0 |
2165 | ){ |
2166 | res = 0; /* Operands are equal */ |
2167 | }else{ |
2168 | res = ((flags3 & MEM_Null) ? -1 : +1); /* Operands are not equal */ |
2169 | } |
2170 | }else{ |
2171 | /* SQLITE_NULLEQ is clear and at least one operand is NULL, |
2172 | ** then the result is always NULL. |
2173 | ** The jump is taken if the SQLITE_JUMPIFNULL bit is set. |
2174 | */ |
2175 | VdbeBranchTaken(2,3); |
2176 | if( pOp->p5 & SQLITE_JUMPIFNULL ){ |
2177 | goto jump_to_p2; |
2178 | } |
2179 | iCompare = 1; /* Operands are not equal */ |
2180 | break; |
2181 | } |
2182 | }else{ |
2183 | /* Neither operand is NULL and we couldn't do the special high-speed |
2184 | ** integer comparison case. So do a general-case comparison. */ |
2185 | affinity = pOp->p5 & SQLITE_AFF_MASK; |
2186 | if( affinity>=SQLITE_AFF_NUMERIC ){ |
2187 | if( (flags1 | flags3)&MEM_Str ){ |
2188 | if( (flags1 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){ |
2189 | applyNumericAffinity(pIn1,0); |
2190 | testcase( flags3==pIn3->flags ); |
2191 | flags3 = pIn3->flags; |
2192 | } |
2193 | if( (flags3 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){ |
2194 | applyNumericAffinity(pIn3,0); |
2195 | } |
2196 | } |
2197 | }else if( affinity==SQLITE_AFF_TEXT ){ |
2198 | if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){ |
2199 | testcase( pIn1->flags & MEM_Int ); |
2200 | testcase( pIn1->flags & MEM_Real ); |
2201 | testcase( pIn1->flags & MEM_IntReal ); |
2202 | sqlite3VdbeMemStringify(pIn1, encoding, 1); |
2203 | testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) ); |
2204 | flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask); |
2205 | if( pIn1==pIn3 ) flags3 = flags1 | MEM_Str; |
2206 | } |
2207 | if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){ |
2208 | testcase( pIn3->flags & MEM_Int ); |
2209 | testcase( pIn3->flags & MEM_Real ); |
2210 | testcase( pIn3->flags & MEM_IntReal ); |
2211 | sqlite3VdbeMemStringify(pIn3, encoding, 1); |
2212 | testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) ); |
2213 | flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask); |
2214 | } |
2215 | } |
2216 | assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 ); |
2217 | res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl); |
2218 | } |
2219 | |
2220 | /* At this point, res is negative, zero, or positive if reg[P1] is |
2221 | ** less than, equal to, or greater than reg[P3], respectively. Compute |
2222 | ** the answer to this operator in res2, depending on what the comparison |
2223 | ** operator actually is. The next block of code depends on the fact |
2224 | ** that the 6 comparison operators are consecutive integers in this |
2225 | ** order: NE, EQ, GT, LE, LT, GE */ |
2226 | assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 ); |
2227 | assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 ); |
2228 | if( res<0 ){ |
2229 | res2 = sqlite3aLTb[pOp->opcode]; |
2230 | }else if( res==0 ){ |
2231 | res2 = sqlite3aEQb[pOp->opcode]; |
2232 | }else{ |
2233 | res2 = sqlite3aGTb[pOp->opcode]; |
2234 | } |
2235 | iCompare = res; |
2236 | |
2237 | /* Undo any changes made by applyAffinity() to the input registers. */ |
2238 | assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) ); |
2239 | pIn3->flags = flags3; |
2240 | assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); |
2241 | pIn1->flags = flags1; |
2242 | |
2243 | VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3); |
2244 | if( res2 ){ |
2245 | goto jump_to_p2; |
2246 | } |
2247 | break; |
2248 | } |
2249 | |
2250 | /* Opcode: ElseEq * P2 * * * |
2251 | ** |
2252 | ** This opcode must follow an OP_Lt or OP_Gt comparison operator. There |
2253 | ** can be zero or more OP_ReleaseReg opcodes intervening, but no other |
2254 | ** opcodes are allowed to occur between this instruction and the previous |
2255 | ** OP_Lt or OP_Gt. |
2256 | ** |
2257 | ** If result of an OP_Eq comparison on the same two operands as the |
2258 | ** prior OP_Lt or OP_Gt would have been true, then jump to P2. |
2259 | ** If the result of an OP_Eq comparison on the two previous |
2260 | ** operands would have been false or NULL, then fall through. |
2261 | */ |
2262 | case OP_ElseEq: { /* same as TK_ESCAPE, jump */ |
2263 | |
2264 | #ifdef SQLITE_DEBUG |
2265 | /* Verify the preconditions of this opcode - that it follows an OP_Lt or |
2266 | ** OP_Gt with zero or more intervening OP_ReleaseReg opcodes */ |
2267 | int iAddr; |
2268 | for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){ |
2269 | if( aOp[iAddr].opcode==OP_ReleaseReg ) continue; |
2270 | assert( aOp[iAddr].opcode==OP_Lt || aOp[iAddr].opcode==OP_Gt ); |
2271 | break; |
2272 | } |
2273 | #endif /* SQLITE_DEBUG */ |
2274 | VdbeBranchTaken(iCompare==0, 2); |
2275 | if( iCompare==0 ) goto jump_to_p2; |
2276 | break; |
2277 | } |
2278 | |
2279 | |
2280 | /* Opcode: Permutation * * * P4 * |
2281 | ** |
2282 | ** Set the permutation used by the OP_Compare operator in the next |
2283 | ** instruction. The permutation is stored in the P4 operand. |
2284 | ** |
2285 | ** The permutation is only valid for the next opcode which must be |
2286 | ** an OP_Compare that has the OPFLAG_PERMUTE bit set in P5. |
2287 | ** |
2288 | ** The first integer in the P4 integer array is the length of the array |
2289 | ** and does not become part of the permutation. |
2290 | */ |
2291 | case OP_Permutation: { |
2292 | assert( pOp->p4type==P4_INTARRAY ); |
2293 | assert( pOp->p4.ai ); |
2294 | assert( pOp[1].opcode==OP_Compare ); |
2295 | assert( pOp[1].p5 & OPFLAG_PERMUTE ); |
2296 | break; |
2297 | } |
2298 | |
2299 | /* Opcode: Compare P1 P2 P3 P4 P5 |
2300 | ** Synopsis: r[P1@P3] <-> r[P2@P3] |
2301 | ** |
2302 | ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this |
2303 | ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of |
2304 | ** the comparison for use by the next OP_Jump instruct. |
2305 | ** |
2306 | ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is |
2307 | ** determined by the most recent OP_Permutation operator. If the |
2308 | ** OPFLAG_PERMUTE bit is clear, then register are compared in sequential |
2309 | ** order. |
2310 | ** |
2311 | ** P4 is a KeyInfo structure that defines collating sequences and sort |
2312 | ** orders for the comparison. The permutation applies to registers |
2313 | ** only. The KeyInfo elements are used sequentially. |
2314 | ** |
2315 | ** The comparison is a sort comparison, so NULLs compare equal, |
2316 | ** NULLs are less than numbers, numbers are less than strings, |
2317 | ** and strings are less than blobs. |
2318 | ** |
2319 | ** This opcode must be immediately followed by an OP_Jump opcode. |
2320 | */ |
2321 | case OP_Compare: { |
2322 | int n; |
2323 | int i; |
2324 | int p1; |
2325 | int p2; |
2326 | const KeyInfo *pKeyInfo; |
2327 | u32 idx; |
2328 | CollSeq *pColl; /* Collating sequence to use on this term */ |
2329 | int bRev; /* True for DESCENDING sort order */ |
2330 | u32 *aPermute; /* The permutation */ |
2331 | |
2332 | if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){ |
2333 | aPermute = 0; |
2334 | }else{ |
2335 | assert( pOp>aOp ); |
2336 | assert( pOp[-1].opcode==OP_Permutation ); |
2337 | assert( pOp[-1].p4type==P4_INTARRAY ); |
2338 | aPermute = pOp[-1].p4.ai + 1; |
2339 | assert( aPermute!=0 ); |
2340 | } |
2341 | n = pOp->p3; |
2342 | pKeyInfo = pOp->p4.pKeyInfo; |
2343 | assert( n>0 ); |
2344 | assert( pKeyInfo!=0 ); |
2345 | p1 = pOp->p1; |
2346 | p2 = pOp->p2; |
2347 | #ifdef SQLITE_DEBUG |
2348 | if( aPermute ){ |
2349 | int k, mx = 0; |
2350 | for(k=0; k<n; k++) if( aPermute[k]>(u32)mx ) mx = aPermute[k]; |
2351 | assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 ); |
2352 | assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 ); |
2353 | }else{ |
2354 | assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 ); |
2355 | assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 ); |
2356 | } |
2357 | #endif /* SQLITE_DEBUG */ |
2358 | for(i=0; i<n; i++){ |
2359 | idx = aPermute ? aPermute[i] : (u32)i; |
2360 | assert( memIsValid(&aMem[p1+idx]) ); |
2361 | assert( memIsValid(&aMem[p2+idx]) ); |
2362 | REGISTER_TRACE(p1+idx, &aMem[p1+idx]); |
2363 | REGISTER_TRACE(p2+idx, &aMem[p2+idx]); |
2364 | assert( i<pKeyInfo->nKeyField ); |
2365 | pColl = pKeyInfo->aColl[i]; |
2366 | bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC); |
2367 | iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl); |
2368 | if( iCompare ){ |
2369 | if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) |
2370 | && ((aMem[p1+idx].flags & MEM_Null) || (aMem[p2+idx].flags & MEM_Null)) |
2371 | ){ |
2372 | iCompare = -iCompare; |
2373 | } |
2374 | if( bRev ) iCompare = -iCompare; |
2375 | break; |
2376 | } |
2377 | } |
2378 | assert( pOp[1].opcode==OP_Jump ); |
2379 | break; |
2380 | } |
2381 | |
2382 | /* Opcode: Jump P1 P2 P3 * * |
2383 | ** |
2384 | ** Jump to the instruction at address P1, P2, or P3 depending on whether |
2385 | ** in the most recent OP_Compare instruction the P1 vector was less than |
2386 | ** equal to, or greater than the P2 vector, respectively. |
2387 | ** |
2388 | ** This opcode must immediately follow an OP_Compare opcode. |
2389 | */ |
2390 | case OP_Jump: { /* jump */ |
2391 | assert( pOp>aOp && pOp[-1].opcode==OP_Compare ); |
2392 | if( iCompare<0 ){ |
2393 | VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1]; |
2394 | }else if( iCompare==0 ){ |
2395 | VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1]; |
2396 | }else{ |
2397 | VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1]; |
2398 | } |
2399 | break; |
2400 | } |
2401 | |
2402 | /* Opcode: And P1 P2 P3 * * |
2403 | ** Synopsis: r[P3]=(r[P1] && r[P2]) |
2404 | ** |
2405 | ** Take the logical AND of the values in registers P1 and P2 and |
2406 | ** write the result into register P3. |
2407 | ** |
2408 | ** If either P1 or P2 is 0 (false) then the result is 0 even if |
2409 | ** the other input is NULL. A NULL and true or two NULLs give |
2410 | ** a NULL output. |
2411 | */ |
2412 | /* Opcode: Or P1 P2 P3 * * |
2413 | ** Synopsis: r[P3]=(r[P1] || r[P2]) |
2414 | ** |
2415 | ** Take the logical OR of the values in register P1 and P2 and |
2416 | ** store the answer in register P3. |
2417 | ** |
2418 | ** If either P1 or P2 is nonzero (true) then the result is 1 (true) |
2419 | ** even if the other input is NULL. A NULL and false or two NULLs |
2420 | ** give a NULL output. |
2421 | */ |
2422 | case OP_And: /* same as TK_AND, in1, in2, out3 */ |
2423 | case OP_Or: { /* same as TK_OR, in1, in2, out3 */ |
2424 | int v1; /* Left operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ |
2425 | int v2; /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ |
2426 | |
2427 | v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2); |
2428 | v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2); |
2429 | if( pOp->opcode==OP_And ){ |
2430 | static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 }; |
2431 | v1 = and_logic[v1*3+v2]; |
2432 | }else{ |
2433 | static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 }; |
2434 | v1 = or_logic[v1*3+v2]; |
2435 | } |
2436 | pOut = &aMem[pOp->p3]; |
2437 | if( v1==2 ){ |
2438 | MemSetTypeFlag(pOut, MEM_Null); |
2439 | }else{ |
2440 | pOut->u.i = v1; |
2441 | MemSetTypeFlag(pOut, MEM_Int); |
2442 | } |
2443 | break; |
2444 | } |
2445 | |
2446 | /* Opcode: IsTrue P1 P2 P3 P4 * |
2447 | ** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 |
2448 | ** |
2449 | ** This opcode implements the IS TRUE, IS FALSE, IS NOT TRUE, and |
2450 | ** IS NOT FALSE operators. |
2451 | ** |
2452 | ** Interpret the value in register P1 as a boolean value. Store that |
2453 | ** boolean (a 0 or 1) in register P2. Or if the value in register P1 is |
2454 | ** NULL, then the P3 is stored in register P2. Invert the answer if P4 |
2455 | ** is 1. |
2456 | ** |
2457 | ** The logic is summarized like this: |
2458 | ** |
2459 | ** <ul> |
2460 | ** <li> If P3==0 and P4==0 then r[P2] := r[P1] IS TRUE |
2461 | ** <li> If P3==1 and P4==1 then r[P2] := r[P1] IS FALSE |
2462 | ** <li> If P3==0 and P4==1 then r[P2] := r[P1] IS NOT TRUE |
2463 | ** <li> If P3==1 and P4==0 then r[P2] := r[P1] IS NOT FALSE |
2464 | ** </ul> |
2465 | */ |
2466 | case OP_IsTrue: { /* in1, out2 */ |
2467 | assert( pOp->p4type==P4_INT32 ); |
2468 | assert( pOp->p4.i==0 || pOp->p4.i==1 ); |
2469 | assert( pOp->p3==0 || pOp->p3==1 ); |
2470 | sqlite3VdbeMemSetInt64(&aMem[pOp->p2], |
2471 | sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i); |
2472 | break; |
2473 | } |
2474 | |
2475 | /* Opcode: Not P1 P2 * * * |
2476 | ** Synopsis: r[P2]= !r[P1] |
2477 | ** |
2478 | ** Interpret the value in register P1 as a boolean value. Store the |
2479 | ** boolean complement in register P2. If the value in register P1 is |
2480 | ** NULL, then a NULL is stored in P2. |
2481 | */ |
2482 | case OP_Not: { /* same as TK_NOT, in1, out2 */ |
2483 | pIn1 = &aMem[pOp->p1]; |
2484 | pOut = &aMem[pOp->p2]; |
2485 | if( (pIn1->flags & MEM_Null)==0 ){ |
2486 | sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0)); |
2487 | }else{ |
2488 | sqlite3VdbeMemSetNull(pOut); |
2489 | } |
2490 | break; |
2491 | } |
2492 | |
2493 | /* Opcode: BitNot P1 P2 * * * |
2494 | ** Synopsis: r[P2]= ~r[P1] |
2495 | ** |
2496 | ** Interpret the content of register P1 as an integer. Store the |
2497 | ** ones-complement of the P1 value into register P2. If P1 holds |
2498 | ** a NULL then store a NULL in P2. |
2499 | */ |
2500 | case OP_BitNot: { /* same as TK_BITNOT, in1, out2 */ |
2501 | pIn1 = &aMem[pOp->p1]; |
2502 | pOut = &aMem[pOp->p2]; |
2503 | sqlite3VdbeMemSetNull(pOut); |
2504 | if( (pIn1->flags & MEM_Null)==0 ){ |
2505 | pOut->flags = MEM_Int; |
2506 | pOut->u.i = ~sqlite3VdbeIntValue(pIn1); |
2507 | } |
2508 | break; |
2509 | } |
2510 | |
2511 | /* Opcode: Once P1 P2 * * * |
2512 | ** |
2513 | ** Fall through to the next instruction the first time this opcode is |
2514 | ** encountered on each invocation of the byte-code program. Jump to P2 |
2515 | ** on the second and all subsequent encounters during the same invocation. |
2516 | ** |
2517 | ** Top-level programs determine first invocation by comparing the P1 |
2518 | ** operand against the P1 operand on the OP_Init opcode at the beginning |
2519 | ** of the program. If the P1 values differ, then fall through and make |
2520 | ** the P1 of this opcode equal to the P1 of OP_Init. If P1 values are |
2521 | ** the same then take the jump. |
2522 | ** |
2523 | ** For subprograms, there is a bitmask in the VdbeFrame that determines |
2524 | ** whether or not the jump should be taken. The bitmask is necessary |
2525 | ** because the self-altering code trick does not work for recursive |
2526 | ** triggers. |
2527 | */ |
2528 | case OP_Once: { /* jump */ |
2529 | u32 iAddr; /* Address of this instruction */ |
2530 | assert( p->aOp[0].opcode==OP_Init ); |
2531 | if( p->pFrame ){ |
2532 | iAddr = (int)(pOp - p->aOp); |
2533 | if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){ |
2534 | VdbeBranchTaken(1, 2); |
2535 | goto jump_to_p2; |
2536 | } |
2537 | p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7); |
2538 | }else{ |
2539 | if( p->aOp[0].p1==pOp->p1 ){ |
2540 | VdbeBranchTaken(1, 2); |
2541 | goto jump_to_p2; |
2542 | } |
2543 | } |
2544 | VdbeBranchTaken(0, 2); |
2545 | pOp->p1 = p->aOp[0].p1; |
2546 | break; |
2547 | } |
2548 | |
2549 | /* Opcode: If P1 P2 P3 * * |
2550 | ** |
2551 | ** Jump to P2 if the value in register P1 is true. The value |
2552 | ** is considered true if it is numeric and non-zero. If the value |
2553 | ** in P1 is NULL then take the jump if and only if P3 is non-zero. |
2554 | */ |
2555 | case OP_If: { /* jump, in1 */ |
2556 | int c; |
2557 | c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3); |
2558 | VdbeBranchTaken(c!=0, 2); |
2559 | if( c ) goto jump_to_p2; |
2560 | break; |
2561 | } |
2562 | |
2563 | /* Opcode: IfNot P1 P2 P3 * * |
2564 | ** |
2565 | ** Jump to P2 if the value in register P1 is False. The value |
2566 | ** is considered false if it has a numeric value of zero. If the value |
2567 | ** in P1 is NULL then take the jump if and only if P3 is non-zero. |
2568 | */ |
2569 | case OP_IfNot: { /* jump, in1 */ |
2570 | int c; |
2571 | c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3); |
2572 | VdbeBranchTaken(c!=0, 2); |
2573 | if( c ) goto jump_to_p2; |
2574 | break; |
2575 | } |
2576 | |
2577 | /* Opcode: IsNull P1 P2 * * * |
2578 | ** Synopsis: if r[P1]==NULL goto P2 |
2579 | ** |
2580 | ** Jump to P2 if the value in register P1 is NULL. |
2581 | */ |
2582 | case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */ |
2583 | pIn1 = &aMem[pOp->p1]; |
2584 | VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2); |
2585 | if( (pIn1->flags & MEM_Null)!=0 ){ |
2586 | goto jump_to_p2; |
2587 | } |
2588 | break; |
2589 | } |
2590 | |
2591 | /* Opcode: IsType P1 P2 P3 P4 P5 |
2592 | ** Synopsis: if typeof(P1.P3) in P5 goto P2 |
2593 | ** |
2594 | ** Jump to P2 if the type of a column in a btree is one of the types specified |
2595 | ** by the P5 bitmask. |
2596 | ** |
2597 | ** P1 is normally a cursor on a btree for which the row decode cache is |
2598 | ** valid through at least column P3. In other words, there should have been |
2599 | ** a prior OP_Column for column P3 or greater. If the cursor is not valid, |
2600 | ** then this opcode might give spurious results. |
2601 | ** The the btree row has fewer than P3 columns, then use P4 as the |
2602 | ** datatype. |
2603 | ** |
2604 | ** If P1 is -1, then P3 is a register number and the datatype is taken |
2605 | ** from the value in that register. |
2606 | ** |
2607 | ** P5 is a bitmask of data types. SQLITE_INTEGER is the least significant |
2608 | ** (0x01) bit. SQLITE_FLOAT is the 0x02 bit. SQLITE_TEXT is 0x04. |
2609 | ** SQLITE_BLOB is 0x08. SQLITE_NULL is 0x10. |
2610 | ** |
2611 | ** Take the jump to address P2 if and only if the datatype of the |
2612 | ** value determined by P1 and P3 corresponds to one of the bits in the |
2613 | ** P5 bitmask. |
2614 | ** |
2615 | */ |
2616 | case OP_IsType: { /* jump */ |
2617 | VdbeCursor *pC; |
2618 | u16 typeMask; |
2619 | u32 serialType; |
2620 | |
2621 | assert( pOp->p1>=(-1) && pOp->p1<p->nCursor ); |
2622 | assert( pOp->p1>=0 || (pOp->p3>=0 && pOp->p3<=(p->nMem+1 - p->nCursor)) ); |
2623 | if( pOp->p1>=0 ){ |
2624 | pC = p->apCsr[pOp->p1]; |
2625 | assert( pC!=0 ); |
2626 | assert( pOp->p3>=0 ); |
2627 | if( pOp->p3<pC->nHdrParsed ){ |
2628 | serialType = pC->aType[pOp->p3]; |
2629 | if( serialType>=12 ){ |
2630 | if( serialType&1 ){ |
2631 | typeMask = 0x04; /* SQLITE_TEXT */ |
2632 | }else{ |
2633 | typeMask = 0x08; /* SQLITE_BLOB */ |
2634 | } |
2635 | }else{ |
2636 | static const unsigned char aMask[] = { |
2637 | 0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2, |
2638 | 0x01, 0x01, 0x10, 0x10 |
2639 | }; |
2640 | testcase( serialType==0 ); |
2641 | testcase( serialType==1 ); |
2642 | testcase( serialType==2 ); |
2643 | testcase( serialType==3 ); |
2644 | testcase( serialType==4 ); |
2645 | testcase( serialType==5 ); |
2646 | testcase( serialType==6 ); |
2647 | testcase( serialType==7 ); |
2648 | testcase( serialType==8 ); |
2649 | testcase( serialType==9 ); |
2650 | testcase( serialType==10 ); |
2651 | testcase( serialType==11 ); |
2652 | typeMask = aMask[serialType]; |
2653 | } |
2654 | }else{ |
2655 | typeMask = 1 << (pOp->p4.i - 1); |
2656 | testcase( typeMask==0x01 ); |
2657 | testcase( typeMask==0x02 ); |
2658 | testcase( typeMask==0x04 ); |
2659 | testcase( typeMask==0x08 ); |
2660 | testcase( typeMask==0x10 ); |
2661 | } |
2662 | }else{ |
2663 | assert( memIsValid(&aMem[pOp->p3]) ); |
2664 | typeMask = 1 << (sqlite3_value_type((sqlite3_value*)&aMem[pOp->p3])-1); |
2665 | testcase( typeMask==0x01 ); |
2666 | testcase( typeMask==0x02 ); |
2667 | testcase( typeMask==0x04 ); |
2668 | testcase( typeMask==0x08 ); |
2669 | testcase( typeMask==0x10 ); |
2670 | } |
2671 | VdbeBranchTaken( (typeMask & pOp->p5)!=0, 2); |
2672 | if( typeMask & pOp->p5 ){ |
2673 | goto jump_to_p2; |
2674 | } |
2675 | break; |
2676 | } |
2677 | |
2678 | /* Opcode: ZeroOrNull P1 P2 P3 * * |
2679 | ** Synopsis: r[P2] = 0 OR NULL |
2680 | ** |
2681 | ** If all both registers P1 and P3 are NOT NULL, then store a zero in |
2682 | ** register P2. If either registers P1 or P3 are NULL then put |
2683 | ** a NULL in register P2. |
2684 | */ |
2685 | case OP_ZeroOrNull: { /* in1, in2, out2, in3 */ |
2686 | if( (aMem[pOp->p1].flags & MEM_Null)!=0 |
2687 | || (aMem[pOp->p3].flags & MEM_Null)!=0 |
2688 | ){ |
2689 | sqlite3VdbeMemSetNull(aMem + pOp->p2); |
2690 | }else{ |
2691 | sqlite3VdbeMemSetInt64(aMem + pOp->p2, 0); |
2692 | } |
2693 | break; |
2694 | } |
2695 | |
2696 | /* Opcode: NotNull P1 P2 * * * |
2697 | ** Synopsis: if r[P1]!=NULL goto P2 |
2698 | ** |
2699 | ** Jump to P2 if the value in register P1 is not NULL. |
2700 | */ |
2701 | case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */ |
2702 | pIn1 = &aMem[pOp->p1]; |
2703 | VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2); |
2704 | if( (pIn1->flags & MEM_Null)==0 ){ |
2705 | goto jump_to_p2; |
2706 | } |
2707 | break; |
2708 | } |
2709 | |
2710 | /* Opcode: IfNullRow P1 P2 P3 * * |
2711 | ** Synopsis: if P1.nullRow then r[P3]=NULL, goto P2 |
2712 | ** |
2713 | ** Check the cursor P1 to see if it is currently pointing at a NULL row. |
2714 | ** If it is, then set register P3 to NULL and jump immediately to P2. |
2715 | ** If P1 is not on a NULL row, then fall through without making any |
2716 | ** changes. |
2717 | ** |
2718 | ** If P1 is not an open cursor, then this opcode is a no-op. |
2719 | */ |
2720 | case OP_IfNullRow: { /* jump */ |
2721 | VdbeCursor *pC; |
2722 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
2723 | pC = p->apCsr[pOp->p1]; |
2724 | if( ALWAYS(pC) && pC->nullRow ){ |
2725 | sqlite3VdbeMemSetNull(aMem + pOp->p3); |
2726 | goto jump_to_p2; |
2727 | } |
2728 | break; |
2729 | } |
2730 | |
2731 | #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC |
2732 | /* Opcode: Offset P1 P2 P3 * * |
2733 | ** Synopsis: r[P3] = sqlite_offset(P1) |
2734 | ** |
2735 | ** Store in register r[P3] the byte offset into the database file that is the |
2736 | ** start of the payload for the record at which that cursor P1 is currently |
2737 | ** pointing. |
2738 | ** |
2739 | ** P2 is the column number for the argument to the sqlite_offset() function. |
2740 | ** This opcode does not use P2 itself, but the P2 value is used by the |
2741 | ** code generator. The P1, P2, and P3 operands to this opcode are the |
2742 | ** same as for OP_Column. |
2743 | ** |
2744 | ** This opcode is only available if SQLite is compiled with the |
2745 | ** -DSQLITE_ENABLE_OFFSET_SQL_FUNC option. |
2746 | */ |
2747 | case OP_Offset: { /* out3 */ |
2748 | VdbeCursor *pC; /* The VDBE cursor */ |
2749 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
2750 | pC = p->apCsr[pOp->p1]; |
2751 | pOut = &p->aMem[pOp->p3]; |
2752 | if( pC==0 || pC->eCurType!=CURTYPE_BTREE ){ |
2753 | sqlite3VdbeMemSetNull(pOut); |
2754 | }else{ |
2755 | if( pC->deferredMoveto ){ |
2756 | rc = sqlite3VdbeFinishMoveto(pC); |
2757 | if( rc ) goto abort_due_to_error; |
2758 | } |
2759 | if( sqlite3BtreeEof(pC->uc.pCursor) ){ |
2760 | sqlite3VdbeMemSetNull(pOut); |
2761 | }else{ |
2762 | sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor)); |
2763 | } |
2764 | } |
2765 | break; |
2766 | } |
2767 | #endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */ |
2768 | |
2769 | /* Opcode: Column P1 P2 P3 P4 P5 |
2770 | ** Synopsis: r[P3]=PX cursor P1 column P2 |
2771 | ** |
2772 | ** Interpret the data that cursor P1 points to as a structure built using |
2773 | ** the MakeRecord instruction. (See the MakeRecord opcode for additional |
2774 | ** information about the format of the data.) Extract the P2-th column |
2775 | ** from this record. If there are less than (P2+1) |
2776 | ** values in the record, extract a NULL. |
2777 | ** |
2778 | ** The value extracted is stored in register P3. |
2779 | ** |
2780 | ** If the record contains fewer than P2 fields, then extract a NULL. Or, |
2781 | ** if the P4 argument is a P4_MEM use the value of the P4 argument as |
2782 | ** the result. |
2783 | ** |
2784 | ** If the OPFLAG_LENGTHARG bit is set in P5 then the result is guaranteed |
2785 | ** to only be used by the length() function or the equivalent. The content |
2786 | ** of large blobs is not loaded, thus saving CPU cycles. If the |
2787 | ** OPFLAG_TYPEOFARG bit is set then the result will only be used by the |
2788 | ** typeof() function or the IS NULL or IS NOT NULL operators or the |
2789 | ** equivalent. In this case, all content loading can be omitted. |
2790 | */ |
2791 | case OP_Column: { |
2792 | u32 p2; /* column number to retrieve */ |
2793 | VdbeCursor *pC; /* The VDBE cursor */ |
2794 | BtCursor *pCrsr; /* The B-Tree cursor corresponding to pC */ |
2795 | u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */ |
2796 | int len; /* The length of the serialized data for the column */ |
2797 | int i; /* Loop counter */ |
2798 | Mem *pDest; /* Where to write the extracted value */ |
2799 | Mem sMem; /* For storing the record being decoded */ |
2800 | const u8 *zData; /* Part of the record being decoded */ |
2801 | const u8 *zHdr; /* Next unparsed byte of the header */ |
2802 | const u8 *zEndHdr; /* Pointer to first byte after the header */ |
2803 | u64 offset64; /* 64-bit offset */ |
2804 | u32 t; /* A type code from the record header */ |
2805 | Mem *pReg; /* PseudoTable input register */ |
2806 | |
2807 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
2808 | assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
2809 | pC = p->apCsr[pOp->p1]; |
2810 | p2 = (u32)pOp->p2; |
2811 | |
2812 | op_column_restart: |
2813 | assert( pC!=0 ); |
2814 | assert( p2<(u32)pC->nField |
2815 | || (pC->eCurType==CURTYPE_PSEUDO && pC->seekResult==0) ); |
2816 | aOffset = pC->aOffset; |
2817 | assert( aOffset==pC->aType+pC->nField ); |
2818 | assert( pC->eCurType!=CURTYPE_VTAB ); |
2819 | assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow ); |
2820 | assert( pC->eCurType!=CURTYPE_SORTER ); |
2821 | |
2822 | if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/ |
2823 | if( pC->nullRow ){ |
2824 | if( pC->eCurType==CURTYPE_PSEUDO && pC->seekResult>0 ){ |
2825 | /* For the special case of as pseudo-cursor, the seekResult field |
2826 | ** identifies the register that holds the record */ |
2827 | pReg = &aMem[pC->seekResult]; |
2828 | assert( pReg->flags & MEM_Blob ); |
2829 | assert( memIsValid(pReg) ); |
2830 | pC->payloadSize = pC->szRow = pReg->n; |
2831 | pC->aRow = (u8*)pReg->z; |
2832 | }else{ |
2833 | pDest = &aMem[pOp->p3]; |
2834 | memAboutToChange(p, pDest); |
2835 | sqlite3VdbeMemSetNull(pDest); |
2836 | goto op_column_out; |
2837 | } |
2838 | }else{ |
2839 | pCrsr = pC->uc.pCursor; |
2840 | if( pC->deferredMoveto ){ |
2841 | u32 iMap; |
2842 | assert( !pC->isEphemeral ); |
2843 | if( pC->ub.aAltMap && (iMap = pC->ub.aAltMap[1+p2])>0 ){ |
2844 | pC = pC->pAltCursor; |
2845 | p2 = iMap - 1; |
2846 | goto op_column_restart; |
2847 | } |
2848 | rc = sqlite3VdbeFinishMoveto(pC); |
2849 | if( rc ) goto abort_due_to_error; |
2850 | }else if( sqlite3BtreeCursorHasMoved(pCrsr) ){ |
2851 | rc = sqlite3VdbeHandleMovedCursor(pC); |
2852 | if( rc ) goto abort_due_to_error; |
2853 | goto op_column_restart; |
2854 | } |
2855 | assert( pC->eCurType==CURTYPE_BTREE ); |
2856 | assert( pCrsr ); |
2857 | assert( sqlite3BtreeCursorIsValid(pCrsr) ); |
2858 | pC->payloadSize = sqlite3BtreePayloadSize(pCrsr); |
2859 | pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow); |
2860 | assert( pC->szRow<=pC->payloadSize ); |
2861 | assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */ |
2862 | } |
2863 | pC->cacheStatus = p->cacheCtr; |
2864 | if( (aOffset[0] = pC->aRow[0])<0x80 ){ |
2865 | pC->iHdrOffset = 1; |
2866 | }else{ |
2867 | pC->iHdrOffset = sqlite3GetVarint32(pC->aRow, aOffset); |
2868 | } |
2869 | pC->nHdrParsed = 0; |
2870 | |
2871 | if( pC->szRow<aOffset[0] ){ /*OPTIMIZATION-IF-FALSE*/ |
2872 | /* pC->aRow does not have to hold the entire row, but it does at least |
2873 | ** need to cover the header of the record. If pC->aRow does not contain |
2874 | ** the complete header, then set it to zero, forcing the header to be |
2875 | ** dynamically allocated. */ |
2876 | pC->aRow = 0; |
2877 | pC->szRow = 0; |
2878 | |
2879 | /* Make sure a corrupt database has not given us an oversize header. |
2880 | ** Do this now to avoid an oversize memory allocation. |
2881 | ** |
2882 | ** Type entries can be between 1 and 5 bytes each. But 4 and 5 byte |
2883 | ** types use so much data space that there can only be 4096 and 32 of |
2884 | ** them, respectively. So the maximum header length results from a |
2885 | ** 3-byte type for each of the maximum of 32768 columns plus three |
2886 | ** extra bytes for the header length itself. 32768*3 + 3 = 98307. |
2887 | */ |
2888 | if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){ |
2889 | goto op_column_corrupt; |
2890 | } |
2891 | }else{ |
2892 | /* This is an optimization. By skipping over the first few tests |
2893 | ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a |
2894 | ** measurable performance gain. |
2895 | ** |
2896 | ** This branch is taken even if aOffset[0]==0. Such a record is never |
2897 | ** generated by SQLite, and could be considered corruption, but we |
2898 | ** accept it for historical reasons. When aOffset[0]==0, the code this |
2899 | ** branch jumps to reads past the end of the record, but never more |
2900 | ** than a few bytes. Even if the record occurs at the end of the page |
2901 | ** content area, the "page header" comes after the page content and so |
2902 | ** this overread is harmless. Similar overreads can occur for a corrupt |
2903 | ** database file. |
2904 | */ |
2905 | zData = pC->aRow; |
2906 | assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */ |
2907 | testcase( aOffset[0]==0 ); |
2908 | goto op_column_read_header; |
2909 | } |
2910 | }else if( sqlite3BtreeCursorHasMoved(pC->uc.pCursor) ){ |
2911 | rc = sqlite3VdbeHandleMovedCursor(pC); |
2912 | if( rc ) goto abort_due_to_error; |
2913 | goto op_column_restart; |
2914 | } |
2915 | |
2916 | /* Make sure at least the first p2+1 entries of the header have been |
2917 | ** parsed and valid information is in aOffset[] and pC->aType[]. |
2918 | */ |
2919 | if( pC->nHdrParsed<=p2 ){ |
2920 | /* If there is more header available for parsing in the record, try |
2921 | ** to extract additional fields up through the p2+1-th field |
2922 | */ |
2923 | if( pC->iHdrOffset<aOffset[0] ){ |
2924 | /* Make sure zData points to enough of the record to cover the header. */ |
2925 | if( pC->aRow==0 ){ |
2926 | memset(&sMem, 0, sizeof(sMem)); |
2927 | rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem); |
2928 | if( rc!=SQLITE_OK ) goto abort_due_to_error; |
2929 | zData = (u8*)sMem.z; |
2930 | }else{ |
2931 | zData = pC->aRow; |
2932 | } |
2933 | |
2934 | /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */ |
2935 | op_column_read_header: |
2936 | i = pC->nHdrParsed; |
2937 | offset64 = aOffset[i]; |
2938 | zHdr = zData + pC->iHdrOffset; |
2939 | zEndHdr = zData + aOffset[0]; |
2940 | testcase( zHdr>=zEndHdr ); |
2941 | do{ |
2942 | if( (pC->aType[i] = t = zHdr[0])<0x80 ){ |
2943 | zHdr++; |
2944 | offset64 += sqlite3VdbeOneByteSerialTypeLen(t); |
2945 | }else{ |
2946 | zHdr += sqlite3GetVarint32(zHdr, &t); |
2947 | pC->aType[i] = t; |
2948 | offset64 += sqlite3VdbeSerialTypeLen(t); |
2949 | } |
2950 | aOffset[++i] = (u32)(offset64 & 0xffffffff); |
2951 | }while( (u32)i<=p2 && zHdr<zEndHdr ); |
2952 | |
2953 | /* The record is corrupt if any of the following are true: |
2954 | ** (1) the bytes of the header extend past the declared header size |
2955 | ** (2) the entire header was used but not all data was used |
2956 | ** (3) the end of the data extends beyond the end of the record. |
2957 | */ |
2958 | if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize)) |
2959 | || (offset64 > pC->payloadSize) |
2960 | ){ |
2961 | if( aOffset[0]==0 ){ |
2962 | i = 0; |
2963 | zHdr = zEndHdr; |
2964 | }else{ |
2965 | if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem); |
2966 | goto op_column_corrupt; |
2967 | } |
2968 | } |
2969 | |
2970 | pC->nHdrParsed = i; |
2971 | pC->iHdrOffset = (u32)(zHdr - zData); |
2972 | if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem); |
2973 | }else{ |
2974 | t = 0; |
2975 | } |
2976 | |
2977 | /* If after trying to extract new entries from the header, nHdrParsed is |
2978 | ** still not up to p2, that means that the record has fewer than p2 |
2979 | ** columns. So the result will be either the default value or a NULL. |
2980 | */ |
2981 | if( pC->nHdrParsed<=p2 ){ |
2982 | pDest = &aMem[pOp->p3]; |
2983 | memAboutToChange(p, pDest); |
2984 | if( pOp->p4type==P4_MEM ){ |
2985 | sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static); |
2986 | }else{ |
2987 | sqlite3VdbeMemSetNull(pDest); |
2988 | } |
2989 | goto op_column_out; |
2990 | } |
2991 | }else{ |
2992 | t = pC->aType[p2]; |
2993 | } |
2994 | |
2995 | /* Extract the content for the p2+1-th column. Control can only |
2996 | ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are |
2997 | ** all valid. |
2998 | */ |
2999 | assert( p2<pC->nHdrParsed ); |
3000 | assert( rc==SQLITE_OK ); |
3001 | pDest = &aMem[pOp->p3]; |
3002 | memAboutToChange(p, pDest); |
3003 | assert( sqlite3VdbeCheckMemInvariants(pDest) ); |
3004 | if( VdbeMemDynamic(pDest) ){ |
3005 | sqlite3VdbeMemSetNull(pDest); |
3006 | } |
3007 | assert( t==pC->aType[p2] ); |
3008 | if( pC->szRow>=aOffset[p2+1] ){ |
3009 | /* This is the common case where the desired content fits on the original |
3010 | ** page - where the content is not on an overflow page */ |
3011 | zData = pC->aRow + aOffset[p2]; |
3012 | if( t<12 ){ |
3013 | sqlite3VdbeSerialGet(zData, t, pDest); |
3014 | }else{ |
3015 | /* If the column value is a string, we need a persistent value, not |
3016 | ** a MEM_Ephem value. This branch is a fast short-cut that is equivalent |
3017 | ** to calling sqlite3VdbeSerialGet() and sqlite3VdbeDeephemeralize(). |
3018 | */ |
3019 | static const u16 aFlag[] = { MEM_Blob, MEM_Str|MEM_Term }; |
3020 | pDest->n = len = (t-12)/2; |
3021 | pDest->enc = encoding; |
3022 | if( pDest->szMalloc < len+2 ){ |
3023 | if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) goto too_big; |
3024 | pDest->flags = MEM_Null; |
3025 | if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem; |
3026 | }else{ |
3027 | pDest->z = pDest->zMalloc; |
3028 | } |
3029 | memcpy(pDest->z, zData, len); |
3030 | pDest->z[len] = 0; |
3031 | pDest->z[len+1] = 0; |
3032 | pDest->flags = aFlag[t&1]; |
3033 | } |
3034 | }else{ |
3035 | pDest->enc = encoding; |
3036 | /* This branch happens only when content is on overflow pages */ |
3037 | if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0 |
3038 | && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0)) |
3039 | || (len = sqlite3VdbeSerialTypeLen(t))==0 |
3040 | ){ |
3041 | /* Content is irrelevant for |
3042 | ** 1. the typeof() function, |
3043 | ** 2. the length(X) function if X is a blob, and |
3044 | ** 3. if the content length is zero. |
3045 | ** So we might as well use bogus content rather than reading |
3046 | ** content from disk. |
3047 | ** |
3048 | ** Although sqlite3VdbeSerialGet() may read at most 8 bytes from the |
3049 | ** buffer passed to it, debugging function VdbeMemPrettyPrint() may |
3050 | ** read more. Use the global constant sqlite3CtypeMap[] as the array, |
3051 | ** as that array is 256 bytes long (plenty for VdbeMemPrettyPrint()) |
3052 | ** and it begins with a bunch of zeros. |
3053 | */ |
3054 | sqlite3VdbeSerialGet((u8*)sqlite3CtypeMap, t, pDest); |
3055 | }else{ |
3056 | if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) goto too_big; |
3057 | rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest); |
3058 | if( rc!=SQLITE_OK ) goto abort_due_to_error; |
3059 | sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest); |
3060 | pDest->flags &= ~MEM_Ephem; |
3061 | } |
3062 | } |
3063 | |
3064 | op_column_out: |
3065 | UPDATE_MAX_BLOBSIZE(pDest); |
3066 | REGISTER_TRACE(pOp->p3, pDest); |
3067 | break; |
3068 | |
3069 | op_column_corrupt: |
3070 | if( aOp[0].p3>0 ){ |
3071 | pOp = &aOp[aOp[0].p3-1]; |
3072 | break; |
3073 | }else{ |
3074 | rc = SQLITE_CORRUPT_BKPT; |
3075 | goto abort_due_to_error; |
3076 | } |
3077 | } |
3078 | |
3079 | /* Opcode: TypeCheck P1 P2 P3 P4 * |
3080 | ** Synopsis: typecheck(r[P1@P2]) |
3081 | ** |
3082 | ** Apply affinities to the range of P2 registers beginning with P1. |
3083 | ** Take the affinities from the Table object in P4. If any value |
3084 | ** cannot be coerced into the correct type, then raise an error. |
3085 | ** |
3086 | ** This opcode is similar to OP_Affinity except that this opcode |
3087 | ** forces the register type to the Table column type. This is used |
3088 | ** to implement "strict affinity". |
3089 | ** |
3090 | ** GENERATED ALWAYS AS ... STATIC columns are only checked if P3 |
3091 | ** is zero. When P3 is non-zero, no type checking occurs for |
3092 | ** static generated columns. Virtual columns are computed at query time |
3093 | ** and so they are never checked. |
3094 | ** |
3095 | ** Preconditions: |
3096 | ** |
3097 | ** <ul> |
3098 | ** <li> P2 should be the number of non-virtual columns in the |
3099 | ** table of P4. |
3100 | ** <li> Table P4 should be a STRICT table. |
3101 | ** </ul> |
3102 | ** |
3103 | ** If any precondition is false, an assertion fault occurs. |
3104 | */ |
3105 | case OP_TypeCheck: { |
3106 | Table *pTab; |
3107 | Column *aCol; |
3108 | int i; |
3109 | |
3110 | assert( pOp->p4type==P4_TABLE ); |
3111 | pTab = pOp->p4.pTab; |
3112 | assert( pTab->tabFlags & TF_Strict ); |
3113 | assert( pTab->nNVCol==pOp->p2 ); |
3114 | aCol = pTab->aCol; |
3115 | pIn1 = &aMem[pOp->p1]; |
3116 | for(i=0; i<pTab->nCol; i++){ |
3117 | if( aCol[i].colFlags & COLFLAG_GENERATED ){ |
3118 | if( aCol[i].colFlags & COLFLAG_VIRTUAL ) continue; |
3119 | if( pOp->p3 ){ pIn1++; continue; } |
3120 | } |
3121 | assert( pIn1 < &aMem[pOp->p1+pOp->p2] ); |
3122 | applyAffinity(pIn1, aCol[i].affinity, encoding); |
3123 | if( (pIn1->flags & MEM_Null)==0 ){ |
3124 | switch( aCol[i].eCType ){ |
3125 | case COLTYPE_BLOB: { |
3126 | if( (pIn1->flags & MEM_Blob)==0 ) goto vdbe_type_error; |
3127 | break; |
3128 | } |
3129 | case COLTYPE_INTEGER: |
3130 | case COLTYPE_INT: { |
3131 | if( (pIn1->flags & MEM_Int)==0 ) goto vdbe_type_error; |
3132 | break; |
3133 | } |
3134 | case COLTYPE_TEXT: { |
3135 | if( (pIn1->flags & MEM_Str)==0 ) goto vdbe_type_error; |
3136 | break; |
3137 | } |
3138 | case COLTYPE_REAL: { |
3139 | testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_Real ); |
3140 | testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_IntReal ); |
3141 | if( pIn1->flags & MEM_Int ){ |
3142 | /* When applying REAL affinity, if the result is still an MEM_Int |
3143 | ** that will fit in 6 bytes, then change the type to MEM_IntReal |
3144 | ** so that we keep the high-resolution integer value but know that |
3145 | ** the type really wants to be REAL. */ |
3146 | testcase( pIn1->u.i==140737488355328LL ); |
3147 | testcase( pIn1->u.i==140737488355327LL ); |
3148 | testcase( pIn1->u.i==-140737488355328LL ); |
3149 | testcase( pIn1->u.i==-140737488355329LL ); |
3150 | if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL){ |
3151 | pIn1->flags |= MEM_IntReal; |
3152 | pIn1->flags &= ~MEM_Int; |
3153 | }else{ |
3154 | pIn1->u.r = (double)pIn1->u.i; |
3155 | pIn1->flags |= MEM_Real; |
3156 | pIn1->flags &= ~MEM_Int; |
3157 | } |
3158 | }else if( (pIn1->flags & (MEM_Real|MEM_IntReal))==0 ){ |
3159 | goto vdbe_type_error; |
3160 | } |
3161 | break; |
3162 | } |
3163 | default: { |
3164 | /* COLTYPE_ANY. Accept anything. */ |
3165 | break; |
3166 | } |
3167 | } |
3168 | } |
3169 | REGISTER_TRACE((int)(pIn1-aMem), pIn1); |
3170 | pIn1++; |
3171 | } |
3172 | assert( pIn1 == &aMem[pOp->p1+pOp->p2] ); |
3173 | break; |
3174 | |
3175 | vdbe_type_error: |
3176 | sqlite3VdbeError(p, "cannot store %s value in %s column %s.%s" , |
3177 | vdbeMemTypeName(pIn1), sqlite3StdType[aCol[i].eCType-1], |
3178 | pTab->zName, aCol[i].zCnName); |
3179 | rc = SQLITE_CONSTRAINT_DATATYPE; |
3180 | goto abort_due_to_error; |
3181 | } |
3182 | |
3183 | /* Opcode: Affinity P1 P2 * P4 * |
3184 | ** Synopsis: affinity(r[P1@P2]) |
3185 | ** |
3186 | ** Apply affinities to a range of P2 registers starting with P1. |
3187 | ** |
3188 | ** P4 is a string that is P2 characters long. The N-th character of the |
3189 | ** string indicates the column affinity that should be used for the N-th |
3190 | ** memory cell in the range. |
3191 | */ |
3192 | case OP_Affinity: { |
3193 | const char *zAffinity; /* The affinity to be applied */ |
3194 | |
3195 | zAffinity = pOp->p4.z; |
3196 | assert( zAffinity!=0 ); |
3197 | assert( pOp->p2>0 ); |
3198 | assert( zAffinity[pOp->p2]==0 ); |
3199 | pIn1 = &aMem[pOp->p1]; |
3200 | while( 1 /*exit-by-break*/ ){ |
3201 | assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] ); |
3202 | assert( zAffinity[0]==SQLITE_AFF_NONE || memIsValid(pIn1) ); |
3203 | applyAffinity(pIn1, zAffinity[0], encoding); |
3204 | if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){ |
3205 | /* When applying REAL affinity, if the result is still an MEM_Int |
3206 | ** that will fit in 6 bytes, then change the type to MEM_IntReal |
3207 | ** so that we keep the high-resolution integer value but know that |
3208 | ** the type really wants to be REAL. */ |
3209 | testcase( pIn1->u.i==140737488355328LL ); |
3210 | testcase( pIn1->u.i==140737488355327LL ); |
3211 | testcase( pIn1->u.i==-140737488355328LL ); |
3212 | testcase( pIn1->u.i==-140737488355329LL ); |
3213 | if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL ){ |
3214 | pIn1->flags |= MEM_IntReal; |
3215 | pIn1->flags &= ~MEM_Int; |
3216 | }else{ |
3217 | pIn1->u.r = (double)pIn1->u.i; |
3218 | pIn1->flags |= MEM_Real; |
3219 | pIn1->flags &= ~MEM_Int; |
3220 | } |
3221 | } |
3222 | REGISTER_TRACE((int)(pIn1-aMem), pIn1); |
3223 | zAffinity++; |
3224 | if( zAffinity[0]==0 ) break; |
3225 | pIn1++; |
3226 | } |
3227 | break; |
3228 | } |
3229 | |
3230 | /* Opcode: MakeRecord P1 P2 P3 P4 * |
3231 | ** Synopsis: r[P3]=mkrec(r[P1@P2]) |
3232 | ** |
3233 | ** Convert P2 registers beginning with P1 into the [record format] |
3234 | ** use as a data record in a database table or as a key |
3235 | ** in an index. The OP_Column opcode can decode the record later. |
3236 | ** |
3237 | ** P4 may be a string that is P2 characters long. The N-th character of the |
3238 | ** string indicates the column affinity that should be used for the N-th |
3239 | ** field of the index key. |
3240 | ** |
3241 | ** The mapping from character to affinity is given by the SQLITE_AFF_ |
3242 | ** macros defined in sqliteInt.h. |
3243 | ** |
3244 | ** If P4 is NULL then all index fields have the affinity BLOB. |
3245 | ** |
3246 | ** The meaning of P5 depends on whether or not the SQLITE_ENABLE_NULL_TRIM |
3247 | ** compile-time option is enabled: |
3248 | ** |
3249 | ** * If SQLITE_ENABLE_NULL_TRIM is enabled, then the P5 is the index |
3250 | ** of the right-most table that can be null-trimmed. |
3251 | ** |
3252 | ** * If SQLITE_ENABLE_NULL_TRIM is omitted, then P5 has the value |
3253 | ** OPFLAG_NOCHNG_MAGIC if the OP_MakeRecord opcode is allowed to |
3254 | ** accept no-change records with serial_type 10. This value is |
3255 | ** only used inside an assert() and does not affect the end result. |
3256 | */ |
3257 | case OP_MakeRecord: { |
3258 | Mem *pRec; /* The new record */ |
3259 | u64 nData; /* Number of bytes of data space */ |
3260 | int nHdr; /* Number of bytes of header space */ |
3261 | i64 nByte; /* Data space required for this record */ |
3262 | i64 nZero; /* Number of zero bytes at the end of the record */ |
3263 | int nVarint; /* Number of bytes in a varint */ |
3264 | u32 serial_type; /* Type field */ |
3265 | Mem *pData0; /* First field to be combined into the record */ |
3266 | Mem *pLast; /* Last field of the record */ |
3267 | int nField; /* Number of fields in the record */ |
3268 | char *zAffinity; /* The affinity string for the record */ |
3269 | u32 len; /* Length of a field */ |
3270 | u8 *zHdr; /* Where to write next byte of the header */ |
3271 | u8 *zPayload; /* Where to write next byte of the payload */ |
3272 | |
3273 | /* Assuming the record contains N fields, the record format looks |
3274 | ** like this: |
3275 | ** |
3276 | ** ------------------------------------------------------------------------ |
3277 | ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | |
3278 | ** ------------------------------------------------------------------------ |
3279 | ** |
3280 | ** Data(0) is taken from register P1. Data(1) comes from register P1+1 |
3281 | ** and so forth. |
3282 | ** |
3283 | ** Each type field is a varint representing the serial type of the |
3284 | ** corresponding data element (see sqlite3VdbeSerialType()). The |
3285 | ** hdr-size field is also a varint which is the offset from the beginning |
3286 | ** of the record to data0. |
3287 | */ |
3288 | nData = 0; /* Number of bytes of data space */ |
3289 | nHdr = 0; /* Number of bytes of header space */ |
3290 | nZero = 0; /* Number of zero bytes at the end of the record */ |
3291 | nField = pOp->p1; |
3292 | zAffinity = pOp->p4.z; |
3293 | assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 ); |
3294 | pData0 = &aMem[nField]; |
3295 | nField = pOp->p2; |
3296 | pLast = &pData0[nField-1]; |
3297 | |
3298 | /* Identify the output register */ |
3299 | assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 ); |
3300 | pOut = &aMem[pOp->p3]; |
3301 | memAboutToChange(p, pOut); |
3302 | |
3303 | /* Apply the requested affinity to all inputs |
3304 | */ |
3305 | assert( pData0<=pLast ); |
3306 | if( zAffinity ){ |
3307 | pRec = pData0; |
3308 | do{ |
3309 | applyAffinity(pRec, zAffinity[0], encoding); |
3310 | if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){ |
3311 | pRec->flags |= MEM_IntReal; |
3312 | pRec->flags &= ~(MEM_Int); |
3313 | } |
3314 | REGISTER_TRACE((int)(pRec-aMem), pRec); |
3315 | zAffinity++; |
3316 | pRec++; |
3317 | assert( zAffinity[0]==0 || pRec<=pLast ); |
3318 | }while( zAffinity[0] ); |
3319 | } |
3320 | |
3321 | #ifdef SQLITE_ENABLE_NULL_TRIM |
3322 | /* NULLs can be safely trimmed from the end of the record, as long as |
3323 | ** as the schema format is 2 or more and none of the omitted columns |
3324 | ** have a non-NULL default value. Also, the record must be left with |
3325 | ** at least one field. If P5>0 then it will be one more than the |
3326 | ** index of the right-most column with a non-NULL default value */ |
3327 | if( pOp->p5 ){ |
3328 | while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){ |
3329 | pLast--; |
3330 | nField--; |
3331 | } |
3332 | } |
3333 | #endif |
3334 | |
3335 | /* Loop through the elements that will make up the record to figure |
3336 | ** out how much space is required for the new record. After this loop, |
3337 | ** the Mem.uTemp field of each term should hold the serial-type that will |
3338 | ** be used for that term in the generated record: |
3339 | ** |
3340 | ** Mem.uTemp value type |
3341 | ** --------------- --------------- |
3342 | ** 0 NULL |
3343 | ** 1 1-byte signed integer |
3344 | ** 2 2-byte signed integer |
3345 | ** 3 3-byte signed integer |
3346 | ** 4 4-byte signed integer |
3347 | ** 5 6-byte signed integer |
3348 | ** 6 8-byte signed integer |
3349 | ** 7 IEEE float |
3350 | ** 8 Integer constant 0 |
3351 | ** 9 Integer constant 1 |
3352 | ** 10,11 reserved for expansion |
3353 | ** N>=12 and even BLOB |
3354 | ** N>=13 and odd text |
3355 | ** |
3356 | ** The following additional values are computed: |
3357 | ** nHdr Number of bytes needed for the record header |
3358 | ** nData Number of bytes of data space needed for the record |
3359 | ** nZero Zero bytes at the end of the record |
3360 | */ |
3361 | pRec = pLast; |
3362 | do{ |
3363 | assert( memIsValid(pRec) ); |
3364 | if( pRec->flags & MEM_Null ){ |
3365 | if( pRec->flags & MEM_Zero ){ |
3366 | /* Values with MEM_Null and MEM_Zero are created by xColumn virtual |
3367 | ** table methods that never invoke sqlite3_result_xxxxx() while |
3368 | ** computing an unchanging column value in an UPDATE statement. |
3369 | ** Give such values a special internal-use-only serial-type of 10 |
3370 | ** so that they can be passed through to xUpdate and have |
3371 | ** a true sqlite3_value_nochange(). */ |
3372 | #ifndef SQLITE_ENABLE_NULL_TRIM |
3373 | assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB ); |
3374 | #endif |
3375 | pRec->uTemp = 10; |
3376 | }else{ |
3377 | pRec->uTemp = 0; |
3378 | } |
3379 | nHdr++; |
3380 | }else if( pRec->flags & (MEM_Int|MEM_IntReal) ){ |
3381 | /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */ |
3382 | i64 i = pRec->u.i; |
3383 | u64 uu; |
3384 | testcase( pRec->flags & MEM_Int ); |
3385 | testcase( pRec->flags & MEM_IntReal ); |
3386 | if( i<0 ){ |
3387 | uu = ~i; |
3388 | }else{ |
3389 | uu = i; |
3390 | } |
3391 | nHdr++; |
3392 | testcase( uu==127 ); testcase( uu==128 ); |
3393 | testcase( uu==32767 ); testcase( uu==32768 ); |
3394 | testcase( uu==8388607 ); testcase( uu==8388608 ); |
3395 | testcase( uu==2147483647 ); testcase( uu==2147483648LL ); |
3396 | testcase( uu==140737488355327LL ); testcase( uu==140737488355328LL ); |
3397 | if( uu<=127 ){ |
3398 | if( (i&1)==i && p->minWriteFileFormat>=4 ){ |
3399 | pRec->uTemp = 8+(u32)uu; |
3400 | }else{ |
3401 | nData++; |
3402 | pRec->uTemp = 1; |
3403 | } |
3404 | }else if( uu<=32767 ){ |
3405 | nData += 2; |
3406 | pRec->uTemp = 2; |
3407 | }else if( uu<=8388607 ){ |
3408 | nData += 3; |
3409 | pRec->uTemp = 3; |
3410 | }else if( uu<=2147483647 ){ |
3411 | nData += 4; |
3412 | pRec->uTemp = 4; |
3413 | }else if( uu<=140737488355327LL ){ |
3414 | nData += 6; |
3415 | pRec->uTemp = 5; |
3416 | }else{ |
3417 | nData += 8; |
3418 | if( pRec->flags & MEM_IntReal ){ |
3419 | /* If the value is IntReal and is going to take up 8 bytes to store |
3420 | ** as an integer, then we might as well make it an 8-byte floating |
3421 | ** point value */ |
3422 | pRec->u.r = (double)pRec->u.i; |
3423 | pRec->flags &= ~MEM_IntReal; |
3424 | pRec->flags |= MEM_Real; |
3425 | pRec->uTemp = 7; |
3426 | }else{ |
3427 | pRec->uTemp = 6; |
3428 | } |
3429 | } |
3430 | }else if( pRec->flags & MEM_Real ){ |
3431 | nHdr++; |
3432 | nData += 8; |
3433 | pRec->uTemp = 7; |
3434 | }else{ |
3435 | assert( db->mallocFailed || pRec->flags&(MEM_Str|MEM_Blob) ); |
3436 | assert( pRec->n>=0 ); |
3437 | len = (u32)pRec->n; |
3438 | serial_type = (len*2) + 12 + ((pRec->flags & MEM_Str)!=0); |
3439 | if( pRec->flags & MEM_Zero ){ |
3440 | serial_type += pRec->u.nZero*2; |
3441 | if( nData ){ |
3442 | if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem; |
3443 | len += pRec->u.nZero; |
3444 | }else{ |
3445 | nZero += pRec->u.nZero; |
3446 | } |
3447 | } |
3448 | nData += len; |
3449 | nHdr += sqlite3VarintLen(serial_type); |
3450 | pRec->uTemp = serial_type; |
3451 | } |
3452 | if( pRec==pData0 ) break; |
3453 | pRec--; |
3454 | }while(1); |
3455 | |
3456 | /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint |
3457 | ** which determines the total number of bytes in the header. The varint |
3458 | ** value is the size of the header in bytes including the size varint |
3459 | ** itself. */ |
3460 | testcase( nHdr==126 ); |
3461 | testcase( nHdr==127 ); |
3462 | if( nHdr<=126 ){ |
3463 | /* The common case */ |
3464 | nHdr += 1; |
3465 | }else{ |
3466 | /* Rare case of a really large header */ |
3467 | nVarint = sqlite3VarintLen(nHdr); |
3468 | nHdr += nVarint; |
3469 | if( nVarint<sqlite3VarintLen(nHdr) ) nHdr++; |
3470 | } |
3471 | nByte = nHdr+nData; |
3472 | |
3473 | /* Make sure the output register has a buffer large enough to store |
3474 | ** the new record. The output register (pOp->p3) is not allowed to |
3475 | ** be one of the input registers (because the following call to |
3476 | ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used). |
3477 | */ |
3478 | if( nByte+nZero<=pOut->szMalloc ){ |
3479 | /* The output register is already large enough to hold the record. |
3480 | ** No error checks or buffer enlargement is required */ |
3481 | pOut->z = pOut->zMalloc; |
3482 | }else{ |
3483 | /* Need to make sure that the output is not too big and then enlarge |
3484 | ** the output register to hold the full result */ |
3485 | if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){ |
3486 | goto too_big; |
3487 | } |
3488 | if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){ |
3489 | goto no_mem; |
3490 | } |
3491 | } |
3492 | pOut->n = (int)nByte; |
3493 | pOut->flags = MEM_Blob; |
3494 | if( nZero ){ |
3495 | pOut->u.nZero = nZero; |
3496 | pOut->flags |= MEM_Zero; |
3497 | } |
3498 | UPDATE_MAX_BLOBSIZE(pOut); |
3499 | zHdr = (u8 *)pOut->z; |
3500 | zPayload = zHdr + nHdr; |
3501 | |
3502 | /* Write the record */ |
3503 | if( nHdr<0x80 ){ |
3504 | *(zHdr++) = nHdr; |
3505 | }else{ |
3506 | zHdr += sqlite3PutVarint(zHdr,nHdr); |
3507 | } |
3508 | assert( pData0<=pLast ); |
3509 | pRec = pData0; |
3510 | while( 1 /*exit-by-break*/ ){ |
3511 | serial_type = pRec->uTemp; |
3512 | /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more |
3513 | ** additional varints, one per column. |
3514 | ** EVIDENCE-OF: R-64536-51728 The values for each column in the record |
3515 | ** immediately follow the header. */ |
3516 | if( serial_type<=7 ){ |
3517 | *(zHdr++) = serial_type; |
3518 | if( serial_type==0 ){ |
3519 | /* NULL value. No change in zPayload */ |
3520 | }else{ |
3521 | u64 v; |
3522 | u32 i; |
3523 | if( serial_type==7 ){ |
3524 | assert( sizeof(v)==sizeof(pRec->u.r) ); |
3525 | memcpy(&v, &pRec->u.r, sizeof(v)); |
3526 | swapMixedEndianFloat(v); |
3527 | }else{ |
3528 | v = pRec->u.i; |
3529 | } |
3530 | len = i = sqlite3SmallTypeSizes[serial_type]; |
3531 | assert( i>0 ); |
3532 | while( 1 /*exit-by-break*/ ){ |
3533 | zPayload[--i] = (u8)(v&0xFF); |
3534 | if( i==0 ) break; |
3535 | v >>= 8; |
3536 | } |
3537 | zPayload += len; |
3538 | } |
3539 | }else if( serial_type<0x80 ){ |
3540 | *(zHdr++) = serial_type; |
3541 | if( serial_type>=14 && pRec->n>0 ){ |
3542 | assert( pRec->z!=0 ); |
3543 | memcpy(zPayload, pRec->z, pRec->n); |
3544 | zPayload += pRec->n; |
3545 | } |
3546 | }else{ |
3547 | zHdr += sqlite3PutVarint(zHdr, serial_type); |
3548 | if( pRec->n ){ |
3549 | assert( pRec->z!=0 ); |
3550 | memcpy(zPayload, pRec->z, pRec->n); |
3551 | zPayload += pRec->n; |
3552 | } |
3553 | } |
3554 | if( pRec==pLast ) break; |
3555 | pRec++; |
3556 | } |
3557 | assert( nHdr==(int)(zHdr - (u8*)pOut->z) ); |
3558 | assert( nByte==(int)(zPayload - (u8*)pOut->z) ); |
3559 | |
3560 | assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
3561 | REGISTER_TRACE(pOp->p3, pOut); |
3562 | break; |
3563 | } |
3564 | |
3565 | /* Opcode: Count P1 P2 P3 * * |
3566 | ** Synopsis: r[P2]=count() |
3567 | ** |
3568 | ** Store the number of entries (an integer value) in the table or index |
3569 | ** opened by cursor P1 in register P2. |
3570 | ** |
3571 | ** If P3==0, then an exact count is obtained, which involves visiting |
3572 | ** every btree page of the table. But if P3 is non-zero, an estimate |
3573 | ** is returned based on the current cursor position. |
3574 | */ |
3575 | case OP_Count: { /* out2 */ |
3576 | i64 nEntry; |
3577 | BtCursor *pCrsr; |
3578 | |
3579 | assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE ); |
3580 | pCrsr = p->apCsr[pOp->p1]->uc.pCursor; |
3581 | assert( pCrsr ); |
3582 | if( pOp->p3 ){ |
3583 | nEntry = sqlite3BtreeRowCountEst(pCrsr); |
3584 | }else{ |
3585 | nEntry = 0; /* Not needed. Only used to silence a warning. */ |
3586 | rc = sqlite3BtreeCount(db, pCrsr, &nEntry); |
3587 | if( rc ) goto abort_due_to_error; |
3588 | } |
3589 | pOut = out2Prerelease(p, pOp); |
3590 | pOut->u.i = nEntry; |
3591 | goto check_for_interrupt; |
3592 | } |
3593 | |
3594 | /* Opcode: Savepoint P1 * * P4 * |
3595 | ** |
3596 | ** Open, release or rollback the savepoint named by parameter P4, depending |
3597 | ** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN). |
3598 | ** To release (commit) an existing savepoint set P1==1 (SAVEPOINT_RELEASE). |
3599 | ** To rollback an existing savepoint set P1==2 (SAVEPOINT_ROLLBACK). |
3600 | */ |
3601 | case OP_Savepoint: { |
3602 | int p1; /* Value of P1 operand */ |
3603 | char *zName; /* Name of savepoint */ |
3604 | int nName; |
3605 | Savepoint *pNew; |
3606 | Savepoint *pSavepoint; |
3607 | Savepoint *pTmp; |
3608 | int iSavepoint; |
3609 | int ii; |
3610 | |
3611 | p1 = pOp->p1; |
3612 | zName = pOp->p4.z; |
3613 | |
3614 | /* Assert that the p1 parameter is valid. Also that if there is no open |
3615 | ** transaction, then there cannot be any savepoints. |
3616 | */ |
3617 | assert( db->pSavepoint==0 || db->autoCommit==0 ); |
3618 | assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK ); |
3619 | assert( db->pSavepoint || db->isTransactionSavepoint==0 ); |
3620 | assert( checkSavepointCount(db) ); |
3621 | assert( p->bIsReader ); |
3622 | |
3623 | if( p1==SAVEPOINT_BEGIN ){ |
3624 | if( db->nVdbeWrite>0 ){ |
3625 | /* A new savepoint cannot be created if there are active write |
3626 | ** statements (i.e. open read/write incremental blob handles). |
3627 | */ |
3628 | sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress" ); |
3629 | rc = SQLITE_BUSY; |
3630 | }else{ |
3631 | nName = sqlite3Strlen30(zName); |
3632 | |
3633 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
3634 | /* This call is Ok even if this savepoint is actually a transaction |
3635 | ** savepoint (and therefore should not prompt xSavepoint()) callbacks. |
3636 | ** If this is a transaction savepoint being opened, it is guaranteed |
3637 | ** that the db->aVTrans[] array is empty. */ |
3638 | assert( db->autoCommit==0 || db->nVTrans==0 ); |
3639 | rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, |
3640 | db->nStatement+db->nSavepoint); |
3641 | if( rc!=SQLITE_OK ) goto abort_due_to_error; |
3642 | #endif |
3643 | |
3644 | /* Create a new savepoint structure. */ |
3645 | pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1); |
3646 | if( pNew ){ |
3647 | pNew->zName = (char *)&pNew[1]; |
3648 | memcpy(pNew->zName, zName, nName+1); |
3649 | |
3650 | /* If there is no open transaction, then mark this as a special |
3651 | ** "transaction savepoint". */ |
3652 | if( db->autoCommit ){ |
3653 | db->autoCommit = 0; |
3654 | db->isTransactionSavepoint = 1; |
3655 | }else{ |
3656 | db->nSavepoint++; |
3657 | } |
3658 | |
3659 | /* Link the new savepoint into the database handle's list. */ |
3660 | pNew->pNext = db->pSavepoint; |
3661 | db->pSavepoint = pNew; |
3662 | pNew->nDeferredCons = db->nDeferredCons; |
3663 | pNew->nDeferredImmCons = db->nDeferredImmCons; |
3664 | } |
3665 | } |
3666 | }else{ |
3667 | assert( p1==SAVEPOINT_RELEASE || p1==SAVEPOINT_ROLLBACK ); |
3668 | iSavepoint = 0; |
3669 | |
3670 | /* Find the named savepoint. If there is no such savepoint, then an |
3671 | ** an error is returned to the user. */ |
3672 | for( |
3673 | pSavepoint = db->pSavepoint; |
3674 | pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName); |
3675 | pSavepoint = pSavepoint->pNext |
3676 | ){ |
3677 | iSavepoint++; |
3678 | } |
3679 | if( !pSavepoint ){ |
3680 | sqlite3VdbeError(p, "no such savepoint: %s" , zName); |
3681 | rc = SQLITE_ERROR; |
3682 | }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){ |
3683 | /* It is not possible to release (commit) a savepoint if there are |
3684 | ** active write statements. |
3685 | */ |
3686 | sqlite3VdbeError(p, "cannot release savepoint - " |
3687 | "SQL statements in progress" ); |
3688 | rc = SQLITE_BUSY; |
3689 | }else{ |
3690 | |
3691 | /* Determine whether or not this is a transaction savepoint. If so, |
3692 | ** and this is a RELEASE command, then the current transaction |
3693 | ** is committed. |
3694 | */ |
3695 | int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint; |
3696 | if( isTransaction && p1==SAVEPOINT_RELEASE ){ |
3697 | if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ |
3698 | goto vdbe_return; |
3699 | } |
3700 | db->autoCommit = 1; |
3701 | if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ |
3702 | p->pc = (int)(pOp - aOp); |
3703 | db->autoCommit = 0; |
3704 | p->rc = rc = SQLITE_BUSY; |
3705 | goto vdbe_return; |
3706 | } |
3707 | rc = p->rc; |
3708 | if( rc ){ |
3709 | db->autoCommit = 0; |
3710 | }else{ |
3711 | db->isTransactionSavepoint = 0; |
3712 | } |
3713 | }else{ |
3714 | int isSchemaChange; |
3715 | iSavepoint = db->nSavepoint - iSavepoint - 1; |
3716 | if( p1==SAVEPOINT_ROLLBACK ){ |
3717 | isSchemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0; |
3718 | for(ii=0; ii<db->nDb; ii++){ |
3719 | rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt, |
3720 | SQLITE_ABORT_ROLLBACK, |
3721 | isSchemaChange==0); |
3722 | if( rc!=SQLITE_OK ) goto abort_due_to_error; |
3723 | } |
3724 | }else{ |
3725 | assert( p1==SAVEPOINT_RELEASE ); |
3726 | isSchemaChange = 0; |
3727 | } |
3728 | for(ii=0; ii<db->nDb; ii++){ |
3729 | rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint); |
3730 | if( rc!=SQLITE_OK ){ |
3731 | goto abort_due_to_error; |
3732 | } |
3733 | } |
3734 | if( isSchemaChange ){ |
3735 | sqlite3ExpirePreparedStatements(db, 0); |
3736 | sqlite3ResetAllSchemasOfConnection(db); |
3737 | db->mDbFlags |= DBFLAG_SchemaChange; |
3738 | } |
3739 | } |
3740 | if( rc ) goto abort_due_to_error; |
3741 | |
3742 | /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all |
3743 | ** savepoints nested inside of the savepoint being operated on. */ |
3744 | while( db->pSavepoint!=pSavepoint ){ |
3745 | pTmp = db->pSavepoint; |
3746 | db->pSavepoint = pTmp->pNext; |
3747 | sqlite3DbFree(db, pTmp); |
3748 | db->nSavepoint--; |
3749 | } |
3750 | |
3751 | /* If it is a RELEASE, then destroy the savepoint being operated on |
3752 | ** too. If it is a ROLLBACK TO, then set the number of deferred |
3753 | ** constraint violations present in the database to the value stored |
3754 | ** when the savepoint was created. */ |
3755 | if( p1==SAVEPOINT_RELEASE ){ |
3756 | assert( pSavepoint==db->pSavepoint ); |
3757 | db->pSavepoint = pSavepoint->pNext; |
3758 | sqlite3DbFree(db, pSavepoint); |
3759 | if( !isTransaction ){ |
3760 | db->nSavepoint--; |
3761 | } |
3762 | }else{ |
3763 | assert( p1==SAVEPOINT_ROLLBACK ); |
3764 | db->nDeferredCons = pSavepoint->nDeferredCons; |
3765 | db->nDeferredImmCons = pSavepoint->nDeferredImmCons; |
3766 | } |
3767 | |
3768 | if( !isTransaction || p1==SAVEPOINT_ROLLBACK ){ |
3769 | rc = sqlite3VtabSavepoint(db, p1, iSavepoint); |
3770 | if( rc!=SQLITE_OK ) goto abort_due_to_error; |
3771 | } |
3772 | } |
3773 | } |
3774 | if( rc ) goto abort_due_to_error; |
3775 | if( p->eVdbeState==VDBE_HALT_STATE ){ |
3776 | rc = SQLITE_DONE; |
3777 | goto vdbe_return; |
3778 | } |
3779 | break; |
3780 | } |
3781 | |
3782 | /* Opcode: AutoCommit P1 P2 * * * |
3783 | ** |
3784 | ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll |
3785 | ** back any currently active btree transactions. If there are any active |
3786 | ** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if |
3787 | ** there are active writing VMs or active VMs that use shared cache. |
3788 | ** |
3789 | ** This instruction causes the VM to halt. |
3790 | */ |
3791 | case OP_AutoCommit: { |
3792 | int desiredAutoCommit; |
3793 | int iRollback; |
3794 | |
3795 | desiredAutoCommit = pOp->p1; |
3796 | iRollback = pOp->p2; |
3797 | assert( desiredAutoCommit==1 || desiredAutoCommit==0 ); |
3798 | assert( desiredAutoCommit==1 || iRollback==0 ); |
3799 | assert( db->nVdbeActive>0 ); /* At least this one VM is active */ |
3800 | assert( p->bIsReader ); |
3801 | |
3802 | if( desiredAutoCommit!=db->autoCommit ){ |
3803 | if( iRollback ){ |
3804 | assert( desiredAutoCommit==1 ); |
3805 | sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); |
3806 | db->autoCommit = 1; |
3807 | }else if( desiredAutoCommit && db->nVdbeWrite>0 ){ |
3808 | /* If this instruction implements a COMMIT and other VMs are writing |
3809 | ** return an error indicating that the other VMs must complete first. |
3810 | */ |
3811 | sqlite3VdbeError(p, "cannot commit transaction - " |
3812 | "SQL statements in progress" ); |
3813 | rc = SQLITE_BUSY; |
3814 | goto abort_due_to_error; |
3815 | }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ |
3816 | goto vdbe_return; |
3817 | }else{ |
3818 | db->autoCommit = (u8)desiredAutoCommit; |
3819 | } |
3820 | if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ |
3821 | p->pc = (int)(pOp - aOp); |
3822 | db->autoCommit = (u8)(1-desiredAutoCommit); |
3823 | p->rc = rc = SQLITE_BUSY; |
3824 | goto vdbe_return; |
3825 | } |
3826 | sqlite3CloseSavepoints(db); |
3827 | if( p->rc==SQLITE_OK ){ |
3828 | rc = SQLITE_DONE; |
3829 | }else{ |
3830 | rc = SQLITE_ERROR; |
3831 | } |
3832 | goto vdbe_return; |
3833 | }else{ |
3834 | sqlite3VdbeError(p, |
3835 | (!desiredAutoCommit)?"cannot start a transaction within a transaction" :( |
3836 | (iRollback)?"cannot rollback - no transaction is active" : |
3837 | "cannot commit - no transaction is active" )); |
3838 | |
3839 | rc = SQLITE_ERROR; |
3840 | goto abort_due_to_error; |
3841 | } |
3842 | /*NOTREACHED*/ assert(0); |
3843 | } |
3844 | |
3845 | /* Opcode: Transaction P1 P2 P3 P4 P5 |
3846 | ** |
3847 | ** Begin a transaction on database P1 if a transaction is not already |
3848 | ** active. |
3849 | ** If P2 is non-zero, then a write-transaction is started, or if a |
3850 | ** read-transaction is already active, it is upgraded to a write-transaction. |
3851 | ** If P2 is zero, then a read-transaction is started. If P2 is 2 or more |
3852 | ** then an exclusive transaction is started. |
3853 | ** |
3854 | ** P1 is the index of the database file on which the transaction is |
3855 | ** started. Index 0 is the main database file and index 1 is the |
3856 | ** file used for temporary tables. Indices of 2 or more are used for |
3857 | ** attached databases. |
3858 | ** |
3859 | ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is |
3860 | ** true (this flag is set if the Vdbe may modify more than one row and may |
3861 | ** throw an ABORT exception), a statement transaction may also be opened. |
3862 | ** More specifically, a statement transaction is opened iff the database |
3863 | ** connection is currently not in autocommit mode, or if there are other |
3864 | ** active statements. A statement transaction allows the changes made by this |
3865 | ** VDBE to be rolled back after an error without having to roll back the |
3866 | ** entire transaction. If no error is encountered, the statement transaction |
3867 | ** will automatically commit when the VDBE halts. |
3868 | ** |
3869 | ** If P5!=0 then this opcode also checks the schema cookie against P3 |
3870 | ** and the schema generation counter against P4. |
3871 | ** The cookie changes its value whenever the database schema changes. |
3872 | ** This operation is used to detect when that the cookie has changed |
3873 | ** and that the current process needs to reread the schema. If the schema |
3874 | ** cookie in P3 differs from the schema cookie in the database header or |
3875 | ** if the schema generation counter in P4 differs from the current |
3876 | ** generation counter, then an SQLITE_SCHEMA error is raised and execution |
3877 | ** halts. The sqlite3_step() wrapper function might then reprepare the |
3878 | ** statement and rerun it from the beginning. |
3879 | */ |
3880 | case OP_Transaction: { |
3881 | Btree *pBt; |
3882 | Db *pDb; |
3883 | int iMeta = 0; |
3884 | |
3885 | assert( p->bIsReader ); |
3886 | assert( p->readOnly==0 || pOp->p2==0 ); |
3887 | assert( pOp->p2>=0 && pOp->p2<=2 ); |
3888 | assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
3889 | assert( DbMaskTest(p->btreeMask, pOp->p1) ); |
3890 | assert( rc==SQLITE_OK ); |
3891 | if( pOp->p2 && (db->flags & (SQLITE_QueryOnly|SQLITE_CorruptRdOnly))!=0 ){ |
3892 | if( db->flags & SQLITE_QueryOnly ){ |
3893 | /* Writes prohibited by the "PRAGMA query_only=TRUE" statement */ |
3894 | rc = SQLITE_READONLY; |
3895 | }else{ |
3896 | /* Writes prohibited due to a prior SQLITE_CORRUPT in the current |
3897 | ** transaction */ |
3898 | rc = SQLITE_CORRUPT; |
3899 | } |
3900 | goto abort_due_to_error; |
3901 | } |
3902 | pDb = &db->aDb[pOp->p1]; |
3903 | pBt = pDb->pBt; |
3904 | |
3905 | if( pBt ){ |
3906 | rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta); |
3907 | testcase( rc==SQLITE_BUSY_SNAPSHOT ); |
3908 | testcase( rc==SQLITE_BUSY_RECOVERY ); |
3909 | if( rc!=SQLITE_OK ){ |
3910 | if( (rc&0xff)==SQLITE_BUSY ){ |
3911 | p->pc = (int)(pOp - aOp); |
3912 | p->rc = rc; |
3913 | goto vdbe_return; |
3914 | } |
3915 | goto abort_due_to_error; |
3916 | } |
3917 | |
3918 | if( p->usesStmtJournal |
3919 | && pOp->p2 |
3920 | && (db->autoCommit==0 || db->nVdbeRead>1) |
3921 | ){ |
3922 | assert( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ); |
3923 | if( p->iStatement==0 ){ |
3924 | assert( db->nStatement>=0 && db->nSavepoint>=0 ); |
3925 | db->nStatement++; |
3926 | p->iStatement = db->nSavepoint + db->nStatement; |
3927 | } |
3928 | |
3929 | rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1); |
3930 | if( rc==SQLITE_OK ){ |
3931 | rc = sqlite3BtreeBeginStmt(pBt, p->iStatement); |
3932 | } |
3933 | |
3934 | /* Store the current value of the database handles deferred constraint |
3935 | ** counter. If the statement transaction needs to be rolled back, |
3936 | ** the value of this counter needs to be restored too. */ |
3937 | p->nStmtDefCons = db->nDeferredCons; |
3938 | p->nStmtDefImmCons = db->nDeferredImmCons; |
3939 | } |
3940 | } |
3941 | assert( pOp->p5==0 || pOp->p4type==P4_INT32 ); |
3942 | if( rc==SQLITE_OK |
3943 | && pOp->p5 |
3944 | && (iMeta!=pOp->p3 || pDb->pSchema->iGeneration!=pOp->p4.i) |
3945 | ){ |
3946 | /* |
3947 | ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema |
3948 | ** version is checked to ensure that the schema has not changed since the |
3949 | ** SQL statement was prepared. |
3950 | */ |
3951 | sqlite3DbFree(db, p->zErrMsg); |
3952 | p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed" ); |
3953 | /* If the schema-cookie from the database file matches the cookie |
3954 | ** stored with the in-memory representation of the schema, do |
3955 | ** not reload the schema from the database file. |
3956 | ** |
3957 | ** If virtual-tables are in use, this is not just an optimization. |
3958 | ** Often, v-tables store their data in other SQLite tables, which |
3959 | ** are queried from within xNext() and other v-table methods using |
3960 | ** prepared queries. If such a query is out-of-date, we do not want to |
3961 | ** discard the database schema, as the user code implementing the |
3962 | ** v-table would have to be ready for the sqlite3_vtab structure itself |
3963 | ** to be invalidated whenever sqlite3_step() is called from within |
3964 | ** a v-table method. |
3965 | */ |
3966 | if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){ |
3967 | sqlite3ResetOneSchema(db, pOp->p1); |
3968 | } |
3969 | p->expired = 1; |
3970 | rc = SQLITE_SCHEMA; |
3971 | |
3972 | /* Set changeCntOn to 0 to prevent the value returned by sqlite3_changes() |
3973 | ** from being modified in sqlite3VdbeHalt(). If this statement is |
3974 | ** reprepared, changeCntOn will be set again. */ |
3975 | p->changeCntOn = 0; |
3976 | } |
3977 | if( rc ) goto abort_due_to_error; |
3978 | break; |
3979 | } |
3980 | |
3981 | /* Opcode: ReadCookie P1 P2 P3 * * |
3982 | ** |
3983 | ** Read cookie number P3 from database P1 and write it into register P2. |
3984 | ** P3==1 is the schema version. P3==2 is the database format. |
3985 | ** P3==3 is the recommended pager cache size, and so forth. P1==0 is |
3986 | ** the main database file and P1==1 is the database file used to store |
3987 | ** temporary tables. |
3988 | ** |
3989 | ** There must be a read-lock on the database (either a transaction |
3990 | ** must be started or there must be an open cursor) before |
3991 | ** executing this instruction. |
3992 | */ |
3993 | case OP_ReadCookie: { /* out2 */ |
3994 | int iMeta; |
3995 | int iDb; |
3996 | int iCookie; |
3997 | |
3998 | assert( p->bIsReader ); |
3999 | iDb = pOp->p1; |
4000 | iCookie = pOp->p3; |
4001 | assert( pOp->p3<SQLITE_N_BTREE_META ); |
4002 | assert( iDb>=0 && iDb<db->nDb ); |
4003 | assert( db->aDb[iDb].pBt!=0 ); |
4004 | assert( DbMaskTest(p->btreeMask, iDb) ); |
4005 | |
4006 | sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta); |
4007 | pOut = out2Prerelease(p, pOp); |
4008 | pOut->u.i = iMeta; |
4009 | break; |
4010 | } |
4011 | |
4012 | /* Opcode: SetCookie P1 P2 P3 * P5 |
4013 | ** |
4014 | ** Write the integer value P3 into cookie number P2 of database P1. |
4015 | ** P2==1 is the schema version. P2==2 is the database format. |
4016 | ** P2==3 is the recommended pager cache |
4017 | ** size, and so forth. P1==0 is the main database file and P1==1 is the |
4018 | ** database file used to store temporary tables. |
4019 | ** |
4020 | ** A transaction must be started before executing this opcode. |
4021 | ** |
4022 | ** If P2 is the SCHEMA_VERSION cookie (cookie number 1) then the internal |
4023 | ** schema version is set to P3-P5. The "PRAGMA schema_version=N" statement |
4024 | ** has P5 set to 1, so that the internal schema version will be different |
4025 | ** from the database schema version, resulting in a schema reset. |
4026 | */ |
4027 | case OP_SetCookie: { |
4028 | Db *pDb; |
4029 | |
4030 | sqlite3VdbeIncrWriteCounter(p, 0); |
4031 | assert( pOp->p2<SQLITE_N_BTREE_META ); |
4032 | assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
4033 | assert( DbMaskTest(p->btreeMask, pOp->p1) ); |
4034 | assert( p->readOnly==0 ); |
4035 | pDb = &db->aDb[pOp->p1]; |
4036 | assert( pDb->pBt!=0 ); |
4037 | assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) ); |
4038 | /* See note about index shifting on OP_ReadCookie */ |
4039 | rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3); |
4040 | if( pOp->p2==BTREE_SCHEMA_VERSION ){ |
4041 | /* When the schema cookie changes, record the new cookie internally */ |
4042 | *(u32*)&pDb->pSchema->schema_cookie = *(u32*)&pOp->p3 - pOp->p5; |
4043 | db->mDbFlags |= DBFLAG_SchemaChange; |
4044 | sqlite3FkClearTriggerCache(db, pOp->p1); |
4045 | }else if( pOp->p2==BTREE_FILE_FORMAT ){ |
4046 | /* Record changes in the file format */ |
4047 | pDb->pSchema->file_format = pOp->p3; |
4048 | } |
4049 | if( pOp->p1==1 ){ |
4050 | /* Invalidate all prepared statements whenever the TEMP database |
4051 | ** schema is changed. Ticket #1644 */ |
4052 | sqlite3ExpirePreparedStatements(db, 0); |
4053 | p->expired = 0; |
4054 | } |
4055 | if( rc ) goto abort_due_to_error; |
4056 | break; |
4057 | } |
4058 | |
4059 | /* Opcode: OpenRead P1 P2 P3 P4 P5 |
4060 | ** Synopsis: root=P2 iDb=P3 |
4061 | ** |
4062 | ** Open a read-only cursor for the database table whose root page is |
4063 | ** P2 in a database file. The database file is determined by P3. |
4064 | ** P3==0 means the main database, P3==1 means the database used for |
4065 | ** temporary tables, and P3>1 means used the corresponding attached |
4066 | ** database. Give the new cursor an identifier of P1. The P1 |
4067 | ** values need not be contiguous but all P1 values should be small integers. |
4068 | ** It is an error for P1 to be negative. |
4069 | ** |
4070 | ** Allowed P5 bits: |
4071 | ** <ul> |
4072 | ** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for |
4073 | ** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT |
4074 | ** of OP_SeekLE/OP_IdxLT) |
4075 | ** </ul> |
4076 | ** |
4077 | ** The P4 value may be either an integer (P4_INT32) or a pointer to |
4078 | ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo |
4079 | ** object, then table being opened must be an [index b-tree] where the |
4080 | ** KeyInfo object defines the content and collating |
4081 | ** sequence of that index b-tree. Otherwise, if P4 is an integer |
4082 | ** value, then the table being opened must be a [table b-tree] with a |
4083 | ** number of columns no less than the value of P4. |
4084 | ** |
4085 | ** See also: OpenWrite, ReopenIdx |
4086 | */ |
4087 | /* Opcode: ReopenIdx P1 P2 P3 P4 P5 |
4088 | ** Synopsis: root=P2 iDb=P3 |
4089 | ** |
4090 | ** The ReopenIdx opcode works like OP_OpenRead except that it first |
4091 | ** checks to see if the cursor on P1 is already open on the same |
4092 | ** b-tree and if it is this opcode becomes a no-op. In other words, |
4093 | ** if the cursor is already open, do not reopen it. |
4094 | ** |
4095 | ** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ |
4096 | ** and with P4 being a P4_KEYINFO object. Furthermore, the P3 value must |
4097 | ** be the same as every other ReopenIdx or OpenRead for the same cursor |
4098 | ** number. |
4099 | ** |
4100 | ** Allowed P5 bits: |
4101 | ** <ul> |
4102 | ** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for |
4103 | ** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT |
4104 | ** of OP_SeekLE/OP_IdxLT) |
4105 | ** </ul> |
4106 | ** |
4107 | ** See also: OP_OpenRead, OP_OpenWrite |
4108 | */ |
4109 | /* Opcode: OpenWrite P1 P2 P3 P4 P5 |
4110 | ** Synopsis: root=P2 iDb=P3 |
4111 | ** |
4112 | ** Open a read/write cursor named P1 on the table or index whose root |
4113 | ** page is P2 (or whose root page is held in register P2 if the |
4114 | ** OPFLAG_P2ISREG bit is set in P5 - see below). |
4115 | ** |
4116 | ** The P4 value may be either an integer (P4_INT32) or a pointer to |
4117 | ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo |
4118 | ** object, then table being opened must be an [index b-tree] where the |
4119 | ** KeyInfo object defines the content and collating |
4120 | ** sequence of that index b-tree. Otherwise, if P4 is an integer |
4121 | ** value, then the table being opened must be a [table b-tree] with a |
4122 | ** number of columns no less than the value of P4. |
4123 | ** |
4124 | ** Allowed P5 bits: |
4125 | ** <ul> |
4126 | ** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for |
4127 | ** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT |
4128 | ** of OP_SeekLE/OP_IdxLT) |
4129 | ** <li> <b>0x08 OPFLAG_FORDELETE</b>: This cursor is used only to seek |
4130 | ** and subsequently delete entries in an index btree. This is a |
4131 | ** hint to the storage engine that the storage engine is allowed to |
4132 | ** ignore. The hint is not used by the official SQLite b*tree storage |
4133 | ** engine, but is used by COMDB2. |
4134 | ** <li> <b>0x10 OPFLAG_P2ISREG</b>: Use the content of register P2 |
4135 | ** as the root page, not the value of P2 itself. |
4136 | ** </ul> |
4137 | ** |
4138 | ** This instruction works like OpenRead except that it opens the cursor |
4139 | ** in read/write mode. |
4140 | ** |
4141 | ** See also: OP_OpenRead, OP_ReopenIdx |
4142 | */ |
4143 | case OP_ReopenIdx: { |
4144 | int nField; |
4145 | KeyInfo *pKeyInfo; |
4146 | u32 p2; |
4147 | int iDb; |
4148 | int wrFlag; |
4149 | Btree *pX; |
4150 | VdbeCursor *pCur; |
4151 | Db *pDb; |
4152 | |
4153 | assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); |
4154 | assert( pOp->p4type==P4_KEYINFO ); |
4155 | pCur = p->apCsr[pOp->p1]; |
4156 | if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){ |
4157 | assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */ |
4158 | assert( pCur->eCurType==CURTYPE_BTREE ); |
4159 | sqlite3BtreeClearCursor(pCur->uc.pCursor); |
4160 | goto open_cursor_set_hints; |
4161 | } |
4162 | /* If the cursor is not currently open or is open on a different |
4163 | ** index, then fall through into OP_OpenRead to force a reopen */ |
4164 | case OP_OpenRead: |
4165 | case OP_OpenWrite: |
4166 | |
4167 | assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); |
4168 | assert( p->bIsReader ); |
4169 | assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx |
4170 | || p->readOnly==0 ); |
4171 | |
4172 | if( p->expired==1 ){ |
4173 | rc = SQLITE_ABORT_ROLLBACK; |
4174 | goto abort_due_to_error; |
4175 | } |
4176 | |
4177 | nField = 0; |
4178 | pKeyInfo = 0; |
4179 | p2 = (u32)pOp->p2; |
4180 | iDb = pOp->p3; |
4181 | assert( iDb>=0 && iDb<db->nDb ); |
4182 | assert( DbMaskTest(p->btreeMask, iDb) ); |
4183 | pDb = &db->aDb[iDb]; |
4184 | pX = pDb->pBt; |
4185 | assert( pX!=0 ); |
4186 | if( pOp->opcode==OP_OpenWrite ){ |
4187 | assert( OPFLAG_FORDELETE==BTREE_FORDELETE ); |
4188 | wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE); |
4189 | assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
4190 | if( pDb->pSchema->file_format < p->minWriteFileFormat ){ |
4191 | p->minWriteFileFormat = pDb->pSchema->file_format; |
4192 | } |
4193 | }else{ |
4194 | wrFlag = 0; |
4195 | } |
4196 | if( pOp->p5 & OPFLAG_P2ISREG ){ |
4197 | assert( p2>0 ); |
4198 | assert( p2<=(u32)(p->nMem+1 - p->nCursor) ); |
4199 | assert( pOp->opcode==OP_OpenWrite ); |
4200 | pIn2 = &aMem[p2]; |
4201 | assert( memIsValid(pIn2) ); |
4202 | assert( (pIn2->flags & MEM_Int)!=0 ); |
4203 | sqlite3VdbeMemIntegerify(pIn2); |
4204 | p2 = (int)pIn2->u.i; |
4205 | /* The p2 value always comes from a prior OP_CreateBtree opcode and |
4206 | ** that opcode will always set the p2 value to 2 or more or else fail. |
4207 | ** If there were a failure, the prepared statement would have halted |
4208 | ** before reaching this instruction. */ |
4209 | assert( p2>=2 ); |
4210 | } |
4211 | if( pOp->p4type==P4_KEYINFO ){ |
4212 | pKeyInfo = pOp->p4.pKeyInfo; |
4213 | assert( pKeyInfo->enc==ENC(db) ); |
4214 | assert( pKeyInfo->db==db ); |
4215 | nField = pKeyInfo->nAllField; |
4216 | }else if( pOp->p4type==P4_INT32 ){ |
4217 | nField = pOp->p4.i; |
4218 | } |
4219 | assert( pOp->p1>=0 ); |
4220 | assert( nField>=0 ); |
4221 | testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */ |
4222 | pCur = allocateCursor(p, pOp->p1, nField, CURTYPE_BTREE); |
4223 | if( pCur==0 ) goto no_mem; |
4224 | pCur->iDb = iDb; |
4225 | pCur->nullRow = 1; |
4226 | pCur->isOrdered = 1; |
4227 | pCur->pgnoRoot = p2; |
4228 | #ifdef SQLITE_DEBUG |
4229 | pCur->wrFlag = wrFlag; |
4230 | #endif |
4231 | rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor); |
4232 | pCur->pKeyInfo = pKeyInfo; |
4233 | /* Set the VdbeCursor.isTable variable. Previous versions of |
4234 | ** SQLite used to check if the root-page flags were sane at this point |
4235 | ** and report database corruption if they were not, but this check has |
4236 | ** since moved into the btree layer. */ |
4237 | pCur->isTable = pOp->p4type!=P4_KEYINFO; |
4238 | |
4239 | open_cursor_set_hints: |
4240 | assert( OPFLAG_BULKCSR==BTREE_BULKLOAD ); |
4241 | assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ ); |
4242 | testcase( pOp->p5 & OPFLAG_BULKCSR ); |
4243 | testcase( pOp->p2 & OPFLAG_SEEKEQ ); |
4244 | sqlite3BtreeCursorHintFlags(pCur->uc.pCursor, |
4245 | (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ))); |
4246 | if( rc ) goto abort_due_to_error; |
4247 | break; |
4248 | } |
4249 | |
4250 | /* Opcode: OpenDup P1 P2 * * * |
4251 | ** |
4252 | ** Open a new cursor P1 that points to the same ephemeral table as |
4253 | ** cursor P2. The P2 cursor must have been opened by a prior OP_OpenEphemeral |
4254 | ** opcode. Only ephemeral cursors may be duplicated. |
4255 | ** |
4256 | ** Duplicate ephemeral cursors are used for self-joins of materialized views. |
4257 | */ |
4258 | case OP_OpenDup: { |
4259 | VdbeCursor *pOrig; /* The original cursor to be duplicated */ |
4260 | VdbeCursor *pCx; /* The new cursor */ |
4261 | |
4262 | pOrig = p->apCsr[pOp->p2]; |
4263 | assert( pOrig ); |
4264 | assert( pOrig->isEphemeral ); /* Only ephemeral cursors can be duplicated */ |
4265 | |
4266 | pCx = allocateCursor(p, pOp->p1, pOrig->nField, CURTYPE_BTREE); |
4267 | if( pCx==0 ) goto no_mem; |
4268 | pCx->nullRow = 1; |
4269 | pCx->isEphemeral = 1; |
4270 | pCx->pKeyInfo = pOrig->pKeyInfo; |
4271 | pCx->isTable = pOrig->isTable; |
4272 | pCx->pgnoRoot = pOrig->pgnoRoot; |
4273 | pCx->isOrdered = pOrig->isOrdered; |
4274 | pCx->ub.pBtx = pOrig->ub.pBtx; |
4275 | pCx->noReuse = 1; |
4276 | pOrig->noReuse = 1; |
4277 | rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR, |
4278 | pCx->pKeyInfo, pCx->uc.pCursor); |
4279 | /* The sqlite3BtreeCursor() routine can only fail for the first cursor |
4280 | ** opened for a database. Since there is already an open cursor when this |
4281 | ** opcode is run, the sqlite3BtreeCursor() cannot fail */ |
4282 | assert( rc==SQLITE_OK ); |
4283 | break; |
4284 | } |
4285 | |
4286 | |
4287 | /* Opcode: OpenEphemeral P1 P2 P3 P4 P5 |
4288 | ** Synopsis: nColumn=P2 |
4289 | ** |
4290 | ** Open a new cursor P1 to a transient table. |
4291 | ** The cursor is always opened read/write even if |
4292 | ** the main database is read-only. The ephemeral |
4293 | ** table is deleted automatically when the cursor is closed. |
4294 | ** |
4295 | ** If the cursor P1 is already opened on an ephemeral table, the table |
4296 | ** is cleared (all content is erased). |
4297 | ** |
4298 | ** P2 is the number of columns in the ephemeral table. |
4299 | ** The cursor points to a BTree table if P4==0 and to a BTree index |
4300 | ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure |
4301 | ** that defines the format of keys in the index. |
4302 | ** |
4303 | ** The P5 parameter can be a mask of the BTREE_* flags defined |
4304 | ** in btree.h. These flags control aspects of the operation of |
4305 | ** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are |
4306 | ** added automatically. |
4307 | ** |
4308 | ** If P3 is positive, then reg[P3] is modified slightly so that it |
4309 | ** can be used as zero-length data for OP_Insert. This is an optimization |
4310 | ** that avoids an extra OP_Blob opcode to initialize that register. |
4311 | */ |
4312 | /* Opcode: OpenAutoindex P1 P2 * P4 * |
4313 | ** Synopsis: nColumn=P2 |
4314 | ** |
4315 | ** This opcode works the same as OP_OpenEphemeral. It has a |
4316 | ** different name to distinguish its use. Tables created using |
4317 | ** by this opcode will be used for automatically created transient |
4318 | ** indices in joins. |
4319 | */ |
4320 | case OP_OpenAutoindex: |
4321 | case OP_OpenEphemeral: { |
4322 | VdbeCursor *pCx; |
4323 | KeyInfo *pKeyInfo; |
4324 | |
4325 | static const int vfsFlags = |
4326 | SQLITE_OPEN_READWRITE | |
4327 | SQLITE_OPEN_CREATE | |
4328 | SQLITE_OPEN_EXCLUSIVE | |
4329 | SQLITE_OPEN_DELETEONCLOSE | |
4330 | SQLITE_OPEN_TRANSIENT_DB; |
4331 | assert( pOp->p1>=0 ); |
4332 | assert( pOp->p2>=0 ); |
4333 | if( pOp->p3>0 ){ |
4334 | /* Make register reg[P3] into a value that can be used as the data |
4335 | ** form sqlite3BtreeInsert() where the length of the data is zero. */ |
4336 | assert( pOp->p2==0 ); /* Only used when number of columns is zero */ |
4337 | assert( pOp->opcode==OP_OpenEphemeral ); |
4338 | assert( aMem[pOp->p3].flags & MEM_Null ); |
4339 | aMem[pOp->p3].n = 0; |
4340 | aMem[pOp->p3].z = "" ; |
4341 | } |
4342 | pCx = p->apCsr[pOp->p1]; |
4343 | if( pCx && !pCx->noReuse && ALWAYS(pOp->p2<=pCx->nField) ){ |
4344 | /* If the ephermeral table is already open and has no duplicates from |
4345 | ** OP_OpenDup, then erase all existing content so that the table is |
4346 | ** empty again, rather than creating a new table. */ |
4347 | assert( pCx->isEphemeral ); |
4348 | pCx->seqCount = 0; |
4349 | pCx->cacheStatus = CACHE_STALE; |
4350 | rc = sqlite3BtreeClearTable(pCx->ub.pBtx, pCx->pgnoRoot, 0); |
4351 | }else{ |
4352 | pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_BTREE); |
4353 | if( pCx==0 ) goto no_mem; |
4354 | pCx->isEphemeral = 1; |
4355 | rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->ub.pBtx, |
4356 | BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, |
4357 | vfsFlags); |
4358 | if( rc==SQLITE_OK ){ |
4359 | rc = sqlite3BtreeBeginTrans(pCx->ub.pBtx, 1, 0); |
4360 | if( rc==SQLITE_OK ){ |
4361 | /* If a transient index is required, create it by calling |
4362 | ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before |
4363 | ** opening it. If a transient table is required, just use the |
4364 | ** automatically created table with root-page 1 (an BLOB_INTKEY table). |
4365 | */ |
4366 | if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){ |
4367 | assert( pOp->p4type==P4_KEYINFO ); |
4368 | rc = sqlite3BtreeCreateTable(pCx->ub.pBtx, &pCx->pgnoRoot, |
4369 | BTREE_BLOBKEY | pOp->p5); |
4370 | if( rc==SQLITE_OK ){ |
4371 | assert( pCx->pgnoRoot==SCHEMA_ROOT+1 ); |
4372 | assert( pKeyInfo->db==db ); |
4373 | assert( pKeyInfo->enc==ENC(db) ); |
4374 | rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR, |
4375 | pKeyInfo, pCx->uc.pCursor); |
4376 | } |
4377 | pCx->isTable = 0; |
4378 | }else{ |
4379 | pCx->pgnoRoot = SCHEMA_ROOT; |
4380 | rc = sqlite3BtreeCursor(pCx->ub.pBtx, SCHEMA_ROOT, BTREE_WRCSR, |
4381 | 0, pCx->uc.pCursor); |
4382 | pCx->isTable = 1; |
4383 | } |
4384 | } |
4385 | pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED); |
4386 | if( rc ){ |
4387 | sqlite3BtreeClose(pCx->ub.pBtx); |
4388 | } |
4389 | } |
4390 | } |
4391 | if( rc ) goto abort_due_to_error; |
4392 | pCx->nullRow = 1; |
4393 | break; |
4394 | } |
4395 | |
4396 | /* Opcode: SorterOpen P1 P2 P3 P4 * |
4397 | ** |
4398 | ** This opcode works like OP_OpenEphemeral except that it opens |
4399 | ** a transient index that is specifically designed to sort large |
4400 | ** tables using an external merge-sort algorithm. |
4401 | ** |
4402 | ** If argument P3 is non-zero, then it indicates that the sorter may |
4403 | ** assume that a stable sort considering the first P3 fields of each |
4404 | ** key is sufficient to produce the required results. |
4405 | */ |
4406 | case OP_SorterOpen: { |
4407 | VdbeCursor *pCx; |
4408 | |
4409 | assert( pOp->p1>=0 ); |
4410 | assert( pOp->p2>=0 ); |
4411 | pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_SORTER); |
4412 | if( pCx==0 ) goto no_mem; |
4413 | pCx->pKeyInfo = pOp->p4.pKeyInfo; |
4414 | assert( pCx->pKeyInfo->db==db ); |
4415 | assert( pCx->pKeyInfo->enc==ENC(db) ); |
4416 | rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx); |
4417 | if( rc ) goto abort_due_to_error; |
4418 | break; |
4419 | } |
4420 | |
4421 | /* Opcode: SequenceTest P1 P2 * * * |
4422 | ** Synopsis: if( cursor[P1].ctr++ ) pc = P2 |
4423 | ** |
4424 | ** P1 is a sorter cursor. If the sequence counter is currently zero, jump |
4425 | ** to P2. Regardless of whether or not the jump is taken, increment the |
4426 | ** the sequence value. |
4427 | */ |
4428 | case OP_SequenceTest: { |
4429 | VdbeCursor *pC; |
4430 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
4431 | pC = p->apCsr[pOp->p1]; |
4432 | assert( isSorter(pC) ); |
4433 | if( (pC->seqCount++)==0 ){ |
4434 | goto jump_to_p2; |
4435 | } |
4436 | break; |
4437 | } |
4438 | |
4439 | /* Opcode: OpenPseudo P1 P2 P3 * * |
4440 | ** Synopsis: P3 columns in r[P2] |
4441 | ** |
4442 | ** Open a new cursor that points to a fake table that contains a single |
4443 | ** row of data. The content of that one row is the content of memory |
4444 | ** register P2. In other words, cursor P1 becomes an alias for the |
4445 | ** MEM_Blob content contained in register P2. |
4446 | ** |
4447 | ** A pseudo-table created by this opcode is used to hold a single |
4448 | ** row output from the sorter so that the row can be decomposed into |
4449 | ** individual columns using the OP_Column opcode. The OP_Column opcode |
4450 | ** is the only cursor opcode that works with a pseudo-table. |
4451 | ** |
4452 | ** P3 is the number of fields in the records that will be stored by |
4453 | ** the pseudo-table. |
4454 | */ |
4455 | case OP_OpenPseudo: { |
4456 | VdbeCursor *pCx; |
4457 | |
4458 | assert( pOp->p1>=0 ); |
4459 | assert( pOp->p3>=0 ); |
4460 | pCx = allocateCursor(p, pOp->p1, pOp->p3, CURTYPE_PSEUDO); |
4461 | if( pCx==0 ) goto no_mem; |
4462 | pCx->nullRow = 1; |
4463 | pCx->seekResult = pOp->p2; |
4464 | pCx->isTable = 1; |
4465 | /* Give this pseudo-cursor a fake BtCursor pointer so that pCx |
4466 | ** can be safely passed to sqlite3VdbeCursorMoveto(). This avoids a test |
4467 | ** for pCx->eCurType==CURTYPE_BTREE inside of sqlite3VdbeCursorMoveto() |
4468 | ** which is a performance optimization */ |
4469 | pCx->uc.pCursor = sqlite3BtreeFakeValidCursor(); |
4470 | assert( pOp->p5==0 ); |
4471 | break; |
4472 | } |
4473 | |
4474 | /* Opcode: Close P1 * * * * |
4475 | ** |
4476 | ** Close a cursor previously opened as P1. If P1 is not |
4477 | ** currently open, this instruction is a no-op. |
4478 | */ |
4479 | case OP_Close: { |
4480 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
4481 | sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]); |
4482 | p->apCsr[pOp->p1] = 0; |
4483 | break; |
4484 | } |
4485 | |
4486 | #ifdef SQLITE_ENABLE_COLUMN_USED_MASK |
4487 | /* Opcode: ColumnsUsed P1 * * P4 * |
4488 | ** |
4489 | ** This opcode (which only exists if SQLite was compiled with |
4490 | ** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the |
4491 | ** table or index for cursor P1 are used. P4 is a 64-bit integer |
4492 | ** (P4_INT64) in which the first 63 bits are one for each of the |
4493 | ** first 63 columns of the table or index that are actually used |
4494 | ** by the cursor. The high-order bit is set if any column after |
4495 | ** the 64th is used. |
4496 | */ |
4497 | case OP_ColumnsUsed: { |
4498 | VdbeCursor *pC; |
4499 | pC = p->apCsr[pOp->p1]; |
4500 | assert( pC->eCurType==CURTYPE_BTREE ); |
4501 | pC->maskUsed = *(u64*)pOp->p4.pI64; |
4502 | break; |
4503 | } |
4504 | #endif |
4505 | |
4506 | /* Opcode: SeekGE P1 P2 P3 P4 * |
4507 | ** Synopsis: key=r[P3@P4] |
4508 | ** |
4509 | ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), |
4510 | ** use the value in register P3 as the key. If cursor P1 refers |
4511 | ** to an SQL index, then P3 is the first in an array of P4 registers |
4512 | ** that are used as an unpacked index key. |
4513 | ** |
4514 | ** Reposition cursor P1 so that it points to the smallest entry that |
4515 | ** is greater than or equal to the key value. If there are no records |
4516 | ** greater than or equal to the key and P2 is not zero, then jump to P2. |
4517 | ** |
4518 | ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this |
4519 | ** opcode will either land on a record that exactly matches the key, or |
4520 | ** else it will cause a jump to P2. When the cursor is OPFLAG_SEEKEQ, |
4521 | ** this opcode must be followed by an IdxLE opcode with the same arguments. |
4522 | ** The IdxGT opcode will be skipped if this opcode succeeds, but the |
4523 | ** IdxGT opcode will be used on subsequent loop iterations. The |
4524 | ** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this |
4525 | ** is an equality search. |
4526 | ** |
4527 | ** This opcode leaves the cursor configured to move in forward order, |
4528 | ** from the beginning toward the end. In other words, the cursor is |
4529 | ** configured to use Next, not Prev. |
4530 | ** |
4531 | ** See also: Found, NotFound, SeekLt, SeekGt, SeekLe |
4532 | */ |
4533 | /* Opcode: SeekGT P1 P2 P3 P4 * |
4534 | ** Synopsis: key=r[P3@P4] |
4535 | ** |
4536 | ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), |
4537 | ** use the value in register P3 as a key. If cursor P1 refers |
4538 | ** to an SQL index, then P3 is the first in an array of P4 registers |
4539 | ** that are used as an unpacked index key. |
4540 | ** |
4541 | ** Reposition cursor P1 so that it points to the smallest entry that |
4542 | ** is greater than the key value. If there are no records greater than |
4543 | ** the key and P2 is not zero, then jump to P2. |
4544 | ** |
4545 | ** This opcode leaves the cursor configured to move in forward order, |
4546 | ** from the beginning toward the end. In other words, the cursor is |
4547 | ** configured to use Next, not Prev. |
4548 | ** |
4549 | ** See also: Found, NotFound, SeekLt, SeekGe, SeekLe |
4550 | */ |
4551 | /* Opcode: SeekLT P1 P2 P3 P4 * |
4552 | ** Synopsis: key=r[P3@P4] |
4553 | ** |
4554 | ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), |
4555 | ** use the value in register P3 as a key. If cursor P1 refers |
4556 | ** to an SQL index, then P3 is the first in an array of P4 registers |
4557 | ** that are used as an unpacked index key. |
4558 | ** |
4559 | ** Reposition cursor P1 so that it points to the largest entry that |
4560 | ** is less than the key value. If there are no records less than |
4561 | ** the key and P2 is not zero, then jump to P2. |
4562 | ** |
4563 | ** This opcode leaves the cursor configured to move in reverse order, |
4564 | ** from the end toward the beginning. In other words, the cursor is |
4565 | ** configured to use Prev, not Next. |
4566 | ** |
4567 | ** See also: Found, NotFound, SeekGt, SeekGe, SeekLe |
4568 | */ |
4569 | /* Opcode: SeekLE P1 P2 P3 P4 * |
4570 | ** Synopsis: key=r[P3@P4] |
4571 | ** |
4572 | ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), |
4573 | ** use the value in register P3 as a key. If cursor P1 refers |
4574 | ** to an SQL index, then P3 is the first in an array of P4 registers |
4575 | ** that are used as an unpacked index key. |
4576 | ** |
4577 | ** Reposition cursor P1 so that it points to the largest entry that |
4578 | ** is less than or equal to the key value. If there are no records |
4579 | ** less than or equal to the key and P2 is not zero, then jump to P2. |
4580 | ** |
4581 | ** This opcode leaves the cursor configured to move in reverse order, |
4582 | ** from the end toward the beginning. In other words, the cursor is |
4583 | ** configured to use Prev, not Next. |
4584 | ** |
4585 | ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this |
4586 | ** opcode will either land on a record that exactly matches the key, or |
4587 | ** else it will cause a jump to P2. When the cursor is OPFLAG_SEEKEQ, |
4588 | ** this opcode must be followed by an IdxLE opcode with the same arguments. |
4589 | ** The IdxGE opcode will be skipped if this opcode succeeds, but the |
4590 | ** IdxGE opcode will be used on subsequent loop iterations. The |
4591 | ** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this |
4592 | ** is an equality search. |
4593 | ** |
4594 | ** See also: Found, NotFound, SeekGt, SeekGe, SeekLt |
4595 | */ |
4596 | case OP_SeekLT: /* jump, in3, group */ |
4597 | case OP_SeekLE: /* jump, in3, group */ |
4598 | case OP_SeekGE: /* jump, in3, group */ |
4599 | case OP_SeekGT: { /* jump, in3, group */ |
4600 | int res; /* Comparison result */ |
4601 | int oc; /* Opcode */ |
4602 | VdbeCursor *pC; /* The cursor to seek */ |
4603 | UnpackedRecord r; /* The key to seek for */ |
4604 | int nField; /* Number of columns or fields in the key */ |
4605 | i64 iKey; /* The rowid we are to seek to */ |
4606 | int eqOnly; /* Only interested in == results */ |
4607 | |
4608 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
4609 | assert( pOp->p2!=0 ); |
4610 | pC = p->apCsr[pOp->p1]; |
4611 | assert( pC!=0 ); |
4612 | assert( pC->eCurType==CURTYPE_BTREE ); |
4613 | assert( OP_SeekLE == OP_SeekLT+1 ); |
4614 | assert( OP_SeekGE == OP_SeekLT+2 ); |
4615 | assert( OP_SeekGT == OP_SeekLT+3 ); |
4616 | assert( pC->isOrdered ); |
4617 | assert( pC->uc.pCursor!=0 ); |
4618 | oc = pOp->opcode; |
4619 | eqOnly = 0; |
4620 | pC->nullRow = 0; |
4621 | #ifdef SQLITE_DEBUG |
4622 | pC->seekOp = pOp->opcode; |
4623 | #endif |
4624 | |
4625 | pC->deferredMoveto = 0; |
4626 | pC->cacheStatus = CACHE_STALE; |
4627 | if( pC->isTable ){ |
4628 | u16 flags3, newType; |
4629 | /* The OPFLAG_SEEKEQ/BTREE_SEEK_EQ flag is only set on index cursors */ |
4630 | assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0 |
4631 | || CORRUPT_DB ); |
4632 | |
4633 | /* The input value in P3 might be of any type: integer, real, string, |
4634 | ** blob, or NULL. But it needs to be an integer before we can do |
4635 | ** the seek, so convert it. */ |
4636 | pIn3 = &aMem[pOp->p3]; |
4637 | flags3 = pIn3->flags; |
4638 | if( (flags3 & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Str))==MEM_Str ){ |
4639 | applyNumericAffinity(pIn3, 0); |
4640 | } |
4641 | iKey = sqlite3VdbeIntValue(pIn3); /* Get the integer key value */ |
4642 | newType = pIn3->flags; /* Record the type after applying numeric affinity */ |
4643 | pIn3->flags = flags3; /* But convert the type back to its original */ |
4644 | |
4645 | /* If the P3 value could not be converted into an integer without |
4646 | ** loss of information, then special processing is required... */ |
4647 | if( (newType & (MEM_Int|MEM_IntReal))==0 ){ |
4648 | int c; |
4649 | if( (newType & MEM_Real)==0 ){ |
4650 | if( (newType & MEM_Null) || oc>=OP_SeekGE ){ |
4651 | VdbeBranchTaken(1,2); |
4652 | goto jump_to_p2; |
4653 | }else{ |
4654 | rc = sqlite3BtreeLast(pC->uc.pCursor, &res); |
4655 | if( rc!=SQLITE_OK ) goto abort_due_to_error; |
4656 | goto seek_not_found; |
4657 | } |
4658 | } |
4659 | c = sqlite3IntFloatCompare(iKey, pIn3->u.r); |
4660 | |
4661 | /* If the approximation iKey is larger than the actual real search |
4662 | ** term, substitute >= for > and < for <=. e.g. if the search term |
4663 | ** is 4.9 and the integer approximation 5: |
4664 | ** |
4665 | ** (x > 4.9) -> (x >= 5) |
4666 | ** (x <= 4.9) -> (x < 5) |
4667 | */ |
4668 | if( c>0 ){ |
4669 | assert( OP_SeekGE==(OP_SeekGT-1) ); |
4670 | assert( OP_SeekLT==(OP_SeekLE-1) ); |
4671 | assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) ); |
4672 | if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--; |
4673 | } |
4674 | |
4675 | /* If the approximation iKey is smaller than the actual real search |
4676 | ** term, substitute <= for < and > for >=. */ |
4677 | else if( c<0 ){ |
4678 | assert( OP_SeekLE==(OP_SeekLT+1) ); |
4679 | assert( OP_SeekGT==(OP_SeekGE+1) ); |
4680 | assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) ); |
4681 | if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++; |
4682 | } |
4683 | } |
4684 | rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)iKey, 0, &res); |
4685 | pC->movetoTarget = iKey; /* Used by OP_Delete */ |
4686 | if( rc!=SQLITE_OK ){ |
4687 | goto abort_due_to_error; |
4688 | } |
4689 | }else{ |
4690 | /* For a cursor with the OPFLAG_SEEKEQ/BTREE_SEEK_EQ hint, only the |
4691 | ** OP_SeekGE and OP_SeekLE opcodes are allowed, and these must be |
4692 | ** immediately followed by an OP_IdxGT or OP_IdxLT opcode, respectively, |
4693 | ** with the same key. |
4694 | */ |
4695 | if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){ |
4696 | eqOnly = 1; |
4697 | assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE ); |
4698 | assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT ); |
4699 | assert( pOp->opcode==OP_SeekGE || pOp[1].opcode==OP_IdxLT ); |
4700 | assert( pOp->opcode==OP_SeekLE || pOp[1].opcode==OP_IdxGT ); |
4701 | assert( pOp[1].p1==pOp[0].p1 ); |
4702 | assert( pOp[1].p2==pOp[0].p2 ); |
4703 | assert( pOp[1].p3==pOp[0].p3 ); |
4704 | assert( pOp[1].p4.i==pOp[0].p4.i ); |
4705 | } |
4706 | |
4707 | nField = pOp->p4.i; |
4708 | assert( pOp->p4type==P4_INT32 ); |
4709 | assert( nField>0 ); |
4710 | r.pKeyInfo = pC->pKeyInfo; |
4711 | r.nField = (u16)nField; |
4712 | |
4713 | /* The next line of code computes as follows, only faster: |
4714 | ** if( oc==OP_SeekGT || oc==OP_SeekLE ){ |
4715 | ** r.default_rc = -1; |
4716 | ** }else{ |
4717 | ** r.default_rc = +1; |
4718 | ** } |
4719 | */ |
4720 | r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1); |
4721 | assert( oc!=OP_SeekGT || r.default_rc==-1 ); |
4722 | assert( oc!=OP_SeekLE || r.default_rc==-1 ); |
4723 | assert( oc!=OP_SeekGE || r.default_rc==+1 ); |
4724 | assert( oc!=OP_SeekLT || r.default_rc==+1 ); |
4725 | |
4726 | r.aMem = &aMem[pOp->p3]; |
4727 | #ifdef SQLITE_DEBUG |
4728 | { |
4729 | int i; |
4730 | for(i=0; i<r.nField; i++){ |
4731 | assert( memIsValid(&r.aMem[i]) ); |
4732 | if( i>0 ) REGISTER_TRACE(pOp->p3+i, &r.aMem[i]); |
4733 | } |
4734 | } |
4735 | #endif |
4736 | r.eqSeen = 0; |
4737 | rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &res); |
4738 | if( rc!=SQLITE_OK ){ |
4739 | goto abort_due_to_error; |
4740 | } |
4741 | if( eqOnly && r.eqSeen==0 ){ |
4742 | assert( res!=0 ); |
4743 | goto seek_not_found; |
4744 | } |
4745 | } |
4746 | #ifdef SQLITE_TEST |
4747 | sqlite3_search_count++; |
4748 | #endif |
4749 | if( oc>=OP_SeekGE ){ assert( oc==OP_SeekGE || oc==OP_SeekGT ); |
4750 | if( res<0 || (res==0 && oc==OP_SeekGT) ){ |
4751 | res = 0; |
4752 | rc = sqlite3BtreeNext(pC->uc.pCursor, 0); |
4753 | if( rc!=SQLITE_OK ){ |
4754 | if( rc==SQLITE_DONE ){ |
4755 | rc = SQLITE_OK; |
4756 | res = 1; |
4757 | }else{ |
4758 | goto abort_due_to_error; |
4759 | } |
4760 | } |
4761 | }else{ |
4762 | res = 0; |
4763 | } |
4764 | }else{ |
4765 | assert( oc==OP_SeekLT || oc==OP_SeekLE ); |
4766 | if( res>0 || (res==0 && oc==OP_SeekLT) ){ |
4767 | res = 0; |
4768 | rc = sqlite3BtreePrevious(pC->uc.pCursor, 0); |
4769 | if( rc!=SQLITE_OK ){ |
4770 | if( rc==SQLITE_DONE ){ |
4771 | rc = SQLITE_OK; |
4772 | res = 1; |
4773 | }else{ |
4774 | goto abort_due_to_error; |
4775 | } |
4776 | } |
4777 | }else{ |
4778 | /* res might be negative because the table is empty. Check to |
4779 | ** see if this is the case. |
4780 | */ |
4781 | res = sqlite3BtreeEof(pC->uc.pCursor); |
4782 | } |
4783 | } |
4784 | seek_not_found: |
4785 | assert( pOp->p2>0 ); |
4786 | VdbeBranchTaken(res!=0,2); |
4787 | if( res ){ |
4788 | goto jump_to_p2; |
4789 | }else if( eqOnly ){ |
4790 | assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT ); |
4791 | pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */ |
4792 | } |
4793 | break; |
4794 | } |
4795 | |
4796 | |
4797 | /* Opcode: SeekScan P1 P2 * * P5 |
4798 | ** Synopsis: Scan-ahead up to P1 rows |
4799 | ** |
4800 | ** This opcode is a prefix opcode to OP_SeekGE. In other words, this |
4801 | ** opcode must be immediately followed by OP_SeekGE. This constraint is |
4802 | ** checked by assert() statements. |
4803 | ** |
4804 | ** This opcode uses the P1 through P4 operands of the subsequent |
4805 | ** OP_SeekGE. In the text that follows, the operands of the subsequent |
4806 | ** OP_SeekGE opcode are denoted as SeekOP.P1 through SeekOP.P4. Only |
4807 | ** the P1, P2 and P5 operands of this opcode are also used, and are called |
4808 | ** This.P1, This.P2 and This.P5. |
4809 | ** |
4810 | ** This opcode helps to optimize IN operators on a multi-column index |
4811 | ** where the IN operator is on the later terms of the index by avoiding |
4812 | ** unnecessary seeks on the btree, substituting steps to the next row |
4813 | ** of the b-tree instead. A correct answer is obtained if this opcode |
4814 | ** is omitted or is a no-op. |
4815 | ** |
4816 | ** The SeekGE.P3 and SeekGE.P4 operands identify an unpacked key which |
4817 | ** is the desired entry that we want the cursor SeekGE.P1 to be pointing |
4818 | ** to. Call this SeekGE.P3/P4 row the "target". |
4819 | ** |
4820 | ** If the SeekGE.P1 cursor is not currently pointing to a valid row, |
4821 | ** then this opcode is a no-op and control passes through into the OP_SeekGE. |
4822 | ** |
4823 | ** If the SeekGE.P1 cursor is pointing to a valid row, then that row |
4824 | ** might be the target row, or it might be near and slightly before the |
4825 | ** target row, or it might be after the target row. If the cursor is |
4826 | ** currently before the target row, then this opcode attempts to position |
4827 | ** the cursor on or after the target row by invoking sqlite3BtreeStep() |
4828 | ** on the cursor between 1 and This.P1 times. |
4829 | ** |
4830 | ** The This.P5 parameter is a flag that indicates what to do if the |
4831 | ** cursor ends up pointing at a valid row that is past the target |
4832 | ** row. If This.P5 is false (0) then a jump is made to SeekGE.P2. If |
4833 | ** This.P5 is true (non-zero) then a jump is made to This.P2. The P5==0 |
4834 | ** case occurs when there are no inequality constraints to the right of |
4835 | ** the IN constraing. The jump to SeekGE.P2 ends the loop. The P5!=0 case |
4836 | ** occurs when there are inequality constraints to the right of the IN |
4837 | ** operator. In that case, the This.P2 will point either directly to or |
4838 | ** to setup code prior to the OP_IdxGT or OP_IdxGE opcode that checks for |
4839 | ** loop terminate. |
4840 | ** |
4841 | ** Possible outcomes from this opcode:<ol> |
4842 | ** |
4843 | ** <li> If the cursor is initally not pointed to any valid row, then |
4844 | ** fall through into the subsequent OP_SeekGE opcode. |
4845 | ** |
4846 | ** <li> If the cursor is left pointing to a row that is before the target |
4847 | ** row, even after making as many as This.P1 calls to |
4848 | ** sqlite3BtreeNext(), then also fall through into OP_SeekGE. |
4849 | ** |
4850 | ** <li> If the cursor is left pointing at the target row, either because it |
4851 | ** was at the target row to begin with or because one or more |
4852 | ** sqlite3BtreeNext() calls moved the cursor to the target row, |
4853 | ** then jump to This.P2.., |
4854 | ** |
4855 | ** <li> If the cursor started out before the target row and a call to |
4856 | ** to sqlite3BtreeNext() moved the cursor off the end of the index |
4857 | ** (indicating that the target row definitely does not exist in the |
4858 | ** btree) then jump to SeekGE.P2, ending the loop. |
4859 | ** |
4860 | ** <li> If the cursor ends up on a valid row that is past the target row |
4861 | ** (indicating that the target row does not exist in the btree) then |
4862 | ** jump to SeekOP.P2 if This.P5==0 or to This.P2 if This.P5>0. |
4863 | ** </ol> |
4864 | */ |
4865 | case OP_SeekScan: { |
4866 | VdbeCursor *pC; |
4867 | int res; |
4868 | int nStep; |
4869 | UnpackedRecord r; |
4870 | |
4871 | assert( pOp[1].opcode==OP_SeekGE ); |
4872 | |
4873 | /* If pOp->p5 is clear, then pOp->p2 points to the first instruction past the |
4874 | ** OP_IdxGT that follows the OP_SeekGE. Otherwise, it points to the first |
4875 | ** opcode past the OP_SeekGE itself. */ |
4876 | assert( pOp->p2>=(int)(pOp-aOp)+2 ); |
4877 | #ifdef SQLITE_DEBUG |
4878 | if( pOp->p5==0 ){ |
4879 | /* There are no inequality constraints following the IN constraint. */ |
4880 | assert( pOp[1].p1==aOp[pOp->p2-1].p1 ); |
4881 | assert( pOp[1].p2==aOp[pOp->p2-1].p2 ); |
4882 | assert( pOp[1].p3==aOp[pOp->p2-1].p3 ); |
4883 | assert( aOp[pOp->p2-1].opcode==OP_IdxGT |
4884 | || aOp[pOp->p2-1].opcode==OP_IdxGE ); |
4885 | testcase( aOp[pOp->p2-1].opcode==OP_IdxGE ); |
4886 | }else{ |
4887 | /* There are inequality constraints. */ |
4888 | assert( pOp->p2==(int)(pOp-aOp)+2 ); |
4889 | assert( aOp[pOp->p2-1].opcode==OP_SeekGE ); |
4890 | } |
4891 | #endif |
4892 | |
4893 | assert( pOp->p1>0 ); |
4894 | pC = p->apCsr[pOp[1].p1]; |
4895 | assert( pC!=0 ); |
4896 | assert( pC->eCurType==CURTYPE_BTREE ); |
4897 | assert( !pC->isTable ); |
4898 | if( !sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) ){ |
4899 | #ifdef SQLITE_DEBUG |
4900 | if( db->flags&SQLITE_VdbeTrace ){ |
4901 | printf("... cursor not valid - fall through\n" ); |
4902 | } |
4903 | #endif |
4904 | break; |
4905 | } |
4906 | nStep = pOp->p1; |
4907 | assert( nStep>=1 ); |
4908 | r.pKeyInfo = pC->pKeyInfo; |
4909 | r.nField = (u16)pOp[1].p4.i; |
4910 | r.default_rc = 0; |
4911 | r.aMem = &aMem[pOp[1].p3]; |
4912 | #ifdef SQLITE_DEBUG |
4913 | { |
4914 | int i; |
4915 | for(i=0; i<r.nField; i++){ |
4916 | assert( memIsValid(&r.aMem[i]) ); |
4917 | REGISTER_TRACE(pOp[1].p3+i, &aMem[pOp[1].p3+i]); |
4918 | } |
4919 | } |
4920 | #endif |
4921 | res = 0; /* Not needed. Only used to silence a warning. */ |
4922 | while(1){ |
4923 | rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res); |
4924 | if( rc ) goto abort_due_to_error; |
4925 | if( res>0 && pOp->p5==0 ){ |
4926 | seekscan_search_fail: |
4927 | /* Jump to SeekGE.P2, ending the loop */ |
4928 | #ifdef SQLITE_DEBUG |
4929 | if( db->flags&SQLITE_VdbeTrace ){ |
4930 | printf("... %d steps and then skip\n" , pOp->p1 - nStep); |
4931 | } |
4932 | #endif |
4933 | VdbeBranchTaken(1,3); |
4934 | pOp++; |
4935 | goto jump_to_p2; |
4936 | } |
4937 | if( res>=0 ){ |
4938 | /* Jump to This.P2, bypassing the OP_SeekGE opcode */ |
4939 | #ifdef SQLITE_DEBUG |
4940 | if( db->flags&SQLITE_VdbeTrace ){ |
4941 | printf("... %d steps and then success\n" , pOp->p1 - nStep); |
4942 | } |
4943 | #endif |
4944 | VdbeBranchTaken(2,3); |
4945 | goto jump_to_p2; |
4946 | break; |
4947 | } |
4948 | if( nStep<=0 ){ |
4949 | #ifdef SQLITE_DEBUG |
4950 | if( db->flags&SQLITE_VdbeTrace ){ |
4951 | printf("... fall through after %d steps\n" , pOp->p1); |
4952 | } |
4953 | #endif |
4954 | VdbeBranchTaken(0,3); |
4955 | break; |
4956 | } |
4957 | nStep--; |
4958 | rc = sqlite3BtreeNext(pC->uc.pCursor, 0); |
4959 | if( rc ){ |
4960 | if( rc==SQLITE_DONE ){ |
4961 | rc = SQLITE_OK; |
4962 | goto seekscan_search_fail; |
4963 | }else{ |
4964 | goto abort_due_to_error; |
4965 | } |
4966 | } |
4967 | } |
4968 | |
4969 | break; |
4970 | } |
4971 | |
4972 | |
4973 | /* Opcode: SeekHit P1 P2 P3 * * |
4974 | ** Synopsis: set P2<=seekHit<=P3 |
4975 | ** |
4976 | ** Increase or decrease the seekHit value for cursor P1, if necessary, |
4977 | ** so that it is no less than P2 and no greater than P3. |
4978 | ** |
4979 | ** The seekHit integer represents the maximum of terms in an index for which |
4980 | ** there is known to be at least one match. If the seekHit value is smaller |
4981 | ** than the total number of equality terms in an index lookup, then the |
4982 | ** OP_IfNoHope opcode might run to see if the IN loop can be abandoned |
4983 | ** early, thus saving work. This is part of the IN-early-out optimization. |
4984 | ** |
4985 | ** P1 must be a valid b-tree cursor. |
4986 | */ |
4987 | case OP_SeekHit: { |
4988 | VdbeCursor *pC; |
4989 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
4990 | pC = p->apCsr[pOp->p1]; |
4991 | assert( pC!=0 ); |
4992 | assert( pOp->p3>=pOp->p2 ); |
4993 | if( pC->seekHit<pOp->p2 ){ |
4994 | #ifdef SQLITE_DEBUG |
4995 | if( db->flags&SQLITE_VdbeTrace ){ |
4996 | printf("seekHit changes from %d to %d\n" , pC->seekHit, pOp->p2); |
4997 | } |
4998 | #endif |
4999 | pC->seekHit = pOp->p2; |
5000 | }else if( pC->seekHit>pOp->p3 ){ |
5001 | #ifdef SQLITE_DEBUG |
5002 | if( db->flags&SQLITE_VdbeTrace ){ |
5003 | printf("seekHit changes from %d to %d\n" , pC->seekHit, pOp->p3); |
5004 | } |
5005 | #endif |
5006 | pC->seekHit = pOp->p3; |
5007 | } |
5008 | break; |
5009 | } |
5010 | |
5011 | /* Opcode: IfNotOpen P1 P2 * * * |
5012 | ** Synopsis: if( !csr[P1] ) goto P2 |
5013 | ** |
5014 | ** If cursor P1 is not open or if P1 is set to a NULL row using the |
5015 | ** OP_NullRow opcode, then jump to instruction P2. Otherwise, fall through. |
5016 | */ |
5017 | case OP_IfNotOpen: { /* jump */ |
5018 | VdbeCursor *pCur; |
5019 | |
5020 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5021 | pCur = p->apCsr[pOp->p1]; |
5022 | VdbeBranchTaken(pCur==0 || pCur->nullRow, 2); |
5023 | if( pCur==0 || pCur->nullRow ){ |
5024 | goto jump_to_p2_and_check_for_interrupt; |
5025 | } |
5026 | break; |
5027 | } |
5028 | |
5029 | /* Opcode: Found P1 P2 P3 P4 * |
5030 | ** Synopsis: key=r[P3@P4] |
5031 | ** |
5032 | ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If |
5033 | ** P4>0 then register P3 is the first of P4 registers that form an unpacked |
5034 | ** record. |
5035 | ** |
5036 | ** Cursor P1 is on an index btree. If the record identified by P3 and P4 |
5037 | ** is a prefix of any entry in P1 then a jump is made to P2 and |
5038 | ** P1 is left pointing at the matching entry. |
5039 | ** |
5040 | ** This operation leaves the cursor in a state where it can be |
5041 | ** advanced in the forward direction. The Next instruction will work, |
5042 | ** but not the Prev instruction. |
5043 | ** |
5044 | ** See also: NotFound, NoConflict, NotExists. SeekGe |
5045 | */ |
5046 | /* Opcode: NotFound P1 P2 P3 P4 * |
5047 | ** Synopsis: key=r[P3@P4] |
5048 | ** |
5049 | ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If |
5050 | ** P4>0 then register P3 is the first of P4 registers that form an unpacked |
5051 | ** record. |
5052 | ** |
5053 | ** Cursor P1 is on an index btree. If the record identified by P3 and P4 |
5054 | ** is not the prefix of any entry in P1 then a jump is made to P2. If P1 |
5055 | ** does contain an entry whose prefix matches the P3/P4 record then control |
5056 | ** falls through to the next instruction and P1 is left pointing at the |
5057 | ** matching entry. |
5058 | ** |
5059 | ** This operation leaves the cursor in a state where it cannot be |
5060 | ** advanced in either direction. In other words, the Next and Prev |
5061 | ** opcodes do not work after this operation. |
5062 | ** |
5063 | ** See also: Found, NotExists, NoConflict, IfNoHope |
5064 | */ |
5065 | /* Opcode: IfNoHope P1 P2 P3 P4 * |
5066 | ** Synopsis: key=r[P3@P4] |
5067 | ** |
5068 | ** Register P3 is the first of P4 registers that form an unpacked |
5069 | ** record. Cursor P1 is an index btree. P2 is a jump destination. |
5070 | ** In other words, the operands to this opcode are the same as the |
5071 | ** operands to OP_NotFound and OP_IdxGT. |
5072 | ** |
5073 | ** This opcode is an optimization attempt only. If this opcode always |
5074 | ** falls through, the correct answer is still obtained, but extra works |
5075 | ** is performed. |
5076 | ** |
5077 | ** A value of N in the seekHit flag of cursor P1 means that there exists |
5078 | ** a key P3:N that will match some record in the index. We want to know |
5079 | ** if it is possible for a record P3:P4 to match some record in the |
5080 | ** index. If it is not possible, we can skips some work. So if seekHit |
5081 | ** is less than P4, attempt to find out if a match is possible by running |
5082 | ** OP_NotFound. |
5083 | ** |
5084 | ** This opcode is used in IN clause processing for a multi-column key. |
5085 | ** If an IN clause is attached to an element of the key other than the |
5086 | ** left-most element, and if there are no matches on the most recent |
5087 | ** seek over the whole key, then it might be that one of the key element |
5088 | ** to the left is prohibiting a match, and hence there is "no hope" of |
5089 | ** any match regardless of how many IN clause elements are checked. |
5090 | ** In such a case, we abandon the IN clause search early, using this |
5091 | ** opcode. The opcode name comes from the fact that the |
5092 | ** jump is taken if there is "no hope" of achieving a match. |
5093 | ** |
5094 | ** See also: NotFound, SeekHit |
5095 | */ |
5096 | /* Opcode: NoConflict P1 P2 P3 P4 * |
5097 | ** Synopsis: key=r[P3@P4] |
5098 | ** |
5099 | ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If |
5100 | ** P4>0 then register P3 is the first of P4 registers that form an unpacked |
5101 | ** record. |
5102 | ** |
5103 | ** Cursor P1 is on an index btree. If the record identified by P3 and P4 |
5104 | ** contains any NULL value, jump immediately to P2. If all terms of the |
5105 | ** record are not-NULL then a check is done to determine if any row in the |
5106 | ** P1 index btree has a matching key prefix. If there are no matches, jump |
5107 | ** immediately to P2. If there is a match, fall through and leave the P1 |
5108 | ** cursor pointing to the matching row. |
5109 | ** |
5110 | ** This opcode is similar to OP_NotFound with the exceptions that the |
5111 | ** branch is always taken if any part of the search key input is NULL. |
5112 | ** |
5113 | ** This operation leaves the cursor in a state where it cannot be |
5114 | ** advanced in either direction. In other words, the Next and Prev |
5115 | ** opcodes do not work after this operation. |
5116 | ** |
5117 | ** See also: NotFound, Found, NotExists |
5118 | */ |
5119 | case OP_IfNoHope: { /* jump, in3 */ |
5120 | VdbeCursor *pC; |
5121 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5122 | pC = p->apCsr[pOp->p1]; |
5123 | assert( pC!=0 ); |
5124 | #ifdef SQLITE_DEBUG |
5125 | if( db->flags&SQLITE_VdbeTrace ){ |
5126 | printf("seekHit is %d\n" , pC->seekHit); |
5127 | } |
5128 | #endif |
5129 | if( pC->seekHit>=pOp->p4.i ) break; |
5130 | /* Fall through into OP_NotFound */ |
5131 | /* no break */ deliberate_fall_through |
5132 | } |
5133 | case OP_NoConflict: /* jump, in3 */ |
5134 | case OP_NotFound: /* jump, in3 */ |
5135 | case OP_Found: { /* jump, in3 */ |
5136 | int alreadyExists; |
5137 | int ii; |
5138 | VdbeCursor *pC; |
5139 | UnpackedRecord *pIdxKey; |
5140 | UnpackedRecord r; |
5141 | |
5142 | #ifdef SQLITE_TEST |
5143 | if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++; |
5144 | #endif |
5145 | |
5146 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5147 | assert( pOp->p4type==P4_INT32 ); |
5148 | pC = p->apCsr[pOp->p1]; |
5149 | assert( pC!=0 ); |
5150 | #ifdef SQLITE_DEBUG |
5151 | pC->seekOp = pOp->opcode; |
5152 | #endif |
5153 | r.aMem = &aMem[pOp->p3]; |
5154 | assert( pC->eCurType==CURTYPE_BTREE ); |
5155 | assert( pC->uc.pCursor!=0 ); |
5156 | assert( pC->isTable==0 ); |
5157 | r.nField = (u16)pOp->p4.i; |
5158 | if( r.nField>0 ){ |
5159 | /* Key values in an array of registers */ |
5160 | r.pKeyInfo = pC->pKeyInfo; |
5161 | r.default_rc = 0; |
5162 | #ifdef SQLITE_DEBUG |
5163 | for(ii=0; ii<r.nField; ii++){ |
5164 | assert( memIsValid(&r.aMem[ii]) ); |
5165 | assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 ); |
5166 | if( ii ) REGISTER_TRACE(pOp->p3+ii, &r.aMem[ii]); |
5167 | } |
5168 | #endif |
5169 | rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &pC->seekResult); |
5170 | }else{ |
5171 | /* Composite key generated by OP_MakeRecord */ |
5172 | assert( r.aMem->flags & MEM_Blob ); |
5173 | assert( pOp->opcode!=OP_NoConflict ); |
5174 | rc = ExpandBlob(r.aMem); |
5175 | assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); |
5176 | if( rc ) goto no_mem; |
5177 | pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo); |
5178 | if( pIdxKey==0 ) goto no_mem; |
5179 | sqlite3VdbeRecordUnpack(pC->pKeyInfo, r.aMem->n, r.aMem->z, pIdxKey); |
5180 | pIdxKey->default_rc = 0; |
5181 | rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &pC->seekResult); |
5182 | sqlite3DbFreeNN(db, pIdxKey); |
5183 | } |
5184 | if( rc!=SQLITE_OK ){ |
5185 | goto abort_due_to_error; |
5186 | } |
5187 | alreadyExists = (pC->seekResult==0); |
5188 | pC->nullRow = 1-alreadyExists; |
5189 | pC->deferredMoveto = 0; |
5190 | pC->cacheStatus = CACHE_STALE; |
5191 | if( pOp->opcode==OP_Found ){ |
5192 | VdbeBranchTaken(alreadyExists!=0,2); |
5193 | if( alreadyExists ) goto jump_to_p2; |
5194 | }else{ |
5195 | if( !alreadyExists ){ |
5196 | VdbeBranchTaken(1,2); |
5197 | goto jump_to_p2; |
5198 | } |
5199 | if( pOp->opcode==OP_NoConflict ){ |
5200 | /* For the OP_NoConflict opcode, take the jump if any of the |
5201 | ** input fields are NULL, since any key with a NULL will not |
5202 | ** conflict */ |
5203 | for(ii=0; ii<r.nField; ii++){ |
5204 | if( r.aMem[ii].flags & MEM_Null ){ |
5205 | VdbeBranchTaken(1,2); |
5206 | goto jump_to_p2; |
5207 | } |
5208 | } |
5209 | } |
5210 | VdbeBranchTaken(0,2); |
5211 | if( pOp->opcode==OP_IfNoHope ){ |
5212 | pC->seekHit = pOp->p4.i; |
5213 | } |
5214 | } |
5215 | break; |
5216 | } |
5217 | |
5218 | /* Opcode: SeekRowid P1 P2 P3 * * |
5219 | ** Synopsis: intkey=r[P3] |
5220 | ** |
5221 | ** P1 is the index of a cursor open on an SQL table btree (with integer |
5222 | ** keys). If register P3 does not contain an integer or if P1 does not |
5223 | ** contain a record with rowid P3 then jump immediately to P2. |
5224 | ** Or, if P2 is 0, raise an SQLITE_CORRUPT error. If P1 does contain |
5225 | ** a record with rowid P3 then |
5226 | ** leave the cursor pointing at that record and fall through to the next |
5227 | ** instruction. |
5228 | ** |
5229 | ** The OP_NotExists opcode performs the same operation, but with OP_NotExists |
5230 | ** the P3 register must be guaranteed to contain an integer value. With this |
5231 | ** opcode, register P3 might not contain an integer. |
5232 | ** |
5233 | ** The OP_NotFound opcode performs the same operation on index btrees |
5234 | ** (with arbitrary multi-value keys). |
5235 | ** |
5236 | ** This opcode leaves the cursor in a state where it cannot be advanced |
5237 | ** in either direction. In other words, the Next and Prev opcodes will |
5238 | ** not work following this opcode. |
5239 | ** |
5240 | ** See also: Found, NotFound, NoConflict, SeekRowid |
5241 | */ |
5242 | /* Opcode: NotExists P1 P2 P3 * * |
5243 | ** Synopsis: intkey=r[P3] |
5244 | ** |
5245 | ** P1 is the index of a cursor open on an SQL table btree (with integer |
5246 | ** keys). P3 is an integer rowid. If P1 does not contain a record with |
5247 | ** rowid P3 then jump immediately to P2. Or, if P2 is 0, raise an |
5248 | ** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then |
5249 | ** leave the cursor pointing at that record and fall through to the next |
5250 | ** instruction. |
5251 | ** |
5252 | ** The OP_SeekRowid opcode performs the same operation but also allows the |
5253 | ** P3 register to contain a non-integer value, in which case the jump is |
5254 | ** always taken. This opcode requires that P3 always contain an integer. |
5255 | ** |
5256 | ** The OP_NotFound opcode performs the same operation on index btrees |
5257 | ** (with arbitrary multi-value keys). |
5258 | ** |
5259 | ** This opcode leaves the cursor in a state where it cannot be advanced |
5260 | ** in either direction. In other words, the Next and Prev opcodes will |
5261 | ** not work following this opcode. |
5262 | ** |
5263 | ** See also: Found, NotFound, NoConflict, SeekRowid |
5264 | */ |
5265 | case OP_SeekRowid: { /* jump, in3 */ |
5266 | VdbeCursor *pC; |
5267 | BtCursor *pCrsr; |
5268 | int res; |
5269 | u64 iKey; |
5270 | |
5271 | pIn3 = &aMem[pOp->p3]; |
5272 | testcase( pIn3->flags & MEM_Int ); |
5273 | testcase( pIn3->flags & MEM_IntReal ); |
5274 | testcase( pIn3->flags & MEM_Real ); |
5275 | testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str ); |
5276 | if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){ |
5277 | /* If pIn3->u.i does not contain an integer, compute iKey as the |
5278 | ** integer value of pIn3. Jump to P2 if pIn3 cannot be converted |
5279 | ** into an integer without loss of information. Take care to avoid |
5280 | ** changing the datatype of pIn3, however, as it is used by other |
5281 | ** parts of the prepared statement. */ |
5282 | Mem x = pIn3[0]; |
5283 | applyAffinity(&x, SQLITE_AFF_NUMERIC, encoding); |
5284 | if( (x.flags & MEM_Int)==0 ) goto jump_to_p2; |
5285 | iKey = x.u.i; |
5286 | goto notExistsWithKey; |
5287 | } |
5288 | /* Fall through into OP_NotExists */ |
5289 | /* no break */ deliberate_fall_through |
5290 | case OP_NotExists: /* jump, in3 */ |
5291 | pIn3 = &aMem[pOp->p3]; |
5292 | assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid ); |
5293 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5294 | iKey = pIn3->u.i; |
5295 | notExistsWithKey: |
5296 | pC = p->apCsr[pOp->p1]; |
5297 | assert( pC!=0 ); |
5298 | #ifdef SQLITE_DEBUG |
5299 | if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid; |
5300 | #endif |
5301 | assert( pC->isTable ); |
5302 | assert( pC->eCurType==CURTYPE_BTREE ); |
5303 | pCrsr = pC->uc.pCursor; |
5304 | assert( pCrsr!=0 ); |
5305 | res = 0; |
5306 | rc = sqlite3BtreeTableMoveto(pCrsr, iKey, 0, &res); |
5307 | assert( rc==SQLITE_OK || res==0 ); |
5308 | pC->movetoTarget = iKey; /* Used by OP_Delete */ |
5309 | pC->nullRow = 0; |
5310 | pC->cacheStatus = CACHE_STALE; |
5311 | pC->deferredMoveto = 0; |
5312 | VdbeBranchTaken(res!=0,2); |
5313 | pC->seekResult = res; |
5314 | if( res!=0 ){ |
5315 | assert( rc==SQLITE_OK ); |
5316 | if( pOp->p2==0 ){ |
5317 | rc = SQLITE_CORRUPT_BKPT; |
5318 | }else{ |
5319 | goto jump_to_p2; |
5320 | } |
5321 | } |
5322 | if( rc ) goto abort_due_to_error; |
5323 | break; |
5324 | } |
5325 | |
5326 | /* Opcode: Sequence P1 P2 * * * |
5327 | ** Synopsis: r[P2]=cursor[P1].ctr++ |
5328 | ** |
5329 | ** Find the next available sequence number for cursor P1. |
5330 | ** Write the sequence number into register P2. |
5331 | ** The sequence number on the cursor is incremented after this |
5332 | ** instruction. |
5333 | */ |
5334 | case OP_Sequence: { /* out2 */ |
5335 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5336 | assert( p->apCsr[pOp->p1]!=0 ); |
5337 | assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB ); |
5338 | pOut = out2Prerelease(p, pOp); |
5339 | pOut->u.i = p->apCsr[pOp->p1]->seqCount++; |
5340 | break; |
5341 | } |
5342 | |
5343 | |
5344 | /* Opcode: NewRowid P1 P2 P3 * * |
5345 | ** Synopsis: r[P2]=rowid |
5346 | ** |
5347 | ** Get a new integer record number (a.k.a "rowid") used as the key to a table. |
5348 | ** The record number is not previously used as a key in the database |
5349 | ** table that cursor P1 points to. The new record number is written |
5350 | ** written to register P2. |
5351 | ** |
5352 | ** If P3>0 then P3 is a register in the root frame of this VDBE that holds |
5353 | ** the largest previously generated record number. No new record numbers are |
5354 | ** allowed to be less than this value. When this value reaches its maximum, |
5355 | ** an SQLITE_FULL error is generated. The P3 register is updated with the ' |
5356 | ** generated record number. This P3 mechanism is used to help implement the |
5357 | ** AUTOINCREMENT feature. |
5358 | */ |
5359 | case OP_NewRowid: { /* out2 */ |
5360 | i64 v; /* The new rowid */ |
5361 | VdbeCursor *pC; /* Cursor of table to get the new rowid */ |
5362 | int res; /* Result of an sqlite3BtreeLast() */ |
5363 | int cnt; /* Counter to limit the number of searches */ |
5364 | #ifndef SQLITE_OMIT_AUTOINCREMENT |
5365 | Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */ |
5366 | VdbeFrame *pFrame; /* Root frame of VDBE */ |
5367 | #endif |
5368 | |
5369 | v = 0; |
5370 | res = 0; |
5371 | pOut = out2Prerelease(p, pOp); |
5372 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5373 | pC = p->apCsr[pOp->p1]; |
5374 | assert( pC!=0 ); |
5375 | assert( pC->isTable ); |
5376 | assert( pC->eCurType==CURTYPE_BTREE ); |
5377 | assert( pC->uc.pCursor!=0 ); |
5378 | { |
5379 | /* The next rowid or record number (different terms for the same |
5380 | ** thing) is obtained in a two-step algorithm. |
5381 | ** |
5382 | ** First we attempt to find the largest existing rowid and add one |
5383 | ** to that. But if the largest existing rowid is already the maximum |
5384 | ** positive integer, we have to fall through to the second |
5385 | ** probabilistic algorithm |
5386 | ** |
5387 | ** The second algorithm is to select a rowid at random and see if |
5388 | ** it already exists in the table. If it does not exist, we have |
5389 | ** succeeded. If the random rowid does exist, we select a new one |
5390 | ** and try again, up to 100 times. |
5391 | */ |
5392 | assert( pC->isTable ); |
5393 | |
5394 | #ifdef SQLITE_32BIT_ROWID |
5395 | # define MAX_ROWID 0x7fffffff |
5396 | #else |
5397 | /* Some compilers complain about constants of the form 0x7fffffffffffffff. |
5398 | ** Others complain about 0x7ffffffffffffffffLL. The following macro seems |
5399 | ** to provide the constant while making all compilers happy. |
5400 | */ |
5401 | # define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff ) |
5402 | #endif |
5403 | |
5404 | if( !pC->useRandomRowid ){ |
5405 | rc = sqlite3BtreeLast(pC->uc.pCursor, &res); |
5406 | if( rc!=SQLITE_OK ){ |
5407 | goto abort_due_to_error; |
5408 | } |
5409 | if( res ){ |
5410 | v = 1; /* IMP: R-61914-48074 */ |
5411 | }else{ |
5412 | assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) ); |
5413 | v = sqlite3BtreeIntegerKey(pC->uc.pCursor); |
5414 | if( v>=MAX_ROWID ){ |
5415 | pC->useRandomRowid = 1; |
5416 | }else{ |
5417 | v++; /* IMP: R-29538-34987 */ |
5418 | } |
5419 | } |
5420 | } |
5421 | |
5422 | #ifndef SQLITE_OMIT_AUTOINCREMENT |
5423 | if( pOp->p3 ){ |
5424 | /* Assert that P3 is a valid memory cell. */ |
5425 | assert( pOp->p3>0 ); |
5426 | if( p->pFrame ){ |
5427 | for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); |
5428 | /* Assert that P3 is a valid memory cell. */ |
5429 | assert( pOp->p3<=pFrame->nMem ); |
5430 | pMem = &pFrame->aMem[pOp->p3]; |
5431 | }else{ |
5432 | /* Assert that P3 is a valid memory cell. */ |
5433 | assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
5434 | pMem = &aMem[pOp->p3]; |
5435 | memAboutToChange(p, pMem); |
5436 | } |
5437 | assert( memIsValid(pMem) ); |
5438 | |
5439 | REGISTER_TRACE(pOp->p3, pMem); |
5440 | sqlite3VdbeMemIntegerify(pMem); |
5441 | assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */ |
5442 | if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){ |
5443 | rc = SQLITE_FULL; /* IMP: R-17817-00630 */ |
5444 | goto abort_due_to_error; |
5445 | } |
5446 | if( v<pMem->u.i+1 ){ |
5447 | v = pMem->u.i + 1; |
5448 | } |
5449 | pMem->u.i = v; |
5450 | } |
5451 | #endif |
5452 | if( pC->useRandomRowid ){ |
5453 | /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the |
5454 | ** largest possible integer (9223372036854775807) then the database |
5455 | ** engine starts picking positive candidate ROWIDs at random until |
5456 | ** it finds one that is not previously used. */ |
5457 | assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is |
5458 | ** an AUTOINCREMENT table. */ |
5459 | cnt = 0; |
5460 | do{ |
5461 | sqlite3_randomness(sizeof(v), &v); |
5462 | v &= (MAX_ROWID>>1); v++; /* Ensure that v is greater than zero */ |
5463 | }while( ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v, |
5464 | 0, &res))==SQLITE_OK) |
5465 | && (res==0) |
5466 | && (++cnt<100)); |
5467 | if( rc ) goto abort_due_to_error; |
5468 | if( res==0 ){ |
5469 | rc = SQLITE_FULL; /* IMP: R-38219-53002 */ |
5470 | goto abort_due_to_error; |
5471 | } |
5472 | assert( v>0 ); /* EV: R-40812-03570 */ |
5473 | } |
5474 | pC->deferredMoveto = 0; |
5475 | pC->cacheStatus = CACHE_STALE; |
5476 | } |
5477 | pOut->u.i = v; |
5478 | break; |
5479 | } |
5480 | |
5481 | /* Opcode: Insert P1 P2 P3 P4 P5 |
5482 | ** Synopsis: intkey=r[P3] data=r[P2] |
5483 | ** |
5484 | ** Write an entry into the table of cursor P1. A new entry is |
5485 | ** created if it doesn't already exist or the data for an existing |
5486 | ** entry is overwritten. The data is the value MEM_Blob stored in register |
5487 | ** number P2. The key is stored in register P3. The key must |
5488 | ** be a MEM_Int. |
5489 | ** |
5490 | ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is |
5491 | ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set, |
5492 | ** then rowid is stored for subsequent return by the |
5493 | ** sqlite3_last_insert_rowid() function (otherwise it is unmodified). |
5494 | ** |
5495 | ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might |
5496 | ** run faster by avoiding an unnecessary seek on cursor P1. However, |
5497 | ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior |
5498 | ** seeks on the cursor or if the most recent seek used a key equal to P3. |
5499 | ** |
5500 | ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an |
5501 | ** UPDATE operation. Otherwise (if the flag is clear) then this opcode |
5502 | ** is part of an INSERT operation. The difference is only important to |
5503 | ** the update hook. |
5504 | ** |
5505 | ** Parameter P4 may point to a Table structure, or may be NULL. If it is |
5506 | ** not NULL, then the update-hook (sqlite3.xUpdateCallback) is invoked |
5507 | ** following a successful insert. |
5508 | ** |
5509 | ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically |
5510 | ** allocated, then ownership of P2 is transferred to the pseudo-cursor |
5511 | ** and register P2 becomes ephemeral. If the cursor is changed, the |
5512 | ** value of register P2 will then change. Make sure this does not |
5513 | ** cause any problems.) |
5514 | ** |
5515 | ** This instruction only works on tables. The equivalent instruction |
5516 | ** for indices is OP_IdxInsert. |
5517 | */ |
5518 | case OP_Insert: { |
5519 | Mem *pData; /* MEM cell holding data for the record to be inserted */ |
5520 | Mem *pKey; /* MEM cell holding key for the record */ |
5521 | VdbeCursor *pC; /* Cursor to table into which insert is written */ |
5522 | int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */ |
5523 | const char *zDb; /* database name - used by the update hook */ |
5524 | Table *pTab; /* Table structure - used by update and pre-update hooks */ |
5525 | BtreePayload x; /* Payload to be inserted */ |
5526 | |
5527 | pData = &aMem[pOp->p2]; |
5528 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5529 | assert( memIsValid(pData) ); |
5530 | pC = p->apCsr[pOp->p1]; |
5531 | assert( pC!=0 ); |
5532 | assert( pC->eCurType==CURTYPE_BTREE ); |
5533 | assert( pC->deferredMoveto==0 ); |
5534 | assert( pC->uc.pCursor!=0 ); |
5535 | assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable ); |
5536 | assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC ); |
5537 | REGISTER_TRACE(pOp->p2, pData); |
5538 | sqlite3VdbeIncrWriteCounter(p, pC); |
5539 | |
5540 | pKey = &aMem[pOp->p3]; |
5541 | assert( pKey->flags & MEM_Int ); |
5542 | assert( memIsValid(pKey) ); |
5543 | REGISTER_TRACE(pOp->p3, pKey); |
5544 | x.nKey = pKey->u.i; |
5545 | |
5546 | if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){ |
5547 | assert( pC->iDb>=0 ); |
5548 | zDb = db->aDb[pC->iDb].zDbSName; |
5549 | pTab = pOp->p4.pTab; |
5550 | assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) ); |
5551 | }else{ |
5552 | pTab = 0; |
5553 | zDb = 0; |
5554 | } |
5555 | |
5556 | #ifdef SQLITE_ENABLE_PREUPDATE_HOOK |
5557 | /* Invoke the pre-update hook, if any */ |
5558 | if( pTab ){ |
5559 | if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){ |
5560 | sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1); |
5561 | } |
5562 | if( db->xUpdateCallback==0 || pTab->aCol==0 ){ |
5563 | /* Prevent post-update hook from running in cases when it should not */ |
5564 | pTab = 0; |
5565 | } |
5566 | } |
5567 | if( pOp->p5 & OPFLAG_ISNOOP ) break; |
5568 | #endif |
5569 | |
5570 | if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; |
5571 | if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey; |
5572 | assert( (pData->flags & (MEM_Blob|MEM_Str))!=0 || pData->n==0 ); |
5573 | x.pData = pData->z; |
5574 | x.nData = pData->n; |
5575 | seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0); |
5576 | if( pData->flags & MEM_Zero ){ |
5577 | x.nZero = pData->u.nZero; |
5578 | }else{ |
5579 | x.nZero = 0; |
5580 | } |
5581 | x.pKey = 0; |
5582 | rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, |
5583 | (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)), |
5584 | seekResult |
5585 | ); |
5586 | pC->deferredMoveto = 0; |
5587 | pC->cacheStatus = CACHE_STALE; |
5588 | |
5589 | /* Invoke the update-hook if required. */ |
5590 | if( rc ) goto abort_due_to_error; |
5591 | if( pTab ){ |
5592 | assert( db->xUpdateCallback!=0 ); |
5593 | assert( pTab->aCol!=0 ); |
5594 | db->xUpdateCallback(db->pUpdateArg, |
5595 | (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT, |
5596 | zDb, pTab->zName, x.nKey); |
5597 | } |
5598 | break; |
5599 | } |
5600 | |
5601 | /* Opcode: RowCell P1 P2 P3 * * |
5602 | ** |
5603 | ** P1 and P2 are both open cursors. Both must be opened on the same type |
5604 | ** of table - intkey or index. This opcode is used as part of copying |
5605 | ** the current row from P2 into P1. If the cursors are opened on intkey |
5606 | ** tables, register P3 contains the rowid to use with the new record in |
5607 | ** P1. If they are opened on index tables, P3 is not used. |
5608 | ** |
5609 | ** This opcode must be followed by either an Insert or InsertIdx opcode |
5610 | ** with the OPFLAG_PREFORMAT flag set to complete the insert operation. |
5611 | */ |
5612 | case OP_RowCell: { |
5613 | VdbeCursor *pDest; /* Cursor to write to */ |
5614 | VdbeCursor *pSrc; /* Cursor to read from */ |
5615 | i64 iKey; /* Rowid value to insert with */ |
5616 | assert( pOp[1].opcode==OP_Insert || pOp[1].opcode==OP_IdxInsert ); |
5617 | assert( pOp[1].opcode==OP_Insert || pOp->p3==0 ); |
5618 | assert( pOp[1].opcode==OP_IdxInsert || pOp->p3>0 ); |
5619 | assert( pOp[1].p5 & OPFLAG_PREFORMAT ); |
5620 | pDest = p->apCsr[pOp->p1]; |
5621 | pSrc = p->apCsr[pOp->p2]; |
5622 | iKey = pOp->p3 ? aMem[pOp->p3].u.i : 0; |
5623 | rc = sqlite3BtreeTransferRow(pDest->uc.pCursor, pSrc->uc.pCursor, iKey); |
5624 | if( rc!=SQLITE_OK ) goto abort_due_to_error; |
5625 | break; |
5626 | }; |
5627 | |
5628 | /* Opcode: Delete P1 P2 P3 P4 P5 |
5629 | ** |
5630 | ** Delete the record at which the P1 cursor is currently pointing. |
5631 | ** |
5632 | ** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then |
5633 | ** the cursor will be left pointing at either the next or the previous |
5634 | ** record in the table. If it is left pointing at the next record, then |
5635 | ** the next Next instruction will be a no-op. As a result, in this case |
5636 | ** it is ok to delete a record from within a Next loop. If |
5637 | ** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be |
5638 | ** left in an undefined state. |
5639 | ** |
5640 | ** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this |
5641 | ** delete one of several associated with deleting a table row and all its |
5642 | ** associated index entries. Exactly one of those deletes is the "primary" |
5643 | ** delete. The others are all on OPFLAG_FORDELETE cursors or else are |
5644 | ** marked with the AUXDELETE flag. |
5645 | ** |
5646 | ** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row |
5647 | ** change count is incremented (otherwise not). |
5648 | ** |
5649 | ** P1 must not be pseudo-table. It has to be a real table with |
5650 | ** multiple rows. |
5651 | ** |
5652 | ** If P4 is not NULL then it points to a Table object. In this case either |
5653 | ** the update or pre-update hook, or both, may be invoked. The P1 cursor must |
5654 | ** have been positioned using OP_NotFound prior to invoking this opcode in |
5655 | ** this case. Specifically, if one is configured, the pre-update hook is |
5656 | ** invoked if P4 is not NULL. The update-hook is invoked if one is configured, |
5657 | ** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2. |
5658 | ** |
5659 | ** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address |
5660 | ** of the memory cell that contains the value that the rowid of the row will |
5661 | ** be set to by the update. |
5662 | */ |
5663 | case OP_Delete: { |
5664 | VdbeCursor *pC; |
5665 | const char *zDb; |
5666 | Table *pTab; |
5667 | int opflags; |
5668 | |
5669 | opflags = pOp->p2; |
5670 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5671 | pC = p->apCsr[pOp->p1]; |
5672 | assert( pC!=0 ); |
5673 | assert( pC->eCurType==CURTYPE_BTREE ); |
5674 | assert( pC->uc.pCursor!=0 ); |
5675 | assert( pC->deferredMoveto==0 ); |
5676 | sqlite3VdbeIncrWriteCounter(p, pC); |
5677 | |
5678 | #ifdef SQLITE_DEBUG |
5679 | if( pOp->p4type==P4_TABLE |
5680 | && HasRowid(pOp->p4.pTab) |
5681 | && pOp->p5==0 |
5682 | && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) |
5683 | ){ |
5684 | /* If p5 is zero, the seek operation that positioned the cursor prior to |
5685 | ** OP_Delete will have also set the pC->movetoTarget field to the rowid of |
5686 | ** the row that is being deleted */ |
5687 | i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor); |
5688 | assert( CORRUPT_DB || pC->movetoTarget==iKey ); |
5689 | } |
5690 | #endif |
5691 | |
5692 | /* If the update-hook or pre-update-hook will be invoked, set zDb to |
5693 | ** the name of the db to pass as to it. Also set local pTab to a copy |
5694 | ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was |
5695 | ** last moved with OP_Next or OP_Prev, not Seek or NotFound, set |
5696 | ** VdbeCursor.movetoTarget to the current rowid. */ |
5697 | if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){ |
5698 | assert( pC->iDb>=0 ); |
5699 | assert( pOp->p4.pTab!=0 ); |
5700 | zDb = db->aDb[pC->iDb].zDbSName; |
5701 | pTab = pOp->p4.pTab; |
5702 | if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){ |
5703 | pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor); |
5704 | } |
5705 | }else{ |
5706 | zDb = 0; |
5707 | pTab = 0; |
5708 | } |
5709 | |
5710 | #ifdef SQLITE_ENABLE_PREUPDATE_HOOK |
5711 | /* Invoke the pre-update-hook if required. */ |
5712 | assert( db->xPreUpdateCallback==0 || pTab==pOp->p4.pTab ); |
5713 | if( db->xPreUpdateCallback && pTab ){ |
5714 | assert( !(opflags & OPFLAG_ISUPDATE) |
5715 | || HasRowid(pTab)==0 |
5716 | || (aMem[pOp->p3].flags & MEM_Int) |
5717 | ); |
5718 | sqlite3VdbePreUpdateHook(p, pC, |
5719 | (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE, |
5720 | zDb, pTab, pC->movetoTarget, |
5721 | pOp->p3, -1 |
5722 | ); |
5723 | } |
5724 | if( opflags & OPFLAG_ISNOOP ) break; |
5725 | #endif |
5726 | |
5727 | /* Only flags that can be set are SAVEPOISTION and AUXDELETE */ |
5728 | assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 ); |
5729 | assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION ); |
5730 | assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE ); |
5731 | |
5732 | #ifdef SQLITE_DEBUG |
5733 | if( p->pFrame==0 ){ |
5734 | if( pC->isEphemeral==0 |
5735 | && (pOp->p5 & OPFLAG_AUXDELETE)==0 |
5736 | && (pC->wrFlag & OPFLAG_FORDELETE)==0 |
5737 | ){ |
5738 | nExtraDelete++; |
5739 | } |
5740 | if( pOp->p2 & OPFLAG_NCHANGE ){ |
5741 | nExtraDelete--; |
5742 | } |
5743 | } |
5744 | #endif |
5745 | |
5746 | rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5); |
5747 | pC->cacheStatus = CACHE_STALE; |
5748 | pC->seekResult = 0; |
5749 | if( rc ) goto abort_due_to_error; |
5750 | |
5751 | /* Invoke the update-hook if required. */ |
5752 | if( opflags & OPFLAG_NCHANGE ){ |
5753 | p->nChange++; |
5754 | if( db->xUpdateCallback && ALWAYS(pTab!=0) && HasRowid(pTab) ){ |
5755 | db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName, |
5756 | pC->movetoTarget); |
5757 | assert( pC->iDb>=0 ); |
5758 | } |
5759 | } |
5760 | |
5761 | break; |
5762 | } |
5763 | /* Opcode: ResetCount * * * * * |
5764 | ** |
5765 | ** The value of the change counter is copied to the database handle |
5766 | ** change counter (returned by subsequent calls to sqlite3_changes()). |
5767 | ** Then the VMs internal change counter resets to 0. |
5768 | ** This is used by trigger programs. |
5769 | */ |
5770 | case OP_ResetCount: { |
5771 | sqlite3VdbeSetChanges(db, p->nChange); |
5772 | p->nChange = 0; |
5773 | break; |
5774 | } |
5775 | |
5776 | /* Opcode: SorterCompare P1 P2 P3 P4 |
5777 | ** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2 |
5778 | ** |
5779 | ** P1 is a sorter cursor. This instruction compares a prefix of the |
5780 | ** record blob in register P3 against a prefix of the entry that |
5781 | ** the sorter cursor currently points to. Only the first P4 fields |
5782 | ** of r[P3] and the sorter record are compared. |
5783 | ** |
5784 | ** If either P3 or the sorter contains a NULL in one of their significant |
5785 | ** fields (not counting the P4 fields at the end which are ignored) then |
5786 | ** the comparison is assumed to be equal. |
5787 | ** |
5788 | ** Fall through to next instruction if the two records compare equal to |
5789 | ** each other. Jump to P2 if they are different. |
5790 | */ |
5791 | case OP_SorterCompare: { |
5792 | VdbeCursor *pC; |
5793 | int res; |
5794 | int nKeyCol; |
5795 | |
5796 | pC = p->apCsr[pOp->p1]; |
5797 | assert( isSorter(pC) ); |
5798 | assert( pOp->p4type==P4_INT32 ); |
5799 | pIn3 = &aMem[pOp->p3]; |
5800 | nKeyCol = pOp->p4.i; |
5801 | res = 0; |
5802 | rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res); |
5803 | VdbeBranchTaken(res!=0,2); |
5804 | if( rc ) goto abort_due_to_error; |
5805 | if( res ) goto jump_to_p2; |
5806 | break; |
5807 | }; |
5808 | |
5809 | /* Opcode: SorterData P1 P2 P3 * * |
5810 | ** Synopsis: r[P2]=data |
5811 | ** |
5812 | ** Write into register P2 the current sorter data for sorter cursor P1. |
5813 | ** Then clear the column header cache on cursor P3. |
5814 | ** |
5815 | ** This opcode is normally use to move a record out of the sorter and into |
5816 | ** a register that is the source for a pseudo-table cursor created using |
5817 | ** OpenPseudo. That pseudo-table cursor is the one that is identified by |
5818 | ** parameter P3. Clearing the P3 column cache as part of this opcode saves |
5819 | ** us from having to issue a separate NullRow instruction to clear that cache. |
5820 | */ |
5821 | case OP_SorterData: { |
5822 | VdbeCursor *pC; |
5823 | |
5824 | pOut = &aMem[pOp->p2]; |
5825 | pC = p->apCsr[pOp->p1]; |
5826 | assert( isSorter(pC) ); |
5827 | rc = sqlite3VdbeSorterRowkey(pC, pOut); |
5828 | assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) ); |
5829 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5830 | if( rc ) goto abort_due_to_error; |
5831 | p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE; |
5832 | break; |
5833 | } |
5834 | |
5835 | /* Opcode: RowData P1 P2 P3 * * |
5836 | ** Synopsis: r[P2]=data |
5837 | ** |
5838 | ** Write into register P2 the complete row content for the row at |
5839 | ** which cursor P1 is currently pointing. |
5840 | ** There is no interpretation of the data. |
5841 | ** It is just copied onto the P2 register exactly as |
5842 | ** it is found in the database file. |
5843 | ** |
5844 | ** If cursor P1 is an index, then the content is the key of the row. |
5845 | ** If cursor P2 is a table, then the content extracted is the data. |
5846 | ** |
5847 | ** If the P1 cursor must be pointing to a valid row (not a NULL row) |
5848 | ** of a real table, not a pseudo-table. |
5849 | ** |
5850 | ** If P3!=0 then this opcode is allowed to make an ephemeral pointer |
5851 | ** into the database page. That means that the content of the output |
5852 | ** register will be invalidated as soon as the cursor moves - including |
5853 | ** moves caused by other cursors that "save" the current cursors |
5854 | ** position in order that they can write to the same table. If P3==0 |
5855 | ** then a copy of the data is made into memory. P3!=0 is faster, but |
5856 | ** P3==0 is safer. |
5857 | ** |
5858 | ** If P3!=0 then the content of the P2 register is unsuitable for use |
5859 | ** in OP_Result and any OP_Result will invalidate the P2 register content. |
5860 | ** The P2 register content is invalidated by opcodes like OP_Function or |
5861 | ** by any use of another cursor pointing to the same table. |
5862 | */ |
5863 | case OP_RowData: { |
5864 | VdbeCursor *pC; |
5865 | BtCursor *pCrsr; |
5866 | u32 n; |
5867 | |
5868 | pOut = out2Prerelease(p, pOp); |
5869 | |
5870 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5871 | pC = p->apCsr[pOp->p1]; |
5872 | assert( pC!=0 ); |
5873 | assert( pC->eCurType==CURTYPE_BTREE ); |
5874 | assert( isSorter(pC)==0 ); |
5875 | assert( pC->nullRow==0 ); |
5876 | assert( pC->uc.pCursor!=0 ); |
5877 | pCrsr = pC->uc.pCursor; |
5878 | |
5879 | /* The OP_RowData opcodes always follow OP_NotExists or |
5880 | ** OP_SeekRowid or OP_Rewind/Op_Next with no intervening instructions |
5881 | ** that might invalidate the cursor. |
5882 | ** If this where not the case, on of the following assert()s |
5883 | ** would fail. Should this ever change (because of changes in the code |
5884 | ** generator) then the fix would be to insert a call to |
5885 | ** sqlite3VdbeCursorMoveto(). |
5886 | */ |
5887 | assert( pC->deferredMoveto==0 ); |
5888 | assert( sqlite3BtreeCursorIsValid(pCrsr) ); |
5889 | |
5890 | n = sqlite3BtreePayloadSize(pCrsr); |
5891 | if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){ |
5892 | goto too_big; |
5893 | } |
5894 | testcase( n==0 ); |
5895 | rc = sqlite3VdbeMemFromBtreeZeroOffset(pCrsr, n, pOut); |
5896 | if( rc ) goto abort_due_to_error; |
5897 | if( !pOp->p3 ) Deephemeralize(pOut); |
5898 | UPDATE_MAX_BLOBSIZE(pOut); |
5899 | REGISTER_TRACE(pOp->p2, pOut); |
5900 | break; |
5901 | } |
5902 | |
5903 | /* Opcode: Rowid P1 P2 * * * |
5904 | ** Synopsis: r[P2]=PX rowid of P1 |
5905 | ** |
5906 | ** Store in register P2 an integer which is the key of the table entry that |
5907 | ** P1 is currently point to. |
5908 | ** |
5909 | ** P1 can be either an ordinary table or a virtual table. There used to |
5910 | ** be a separate OP_VRowid opcode for use with virtual tables, but this |
5911 | ** one opcode now works for both table types. |
5912 | */ |
5913 | case OP_Rowid: { /* out2 */ |
5914 | VdbeCursor *pC; |
5915 | i64 v; |
5916 | sqlite3_vtab *pVtab; |
5917 | const sqlite3_module *pModule; |
5918 | |
5919 | pOut = out2Prerelease(p, pOp); |
5920 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5921 | pC = p->apCsr[pOp->p1]; |
5922 | assert( pC!=0 ); |
5923 | assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow ); |
5924 | if( pC->nullRow ){ |
5925 | pOut->flags = MEM_Null; |
5926 | break; |
5927 | }else if( pC->deferredMoveto ){ |
5928 | v = pC->movetoTarget; |
5929 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
5930 | }else if( pC->eCurType==CURTYPE_VTAB ){ |
5931 | assert( pC->uc.pVCur!=0 ); |
5932 | pVtab = pC->uc.pVCur->pVtab; |
5933 | pModule = pVtab->pModule; |
5934 | assert( pModule->xRowid ); |
5935 | rc = pModule->xRowid(pC->uc.pVCur, &v); |
5936 | sqlite3VtabImportErrmsg(p, pVtab); |
5937 | if( rc ) goto abort_due_to_error; |
5938 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
5939 | }else{ |
5940 | assert( pC->eCurType==CURTYPE_BTREE ); |
5941 | assert( pC->uc.pCursor!=0 ); |
5942 | rc = sqlite3VdbeCursorRestore(pC); |
5943 | if( rc ) goto abort_due_to_error; |
5944 | if( pC->nullRow ){ |
5945 | pOut->flags = MEM_Null; |
5946 | break; |
5947 | } |
5948 | v = sqlite3BtreeIntegerKey(pC->uc.pCursor); |
5949 | } |
5950 | pOut->u.i = v; |
5951 | break; |
5952 | } |
5953 | |
5954 | /* Opcode: NullRow P1 * * * * |
5955 | ** |
5956 | ** Move the cursor P1 to a null row. Any OP_Column operations |
5957 | ** that occur while the cursor is on the null row will always |
5958 | ** write a NULL. |
5959 | ** |
5960 | ** If cursor P1 is not previously opened, open it now to a special |
5961 | ** pseudo-cursor that always returns NULL for every column. |
5962 | */ |
5963 | case OP_NullRow: { |
5964 | VdbeCursor *pC; |
5965 | |
5966 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
5967 | pC = p->apCsr[pOp->p1]; |
5968 | if( pC==0 ){ |
5969 | /* If the cursor is not already open, create a special kind of |
5970 | ** pseudo-cursor that always gives null rows. */ |
5971 | pC = allocateCursor(p, pOp->p1, 1, CURTYPE_PSEUDO); |
5972 | if( pC==0 ) goto no_mem; |
5973 | pC->seekResult = 0; |
5974 | pC->isTable = 1; |
5975 | pC->noReuse = 1; |
5976 | pC->uc.pCursor = sqlite3BtreeFakeValidCursor(); |
5977 | } |
5978 | pC->nullRow = 1; |
5979 | pC->cacheStatus = CACHE_STALE; |
5980 | if( pC->eCurType==CURTYPE_BTREE ){ |
5981 | assert( pC->uc.pCursor!=0 ); |
5982 | sqlite3BtreeClearCursor(pC->uc.pCursor); |
5983 | } |
5984 | #ifdef SQLITE_DEBUG |
5985 | if( pC->seekOp==0 ) pC->seekOp = OP_NullRow; |
5986 | #endif |
5987 | break; |
5988 | } |
5989 | |
5990 | /* Opcode: SeekEnd P1 * * * * |
5991 | ** |
5992 | ** Position cursor P1 at the end of the btree for the purpose of |
5993 | ** appending a new entry onto the btree. |
5994 | ** |
5995 | ** It is assumed that the cursor is used only for appending and so |
5996 | ** if the cursor is valid, then the cursor must already be pointing |
5997 | ** at the end of the btree and so no changes are made to |
5998 | ** the cursor. |
5999 | */ |
6000 | /* Opcode: Last P1 P2 * * * |
6001 | ** |
6002 | ** The next use of the Rowid or Column or Prev instruction for P1 |
6003 | ** will refer to the last entry in the database table or index. |
6004 | ** If the table or index is empty and P2>0, then jump immediately to P2. |
6005 | ** If P2 is 0 or if the table or index is not empty, fall through |
6006 | ** to the following instruction. |
6007 | ** |
6008 | ** This opcode leaves the cursor configured to move in reverse order, |
6009 | ** from the end toward the beginning. In other words, the cursor is |
6010 | ** configured to use Prev, not Next. |
6011 | */ |
6012 | case OP_SeekEnd: |
6013 | case OP_Last: { /* jump */ |
6014 | VdbeCursor *pC; |
6015 | BtCursor *pCrsr; |
6016 | int res; |
6017 | |
6018 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6019 | pC = p->apCsr[pOp->p1]; |
6020 | assert( pC!=0 ); |
6021 | assert( pC->eCurType==CURTYPE_BTREE ); |
6022 | pCrsr = pC->uc.pCursor; |
6023 | res = 0; |
6024 | assert( pCrsr!=0 ); |
6025 | #ifdef SQLITE_DEBUG |
6026 | pC->seekOp = pOp->opcode; |
6027 | #endif |
6028 | if( pOp->opcode==OP_SeekEnd ){ |
6029 | assert( pOp->p2==0 ); |
6030 | pC->seekResult = -1; |
6031 | if( sqlite3BtreeCursorIsValidNN(pCrsr) ){ |
6032 | break; |
6033 | } |
6034 | } |
6035 | rc = sqlite3BtreeLast(pCrsr, &res); |
6036 | pC->nullRow = (u8)res; |
6037 | pC->deferredMoveto = 0; |
6038 | pC->cacheStatus = CACHE_STALE; |
6039 | if( rc ) goto abort_due_to_error; |
6040 | if( pOp->p2>0 ){ |
6041 | VdbeBranchTaken(res!=0,2); |
6042 | if( res ) goto jump_to_p2; |
6043 | } |
6044 | break; |
6045 | } |
6046 | |
6047 | /* Opcode: IfSmaller P1 P2 P3 * * |
6048 | ** |
6049 | ** Estimate the number of rows in the table P1. Jump to P2 if that |
6050 | ** estimate is less than approximately 2**(0.1*P3). |
6051 | */ |
6052 | case OP_IfSmaller: { /* jump */ |
6053 | VdbeCursor *pC; |
6054 | BtCursor *pCrsr; |
6055 | int res; |
6056 | i64 sz; |
6057 | |
6058 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6059 | pC = p->apCsr[pOp->p1]; |
6060 | assert( pC!=0 ); |
6061 | pCrsr = pC->uc.pCursor; |
6062 | assert( pCrsr ); |
6063 | rc = sqlite3BtreeFirst(pCrsr, &res); |
6064 | if( rc ) goto abort_due_to_error; |
6065 | if( res==0 ){ |
6066 | sz = sqlite3BtreeRowCountEst(pCrsr); |
6067 | if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)<pOp->p3 ) res = 1; |
6068 | } |
6069 | VdbeBranchTaken(res!=0,2); |
6070 | if( res ) goto jump_to_p2; |
6071 | break; |
6072 | } |
6073 | |
6074 | |
6075 | /* Opcode: SorterSort P1 P2 * * * |
6076 | ** |
6077 | ** After all records have been inserted into the Sorter object |
6078 | ** identified by P1, invoke this opcode to actually do the sorting. |
6079 | ** Jump to P2 if there are no records to be sorted. |
6080 | ** |
6081 | ** This opcode is an alias for OP_Sort and OP_Rewind that is used |
6082 | ** for Sorter objects. |
6083 | */ |
6084 | /* Opcode: Sort P1 P2 * * * |
6085 | ** |
6086 | ** This opcode does exactly the same thing as OP_Rewind except that |
6087 | ** it increments an undocumented global variable used for testing. |
6088 | ** |
6089 | ** Sorting is accomplished by writing records into a sorting index, |
6090 | ** then rewinding that index and playing it back from beginning to |
6091 | ** end. We use the OP_Sort opcode instead of OP_Rewind to do the |
6092 | ** rewinding so that the global variable will be incremented and |
6093 | ** regression tests can determine whether or not the optimizer is |
6094 | ** correctly optimizing out sorts. |
6095 | */ |
6096 | case OP_SorterSort: /* jump */ |
6097 | case OP_Sort: { /* jump */ |
6098 | #ifdef SQLITE_TEST |
6099 | sqlite3_sort_count++; |
6100 | sqlite3_search_count--; |
6101 | #endif |
6102 | p->aCounter[SQLITE_STMTSTATUS_SORT]++; |
6103 | /* Fall through into OP_Rewind */ |
6104 | /* no break */ deliberate_fall_through |
6105 | } |
6106 | /* Opcode: Rewind P1 P2 * * * |
6107 | ** |
6108 | ** The next use of the Rowid or Column or Next instruction for P1 |
6109 | ** will refer to the first entry in the database table or index. |
6110 | ** If the table or index is empty, jump immediately to P2. |
6111 | ** If the table or index is not empty, fall through to the following |
6112 | ** instruction. |
6113 | ** |
6114 | ** This opcode leaves the cursor configured to move in forward order, |
6115 | ** from the beginning toward the end. In other words, the cursor is |
6116 | ** configured to use Next, not Prev. |
6117 | */ |
6118 | case OP_Rewind: { /* jump */ |
6119 | VdbeCursor *pC; |
6120 | BtCursor *pCrsr; |
6121 | int res; |
6122 | |
6123 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6124 | assert( pOp->p5==0 ); |
6125 | pC = p->apCsr[pOp->p1]; |
6126 | assert( pC!=0 ); |
6127 | assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) ); |
6128 | res = 1; |
6129 | #ifdef SQLITE_DEBUG |
6130 | pC->seekOp = OP_Rewind; |
6131 | #endif |
6132 | if( isSorter(pC) ){ |
6133 | rc = sqlite3VdbeSorterRewind(pC, &res); |
6134 | }else{ |
6135 | assert( pC->eCurType==CURTYPE_BTREE ); |
6136 | pCrsr = pC->uc.pCursor; |
6137 | assert( pCrsr ); |
6138 | rc = sqlite3BtreeFirst(pCrsr, &res); |
6139 | pC->deferredMoveto = 0; |
6140 | pC->cacheStatus = CACHE_STALE; |
6141 | } |
6142 | if( rc ) goto abort_due_to_error; |
6143 | pC->nullRow = (u8)res; |
6144 | assert( pOp->p2>0 && pOp->p2<p->nOp ); |
6145 | VdbeBranchTaken(res!=0,2); |
6146 | if( res ) goto jump_to_p2; |
6147 | break; |
6148 | } |
6149 | |
6150 | /* Opcode: Next P1 P2 P3 * P5 |
6151 | ** |
6152 | ** Advance cursor P1 so that it points to the next key/data pair in its |
6153 | ** table or index. If there are no more key/value pairs then fall through |
6154 | ** to the following instruction. But if the cursor advance was successful, |
6155 | ** jump immediately to P2. |
6156 | ** |
6157 | ** The Next opcode is only valid following an SeekGT, SeekGE, or |
6158 | ** OP_Rewind opcode used to position the cursor. Next is not allowed |
6159 | ** to follow SeekLT, SeekLE, or OP_Last. |
6160 | ** |
6161 | ** The P1 cursor must be for a real table, not a pseudo-table. P1 must have |
6162 | ** been opened prior to this opcode or the program will segfault. |
6163 | ** |
6164 | ** The P3 value is a hint to the btree implementation. If P3==1, that |
6165 | ** means P1 is an SQL index and that this instruction could have been |
6166 | ** omitted if that index had been unique. P3 is usually 0. P3 is |
6167 | ** always either 0 or 1. |
6168 | ** |
6169 | ** If P5 is positive and the jump is taken, then event counter |
6170 | ** number P5-1 in the prepared statement is incremented. |
6171 | ** |
6172 | ** See also: Prev |
6173 | */ |
6174 | /* Opcode: Prev P1 P2 P3 * P5 |
6175 | ** |
6176 | ** Back up cursor P1 so that it points to the previous key/data pair in its |
6177 | ** table or index. If there is no previous key/value pairs then fall through |
6178 | ** to the following instruction. But if the cursor backup was successful, |
6179 | ** jump immediately to P2. |
6180 | ** |
6181 | ** |
6182 | ** The Prev opcode is only valid following an SeekLT, SeekLE, or |
6183 | ** OP_Last opcode used to position the cursor. Prev is not allowed |
6184 | ** to follow SeekGT, SeekGE, or OP_Rewind. |
6185 | ** |
6186 | ** The P1 cursor must be for a real table, not a pseudo-table. If P1 is |
6187 | ** not open then the behavior is undefined. |
6188 | ** |
6189 | ** The P3 value is a hint to the btree implementation. If P3==1, that |
6190 | ** means P1 is an SQL index and that this instruction could have been |
6191 | ** omitted if that index had been unique. P3 is usually 0. P3 is |
6192 | ** always either 0 or 1. |
6193 | ** |
6194 | ** If P5 is positive and the jump is taken, then event counter |
6195 | ** number P5-1 in the prepared statement is incremented. |
6196 | */ |
6197 | /* Opcode: SorterNext P1 P2 * * P5 |
6198 | ** |
6199 | ** This opcode works just like OP_Next except that P1 must be a |
6200 | ** sorter object for which the OP_SorterSort opcode has been |
6201 | ** invoked. This opcode advances the cursor to the next sorted |
6202 | ** record, or jumps to P2 if there are no more sorted records. |
6203 | */ |
6204 | case OP_SorterNext: { /* jump */ |
6205 | VdbeCursor *pC; |
6206 | |
6207 | pC = p->apCsr[pOp->p1]; |
6208 | assert( isSorter(pC) ); |
6209 | rc = sqlite3VdbeSorterNext(db, pC); |
6210 | goto next_tail; |
6211 | |
6212 | case OP_Prev: /* jump */ |
6213 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6214 | assert( pOp->p5==0 |
6215 | || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP |
6216 | || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX); |
6217 | pC = p->apCsr[pOp->p1]; |
6218 | assert( pC!=0 ); |
6219 | assert( pC->deferredMoveto==0 ); |
6220 | assert( pC->eCurType==CURTYPE_BTREE ); |
6221 | assert( pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE |
6222 | || pC->seekOp==OP_Last || pC->seekOp==OP_IfNoHope |
6223 | || pC->seekOp==OP_NullRow); |
6224 | rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3); |
6225 | goto next_tail; |
6226 | |
6227 | case OP_Next: /* jump */ |
6228 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6229 | assert( pOp->p5==0 |
6230 | || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP |
6231 | || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX); |
6232 | pC = p->apCsr[pOp->p1]; |
6233 | assert( pC!=0 ); |
6234 | assert( pC->deferredMoveto==0 ); |
6235 | assert( pC->eCurType==CURTYPE_BTREE ); |
6236 | assert( pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE |
6237 | || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found |
6238 | || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid |
6239 | || pC->seekOp==OP_IfNoHope); |
6240 | rc = sqlite3BtreeNext(pC->uc.pCursor, pOp->p3); |
6241 | |
6242 | next_tail: |
6243 | pC->cacheStatus = CACHE_STALE; |
6244 | VdbeBranchTaken(rc==SQLITE_OK,2); |
6245 | if( rc==SQLITE_OK ){ |
6246 | pC->nullRow = 0; |
6247 | p->aCounter[pOp->p5]++; |
6248 | #ifdef SQLITE_TEST |
6249 | sqlite3_search_count++; |
6250 | #endif |
6251 | goto jump_to_p2_and_check_for_interrupt; |
6252 | } |
6253 | if( rc!=SQLITE_DONE ) goto abort_due_to_error; |
6254 | rc = SQLITE_OK; |
6255 | pC->nullRow = 1; |
6256 | goto check_for_interrupt; |
6257 | } |
6258 | |
6259 | /* Opcode: IdxInsert P1 P2 P3 P4 P5 |
6260 | ** Synopsis: key=r[P2] |
6261 | ** |
6262 | ** Register P2 holds an SQL index key made using the |
6263 | ** MakeRecord instructions. This opcode writes that key |
6264 | ** into the index P1. Data for the entry is nil. |
6265 | ** |
6266 | ** If P4 is not zero, then it is the number of values in the unpacked |
6267 | ** key of reg(P2). In that case, P3 is the index of the first register |
6268 | ** for the unpacked key. The availability of the unpacked key can sometimes |
6269 | ** be an optimization. |
6270 | ** |
6271 | ** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer |
6272 | ** that this insert is likely to be an append. |
6273 | ** |
6274 | ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is |
6275 | ** incremented by this instruction. If the OPFLAG_NCHANGE bit is clear, |
6276 | ** then the change counter is unchanged. |
6277 | ** |
6278 | ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might |
6279 | ** run faster by avoiding an unnecessary seek on cursor P1. However, |
6280 | ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior |
6281 | ** seeks on the cursor or if the most recent seek used a key equivalent |
6282 | ** to P2. |
6283 | ** |
6284 | ** This instruction only works for indices. The equivalent instruction |
6285 | ** for tables is OP_Insert. |
6286 | */ |
6287 | case OP_IdxInsert: { /* in2 */ |
6288 | VdbeCursor *pC; |
6289 | BtreePayload x; |
6290 | |
6291 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6292 | pC = p->apCsr[pOp->p1]; |
6293 | sqlite3VdbeIncrWriteCounter(p, pC); |
6294 | assert( pC!=0 ); |
6295 | assert( !isSorter(pC) ); |
6296 | pIn2 = &aMem[pOp->p2]; |
6297 | assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) ); |
6298 | if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; |
6299 | assert( pC->eCurType==CURTYPE_BTREE ); |
6300 | assert( pC->isTable==0 ); |
6301 | rc = ExpandBlob(pIn2); |
6302 | if( rc ) goto abort_due_to_error; |
6303 | x.nKey = pIn2->n; |
6304 | x.pKey = pIn2->z; |
6305 | x.aMem = aMem + pOp->p3; |
6306 | x.nMem = (u16)pOp->p4.i; |
6307 | rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, |
6308 | (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)), |
6309 | ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0) |
6310 | ); |
6311 | assert( pC->deferredMoveto==0 ); |
6312 | pC->cacheStatus = CACHE_STALE; |
6313 | if( rc) goto abort_due_to_error; |
6314 | break; |
6315 | } |
6316 | |
6317 | /* Opcode: SorterInsert P1 P2 * * * |
6318 | ** Synopsis: key=r[P2] |
6319 | ** |
6320 | ** Register P2 holds an SQL index key made using the |
6321 | ** MakeRecord instructions. This opcode writes that key |
6322 | ** into the sorter P1. Data for the entry is nil. |
6323 | */ |
6324 | case OP_SorterInsert: { /* in2 */ |
6325 | VdbeCursor *pC; |
6326 | |
6327 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6328 | pC = p->apCsr[pOp->p1]; |
6329 | sqlite3VdbeIncrWriteCounter(p, pC); |
6330 | assert( pC!=0 ); |
6331 | assert( isSorter(pC) ); |
6332 | pIn2 = &aMem[pOp->p2]; |
6333 | assert( pIn2->flags & MEM_Blob ); |
6334 | assert( pC->isTable==0 ); |
6335 | rc = ExpandBlob(pIn2); |
6336 | if( rc ) goto abort_due_to_error; |
6337 | rc = sqlite3VdbeSorterWrite(pC, pIn2); |
6338 | if( rc) goto abort_due_to_error; |
6339 | break; |
6340 | } |
6341 | |
6342 | /* Opcode: IdxDelete P1 P2 P3 * P5 |
6343 | ** Synopsis: key=r[P2@P3] |
6344 | ** |
6345 | ** The content of P3 registers starting at register P2 form |
6346 | ** an unpacked index key. This opcode removes that entry from the |
6347 | ** index opened by cursor P1. |
6348 | ** |
6349 | ** If P5 is not zero, then raise an SQLITE_CORRUPT_INDEX error |
6350 | ** if no matching index entry is found. This happens when running |
6351 | ** an UPDATE or DELETE statement and the index entry to be updated |
6352 | ** or deleted is not found. For some uses of IdxDelete |
6353 | ** (example: the EXCEPT operator) it does not matter that no matching |
6354 | ** entry is found. For those cases, P5 is zero. Also, do not raise |
6355 | ** this (self-correcting and non-critical) error if in writable_schema mode. |
6356 | */ |
6357 | case OP_IdxDelete: { |
6358 | VdbeCursor *pC; |
6359 | BtCursor *pCrsr; |
6360 | int res; |
6361 | UnpackedRecord r; |
6362 | |
6363 | assert( pOp->p3>0 ); |
6364 | assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 ); |
6365 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6366 | pC = p->apCsr[pOp->p1]; |
6367 | assert( pC!=0 ); |
6368 | assert( pC->eCurType==CURTYPE_BTREE ); |
6369 | sqlite3VdbeIncrWriteCounter(p, pC); |
6370 | pCrsr = pC->uc.pCursor; |
6371 | assert( pCrsr!=0 ); |
6372 | r.pKeyInfo = pC->pKeyInfo; |
6373 | r.nField = (u16)pOp->p3; |
6374 | r.default_rc = 0; |
6375 | r.aMem = &aMem[pOp->p2]; |
6376 | rc = sqlite3BtreeIndexMoveto(pCrsr, &r, &res); |
6377 | if( rc ) goto abort_due_to_error; |
6378 | if( res==0 ){ |
6379 | rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE); |
6380 | if( rc ) goto abort_due_to_error; |
6381 | }else if( pOp->p5 && !sqlite3WritableSchema(db) ){ |
6382 | rc = sqlite3ReportError(SQLITE_CORRUPT_INDEX, __LINE__, "index corruption" ); |
6383 | goto abort_due_to_error; |
6384 | } |
6385 | assert( pC->deferredMoveto==0 ); |
6386 | pC->cacheStatus = CACHE_STALE; |
6387 | pC->seekResult = 0; |
6388 | break; |
6389 | } |
6390 | |
6391 | /* Opcode: DeferredSeek P1 * P3 P4 * |
6392 | ** Synopsis: Move P3 to P1.rowid if needed |
6393 | ** |
6394 | ** P1 is an open index cursor and P3 is a cursor on the corresponding |
6395 | ** table. This opcode does a deferred seek of the P3 table cursor |
6396 | ** to the row that corresponds to the current row of P1. |
6397 | ** |
6398 | ** This is a deferred seek. Nothing actually happens until |
6399 | ** the cursor is used to read a record. That way, if no reads |
6400 | ** occur, no unnecessary I/O happens. |
6401 | ** |
6402 | ** P4 may be an array of integers (type P4_INTARRAY) containing |
6403 | ** one entry for each column in the P3 table. If array entry a(i) |
6404 | ** is non-zero, then reading column a(i)-1 from cursor P3 is |
6405 | ** equivalent to performing the deferred seek and then reading column i |
6406 | ** from P1. This information is stored in P3 and used to redirect |
6407 | ** reads against P3 over to P1, thus possibly avoiding the need to |
6408 | ** seek and read cursor P3. |
6409 | */ |
6410 | /* Opcode: IdxRowid P1 P2 * * * |
6411 | ** Synopsis: r[P2]=rowid |
6412 | ** |
6413 | ** Write into register P2 an integer which is the last entry in the record at |
6414 | ** the end of the index key pointed to by cursor P1. This integer should be |
6415 | ** the rowid of the table entry to which this index entry points. |
6416 | ** |
6417 | ** See also: Rowid, MakeRecord. |
6418 | */ |
6419 | case OP_DeferredSeek: |
6420 | case OP_IdxRowid: { /* out2 */ |
6421 | VdbeCursor *pC; /* The P1 index cursor */ |
6422 | VdbeCursor *pTabCur; /* The P2 table cursor (OP_DeferredSeek only) */ |
6423 | i64 rowid; /* Rowid that P1 current points to */ |
6424 | |
6425 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6426 | pC = p->apCsr[pOp->p1]; |
6427 | assert( pC!=0 ); |
6428 | assert( pC->eCurType==CURTYPE_BTREE || IsNullCursor(pC) ); |
6429 | assert( pC->uc.pCursor!=0 ); |
6430 | assert( pC->isTable==0 || IsNullCursor(pC) ); |
6431 | assert( pC->deferredMoveto==0 ); |
6432 | assert( !pC->nullRow || pOp->opcode==OP_IdxRowid ); |
6433 | |
6434 | /* The IdxRowid and Seek opcodes are combined because of the commonality |
6435 | ** of sqlite3VdbeCursorRestore() and sqlite3VdbeIdxRowid(). */ |
6436 | rc = sqlite3VdbeCursorRestore(pC); |
6437 | |
6438 | /* sqlite3VdbeCursorRestore() may fail if the cursor has been disturbed |
6439 | ** since it was last positioned and an error (e.g. OOM or an IO error) |
6440 | ** occurs while trying to reposition it. */ |
6441 | if( rc!=SQLITE_OK ) goto abort_due_to_error; |
6442 | |
6443 | if( !pC->nullRow ){ |
6444 | rowid = 0; /* Not needed. Only used to silence a warning. */ |
6445 | rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid); |
6446 | if( rc!=SQLITE_OK ){ |
6447 | goto abort_due_to_error; |
6448 | } |
6449 | if( pOp->opcode==OP_DeferredSeek ){ |
6450 | assert( pOp->p3>=0 && pOp->p3<p->nCursor ); |
6451 | pTabCur = p->apCsr[pOp->p3]; |
6452 | assert( pTabCur!=0 ); |
6453 | assert( pTabCur->eCurType==CURTYPE_BTREE ); |
6454 | assert( pTabCur->uc.pCursor!=0 ); |
6455 | assert( pTabCur->isTable ); |
6456 | pTabCur->nullRow = 0; |
6457 | pTabCur->movetoTarget = rowid; |
6458 | pTabCur->deferredMoveto = 1; |
6459 | pTabCur->cacheStatus = CACHE_STALE; |
6460 | assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 ); |
6461 | assert( !pTabCur->isEphemeral ); |
6462 | pTabCur->ub.aAltMap = pOp->p4.ai; |
6463 | assert( !pC->isEphemeral ); |
6464 | pTabCur->pAltCursor = pC; |
6465 | }else{ |
6466 | pOut = out2Prerelease(p, pOp); |
6467 | pOut->u.i = rowid; |
6468 | } |
6469 | }else{ |
6470 | assert( pOp->opcode==OP_IdxRowid ); |
6471 | sqlite3VdbeMemSetNull(&aMem[pOp->p2]); |
6472 | } |
6473 | break; |
6474 | } |
6475 | |
6476 | /* Opcode: FinishSeek P1 * * * * |
6477 | ** |
6478 | ** If cursor P1 was previously moved via OP_DeferredSeek, complete that |
6479 | ** seek operation now, without further delay. If the cursor seek has |
6480 | ** already occurred, this instruction is a no-op. |
6481 | */ |
6482 | case OP_FinishSeek: { |
6483 | VdbeCursor *pC; /* The P1 index cursor */ |
6484 | |
6485 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6486 | pC = p->apCsr[pOp->p1]; |
6487 | if( pC->deferredMoveto ){ |
6488 | rc = sqlite3VdbeFinishMoveto(pC); |
6489 | if( rc ) goto abort_due_to_error; |
6490 | } |
6491 | break; |
6492 | } |
6493 | |
6494 | /* Opcode: IdxGE P1 P2 P3 P4 * |
6495 | ** Synopsis: key=r[P3@P4] |
6496 | ** |
6497 | ** The P4 register values beginning with P3 form an unpacked index |
6498 | ** key that omits the PRIMARY KEY. Compare this key value against the index |
6499 | ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID |
6500 | ** fields at the end. |
6501 | ** |
6502 | ** If the P1 index entry is greater than or equal to the key value |
6503 | ** then jump to P2. Otherwise fall through to the next instruction. |
6504 | */ |
6505 | /* Opcode: IdxGT P1 P2 P3 P4 * |
6506 | ** Synopsis: key=r[P3@P4] |
6507 | ** |
6508 | ** The P4 register values beginning with P3 form an unpacked index |
6509 | ** key that omits the PRIMARY KEY. Compare this key value against the index |
6510 | ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID |
6511 | ** fields at the end. |
6512 | ** |
6513 | ** If the P1 index entry is greater than the key value |
6514 | ** then jump to P2. Otherwise fall through to the next instruction. |
6515 | */ |
6516 | /* Opcode: IdxLT P1 P2 P3 P4 * |
6517 | ** Synopsis: key=r[P3@P4] |
6518 | ** |
6519 | ** The P4 register values beginning with P3 form an unpacked index |
6520 | ** key that omits the PRIMARY KEY or ROWID. Compare this key value against |
6521 | ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or |
6522 | ** ROWID on the P1 index. |
6523 | ** |
6524 | ** If the P1 index entry is less than the key value then jump to P2. |
6525 | ** Otherwise fall through to the next instruction. |
6526 | */ |
6527 | /* Opcode: IdxLE P1 P2 P3 P4 * |
6528 | ** Synopsis: key=r[P3@P4] |
6529 | ** |
6530 | ** The P4 register values beginning with P3 form an unpacked index |
6531 | ** key that omits the PRIMARY KEY or ROWID. Compare this key value against |
6532 | ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or |
6533 | ** ROWID on the P1 index. |
6534 | ** |
6535 | ** If the P1 index entry is less than or equal to the key value then jump |
6536 | ** to P2. Otherwise fall through to the next instruction. |
6537 | */ |
6538 | case OP_IdxLE: /* jump */ |
6539 | case OP_IdxGT: /* jump */ |
6540 | case OP_IdxLT: /* jump */ |
6541 | case OP_IdxGE: { /* jump */ |
6542 | VdbeCursor *pC; |
6543 | int res; |
6544 | UnpackedRecord r; |
6545 | |
6546 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6547 | pC = p->apCsr[pOp->p1]; |
6548 | assert( pC!=0 ); |
6549 | assert( pC->isOrdered ); |
6550 | assert( pC->eCurType==CURTYPE_BTREE ); |
6551 | assert( pC->uc.pCursor!=0); |
6552 | assert( pC->deferredMoveto==0 ); |
6553 | assert( pOp->p4type==P4_INT32 ); |
6554 | r.pKeyInfo = pC->pKeyInfo; |
6555 | r.nField = (u16)pOp->p4.i; |
6556 | if( pOp->opcode<OP_IdxLT ){ |
6557 | assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT ); |
6558 | r.default_rc = -1; |
6559 | }else{ |
6560 | assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT ); |
6561 | r.default_rc = 0; |
6562 | } |
6563 | r.aMem = &aMem[pOp->p3]; |
6564 | #ifdef SQLITE_DEBUG |
6565 | { |
6566 | int i; |
6567 | for(i=0; i<r.nField; i++){ |
6568 | assert( memIsValid(&r.aMem[i]) ); |
6569 | REGISTER_TRACE(pOp->p3+i, &aMem[pOp->p3+i]); |
6570 | } |
6571 | } |
6572 | #endif |
6573 | |
6574 | /* Inlined version of sqlite3VdbeIdxKeyCompare() */ |
6575 | { |
6576 | i64 nCellKey = 0; |
6577 | BtCursor *pCur; |
6578 | Mem m; |
6579 | |
6580 | assert( pC->eCurType==CURTYPE_BTREE ); |
6581 | pCur = pC->uc.pCursor; |
6582 | assert( sqlite3BtreeCursorIsValid(pCur) ); |
6583 | nCellKey = sqlite3BtreePayloadSize(pCur); |
6584 | /* nCellKey will always be between 0 and 0xffffffff because of the way |
6585 | ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */ |
6586 | if( nCellKey<=0 || nCellKey>0x7fffffff ){ |
6587 | rc = SQLITE_CORRUPT_BKPT; |
6588 | goto abort_due_to_error; |
6589 | } |
6590 | sqlite3VdbeMemInit(&m, db, 0); |
6591 | rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m); |
6592 | if( rc ) goto abort_due_to_error; |
6593 | res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, &r, 0); |
6594 | sqlite3VdbeMemReleaseMalloc(&m); |
6595 | } |
6596 | /* End of inlined sqlite3VdbeIdxKeyCompare() */ |
6597 | |
6598 | assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) ); |
6599 | if( (pOp->opcode&1)==(OP_IdxLT&1) ){ |
6600 | assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT ); |
6601 | res = -res; |
6602 | }else{ |
6603 | assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT ); |
6604 | res++; |
6605 | } |
6606 | VdbeBranchTaken(res>0,2); |
6607 | assert( rc==SQLITE_OK ); |
6608 | if( res>0 ) goto jump_to_p2; |
6609 | break; |
6610 | } |
6611 | |
6612 | /* Opcode: Destroy P1 P2 P3 * * |
6613 | ** |
6614 | ** Delete an entire database table or index whose root page in the database |
6615 | ** file is given by P1. |
6616 | ** |
6617 | ** The table being destroyed is in the main database file if P3==0. If |
6618 | ** P3==1 then the table to be clear is in the auxiliary database file |
6619 | ** that is used to store tables create using CREATE TEMPORARY TABLE. |
6620 | ** |
6621 | ** If AUTOVACUUM is enabled then it is possible that another root page |
6622 | ** might be moved into the newly deleted root page in order to keep all |
6623 | ** root pages contiguous at the beginning of the database. The former |
6624 | ** value of the root page that moved - its value before the move occurred - |
6625 | ** is stored in register P2. If no page movement was required (because the |
6626 | ** table being dropped was already the last one in the database) then a |
6627 | ** zero is stored in register P2. If AUTOVACUUM is disabled then a zero |
6628 | ** is stored in register P2. |
6629 | ** |
6630 | ** This opcode throws an error if there are any active reader VMs when |
6631 | ** it is invoked. This is done to avoid the difficulty associated with |
6632 | ** updating existing cursors when a root page is moved in an AUTOVACUUM |
6633 | ** database. This error is thrown even if the database is not an AUTOVACUUM |
6634 | ** db in order to avoid introducing an incompatibility between autovacuum |
6635 | ** and non-autovacuum modes. |
6636 | ** |
6637 | ** See also: Clear |
6638 | */ |
6639 | case OP_Destroy: { /* out2 */ |
6640 | int iMoved; |
6641 | int iDb; |
6642 | |
6643 | sqlite3VdbeIncrWriteCounter(p, 0); |
6644 | assert( p->readOnly==0 ); |
6645 | assert( pOp->p1>1 ); |
6646 | pOut = out2Prerelease(p, pOp); |
6647 | pOut->flags = MEM_Null; |
6648 | if( db->nVdbeRead > db->nVDestroy+1 ){ |
6649 | rc = SQLITE_LOCKED; |
6650 | p->errorAction = OE_Abort; |
6651 | goto abort_due_to_error; |
6652 | }else{ |
6653 | iDb = pOp->p3; |
6654 | assert( DbMaskTest(p->btreeMask, iDb) ); |
6655 | iMoved = 0; /* Not needed. Only to silence a warning. */ |
6656 | rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved); |
6657 | pOut->flags = MEM_Int; |
6658 | pOut->u.i = iMoved; |
6659 | if( rc ) goto abort_due_to_error; |
6660 | #ifndef SQLITE_OMIT_AUTOVACUUM |
6661 | if( iMoved!=0 ){ |
6662 | sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1); |
6663 | /* All OP_Destroy operations occur on the same btree */ |
6664 | assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 ); |
6665 | resetSchemaOnFault = iDb+1; |
6666 | } |
6667 | #endif |
6668 | } |
6669 | break; |
6670 | } |
6671 | |
6672 | /* Opcode: Clear P1 P2 P3 |
6673 | ** |
6674 | ** Delete all contents of the database table or index whose root page |
6675 | ** in the database file is given by P1. But, unlike Destroy, do not |
6676 | ** remove the table or index from the database file. |
6677 | ** |
6678 | ** The table being clear is in the main database file if P2==0. If |
6679 | ** P2==1 then the table to be clear is in the auxiliary database file |
6680 | ** that is used to store tables create using CREATE TEMPORARY TABLE. |
6681 | ** |
6682 | ** If the P3 value is non-zero, then the row change count is incremented |
6683 | ** by the number of rows in the table being cleared. If P3 is greater |
6684 | ** than zero, then the value stored in register P3 is also incremented |
6685 | ** by the number of rows in the table being cleared. |
6686 | ** |
6687 | ** See also: Destroy |
6688 | */ |
6689 | case OP_Clear: { |
6690 | i64 nChange; |
6691 | |
6692 | sqlite3VdbeIncrWriteCounter(p, 0); |
6693 | nChange = 0; |
6694 | assert( p->readOnly==0 ); |
6695 | assert( DbMaskTest(p->btreeMask, pOp->p2) ); |
6696 | rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, (u32)pOp->p1, &nChange); |
6697 | if( pOp->p3 ){ |
6698 | p->nChange += nChange; |
6699 | if( pOp->p3>0 ){ |
6700 | assert( memIsValid(&aMem[pOp->p3]) ); |
6701 | memAboutToChange(p, &aMem[pOp->p3]); |
6702 | aMem[pOp->p3].u.i += nChange; |
6703 | } |
6704 | } |
6705 | if( rc ) goto abort_due_to_error; |
6706 | break; |
6707 | } |
6708 | |
6709 | /* Opcode: ResetSorter P1 * * * * |
6710 | ** |
6711 | ** Delete all contents from the ephemeral table or sorter |
6712 | ** that is open on cursor P1. |
6713 | ** |
6714 | ** This opcode only works for cursors used for sorting and |
6715 | ** opened with OP_OpenEphemeral or OP_SorterOpen. |
6716 | */ |
6717 | case OP_ResetSorter: { |
6718 | VdbeCursor *pC; |
6719 | |
6720 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
6721 | pC = p->apCsr[pOp->p1]; |
6722 | assert( pC!=0 ); |
6723 | if( isSorter(pC) ){ |
6724 | sqlite3VdbeSorterReset(db, pC->uc.pSorter); |
6725 | }else{ |
6726 | assert( pC->eCurType==CURTYPE_BTREE ); |
6727 | assert( pC->isEphemeral ); |
6728 | rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor); |
6729 | if( rc ) goto abort_due_to_error; |
6730 | } |
6731 | break; |
6732 | } |
6733 | |
6734 | /* Opcode: CreateBtree P1 P2 P3 * * |
6735 | ** Synopsis: r[P2]=root iDb=P1 flags=P3 |
6736 | ** |
6737 | ** Allocate a new b-tree in the main database file if P1==0 or in the |
6738 | ** TEMP database file if P1==1 or in an attached database if |
6739 | ** P1>1. The P3 argument must be 1 (BTREE_INTKEY) for a rowid table |
6740 | ** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table. |
6741 | ** The root page number of the new b-tree is stored in register P2. |
6742 | */ |
6743 | case OP_CreateBtree: { /* out2 */ |
6744 | Pgno pgno; |
6745 | Db *pDb; |
6746 | |
6747 | sqlite3VdbeIncrWriteCounter(p, 0); |
6748 | pOut = out2Prerelease(p, pOp); |
6749 | pgno = 0; |
6750 | assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY ); |
6751 | assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
6752 | assert( DbMaskTest(p->btreeMask, pOp->p1) ); |
6753 | assert( p->readOnly==0 ); |
6754 | pDb = &db->aDb[pOp->p1]; |
6755 | assert( pDb->pBt!=0 ); |
6756 | rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3); |
6757 | if( rc ) goto abort_due_to_error; |
6758 | pOut->u.i = pgno; |
6759 | break; |
6760 | } |
6761 | |
6762 | /* Opcode: SqlExec * * * P4 * |
6763 | ** |
6764 | ** Run the SQL statement or statements specified in the P4 string. |
6765 | */ |
6766 | case OP_SqlExec: { |
6767 | sqlite3VdbeIncrWriteCounter(p, 0); |
6768 | db->nSqlExec++; |
6769 | rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0); |
6770 | db->nSqlExec--; |
6771 | if( rc ) goto abort_due_to_error; |
6772 | break; |
6773 | } |
6774 | |
6775 | /* Opcode: ParseSchema P1 * * P4 * |
6776 | ** |
6777 | ** Read and parse all entries from the schema table of database P1 |
6778 | ** that match the WHERE clause P4. If P4 is a NULL pointer, then the |
6779 | ** entire schema for P1 is reparsed. |
6780 | ** |
6781 | ** This opcode invokes the parser to create a new virtual machine, |
6782 | ** then runs the new virtual machine. It is thus a re-entrant opcode. |
6783 | */ |
6784 | case OP_ParseSchema: { |
6785 | int iDb; |
6786 | const char *zSchema; |
6787 | char *zSql; |
6788 | InitData initData; |
6789 | |
6790 | /* Any prepared statement that invokes this opcode will hold mutexes |
6791 | ** on every btree. This is a prerequisite for invoking |
6792 | ** sqlite3InitCallback(). |
6793 | */ |
6794 | #ifdef SQLITE_DEBUG |
6795 | for(iDb=0; iDb<db->nDb; iDb++){ |
6796 | assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); |
6797 | } |
6798 | #endif |
6799 | |
6800 | iDb = pOp->p1; |
6801 | assert( iDb>=0 && iDb<db->nDb ); |
6802 | assert( DbHasProperty(db, iDb, DB_SchemaLoaded) |
6803 | || db->mallocFailed |
6804 | || (CORRUPT_DB && (db->flags & SQLITE_NoSchemaError)!=0) ); |
6805 | |
6806 | #ifndef SQLITE_OMIT_ALTERTABLE |
6807 | if( pOp->p4.z==0 ){ |
6808 | sqlite3SchemaClear(db->aDb[iDb].pSchema); |
6809 | db->mDbFlags &= ~DBFLAG_SchemaKnownOk; |
6810 | rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5); |
6811 | db->mDbFlags |= DBFLAG_SchemaChange; |
6812 | p->expired = 0; |
6813 | }else |
6814 | #endif |
6815 | { |
6816 | zSchema = LEGACY_SCHEMA_TABLE; |
6817 | initData.db = db; |
6818 | initData.iDb = iDb; |
6819 | initData.pzErrMsg = &p->zErrMsg; |
6820 | initData.mInitFlags = 0; |
6821 | initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt); |
6822 | zSql = sqlite3MPrintf(db, |
6823 | "SELECT*FROM\"%w\".%s WHERE %s ORDER BY rowid" , |
6824 | db->aDb[iDb].zDbSName, zSchema, pOp->p4.z); |
6825 | if( zSql==0 ){ |
6826 | rc = SQLITE_NOMEM_BKPT; |
6827 | }else{ |
6828 | assert( db->init.busy==0 ); |
6829 | db->init.busy = 1; |
6830 | initData.rc = SQLITE_OK; |
6831 | initData.nInitRow = 0; |
6832 | assert( !db->mallocFailed ); |
6833 | rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); |
6834 | if( rc==SQLITE_OK ) rc = initData.rc; |
6835 | if( rc==SQLITE_OK && initData.nInitRow==0 ){ |
6836 | /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse |
6837 | ** at least one SQL statement. Any less than that indicates that |
6838 | ** the sqlite_schema table is corrupt. */ |
6839 | rc = SQLITE_CORRUPT_BKPT; |
6840 | } |
6841 | sqlite3DbFreeNN(db, zSql); |
6842 | db->init.busy = 0; |
6843 | } |
6844 | } |
6845 | if( rc ){ |
6846 | sqlite3ResetAllSchemasOfConnection(db); |
6847 | if( rc==SQLITE_NOMEM ){ |
6848 | goto no_mem; |
6849 | } |
6850 | goto abort_due_to_error; |
6851 | } |
6852 | break; |
6853 | } |
6854 | |
6855 | #if !defined(SQLITE_OMIT_ANALYZE) |
6856 | /* Opcode: LoadAnalysis P1 * * * * |
6857 | ** |
6858 | ** Read the sqlite_stat1 table for database P1 and load the content |
6859 | ** of that table into the internal index hash table. This will cause |
6860 | ** the analysis to be used when preparing all subsequent queries. |
6861 | */ |
6862 | case OP_LoadAnalysis: { |
6863 | assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
6864 | rc = sqlite3AnalysisLoad(db, pOp->p1); |
6865 | if( rc ) goto abort_due_to_error; |
6866 | break; |
6867 | } |
6868 | #endif /* !defined(SQLITE_OMIT_ANALYZE) */ |
6869 | |
6870 | /* Opcode: DropTable P1 * * P4 * |
6871 | ** |
6872 | ** Remove the internal (in-memory) data structures that describe |
6873 | ** the table named P4 in database P1. This is called after a table |
6874 | ** is dropped from disk (using the Destroy opcode) in order to keep |
6875 | ** the internal representation of the |
6876 | ** schema consistent with what is on disk. |
6877 | */ |
6878 | case OP_DropTable: { |
6879 | sqlite3VdbeIncrWriteCounter(p, 0); |
6880 | sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z); |
6881 | break; |
6882 | } |
6883 | |
6884 | /* Opcode: DropIndex P1 * * P4 * |
6885 | ** |
6886 | ** Remove the internal (in-memory) data structures that describe |
6887 | ** the index named P4 in database P1. This is called after an index |
6888 | ** is dropped from disk (using the Destroy opcode) |
6889 | ** in order to keep the internal representation of the |
6890 | ** schema consistent with what is on disk. |
6891 | */ |
6892 | case OP_DropIndex: { |
6893 | sqlite3VdbeIncrWriteCounter(p, 0); |
6894 | sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z); |
6895 | break; |
6896 | } |
6897 | |
6898 | /* Opcode: DropTrigger P1 * * P4 * |
6899 | ** |
6900 | ** Remove the internal (in-memory) data structures that describe |
6901 | ** the trigger named P4 in database P1. This is called after a trigger |
6902 | ** is dropped from disk (using the Destroy opcode) in order to keep |
6903 | ** the internal representation of the |
6904 | ** schema consistent with what is on disk. |
6905 | */ |
6906 | case OP_DropTrigger: { |
6907 | sqlite3VdbeIncrWriteCounter(p, 0); |
6908 | sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z); |
6909 | break; |
6910 | } |
6911 | |
6912 | |
6913 | #ifndef SQLITE_OMIT_INTEGRITY_CHECK |
6914 | /* Opcode: IntegrityCk P1 P2 P3 P4 P5 |
6915 | ** |
6916 | ** Do an analysis of the currently open database. Store in |
6917 | ** register P1 the text of an error message describing any problems. |
6918 | ** If no problems are found, store a NULL in register P1. |
6919 | ** |
6920 | ** The register P3 contains one less than the maximum number of allowed errors. |
6921 | ** At most reg(P3) errors will be reported. |
6922 | ** In other words, the analysis stops as soon as reg(P1) errors are |
6923 | ** seen. Reg(P1) is updated with the number of errors remaining. |
6924 | ** |
6925 | ** The root page numbers of all tables in the database are integers |
6926 | ** stored in P4_INTARRAY argument. |
6927 | ** |
6928 | ** If P5 is not zero, the check is done on the auxiliary database |
6929 | ** file, not the main database file. |
6930 | ** |
6931 | ** This opcode is used to implement the integrity_check pragma. |
6932 | */ |
6933 | case OP_IntegrityCk: { |
6934 | int nRoot; /* Number of tables to check. (Number of root pages.) */ |
6935 | Pgno *aRoot; /* Array of rootpage numbers for tables to be checked */ |
6936 | int nErr; /* Number of errors reported */ |
6937 | char *z; /* Text of the error report */ |
6938 | Mem *pnErr; /* Register keeping track of errors remaining */ |
6939 | |
6940 | assert( p->bIsReader ); |
6941 | nRoot = pOp->p2; |
6942 | aRoot = pOp->p4.ai; |
6943 | assert( nRoot>0 ); |
6944 | assert( aRoot[0]==(Pgno)nRoot ); |
6945 | assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
6946 | pnErr = &aMem[pOp->p3]; |
6947 | assert( (pnErr->flags & MEM_Int)!=0 ); |
6948 | assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 ); |
6949 | pIn1 = &aMem[pOp->p1]; |
6950 | assert( pOp->p5<db->nDb ); |
6951 | assert( DbMaskTest(p->btreeMask, pOp->p5) ); |
6952 | z = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot, |
6953 | (int)pnErr->u.i+1, &nErr); |
6954 | sqlite3VdbeMemSetNull(pIn1); |
6955 | if( nErr==0 ){ |
6956 | assert( z==0 ); |
6957 | }else if( z==0 ){ |
6958 | goto no_mem; |
6959 | }else{ |
6960 | pnErr->u.i -= nErr-1; |
6961 | sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free); |
6962 | } |
6963 | UPDATE_MAX_BLOBSIZE(pIn1); |
6964 | sqlite3VdbeChangeEncoding(pIn1, encoding); |
6965 | goto check_for_interrupt; |
6966 | } |
6967 | #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ |
6968 | |
6969 | /* Opcode: RowSetAdd P1 P2 * * * |
6970 | ** Synopsis: rowset(P1)=r[P2] |
6971 | ** |
6972 | ** Insert the integer value held by register P2 into a RowSet object |
6973 | ** held in register P1. |
6974 | ** |
6975 | ** An assertion fails if P2 is not an integer. |
6976 | */ |
6977 | case OP_RowSetAdd: { /* in1, in2 */ |
6978 | pIn1 = &aMem[pOp->p1]; |
6979 | pIn2 = &aMem[pOp->p2]; |
6980 | assert( (pIn2->flags & MEM_Int)!=0 ); |
6981 | if( (pIn1->flags & MEM_Blob)==0 ){ |
6982 | if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; |
6983 | } |
6984 | assert( sqlite3VdbeMemIsRowSet(pIn1) ); |
6985 | sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i); |
6986 | break; |
6987 | } |
6988 | |
6989 | /* Opcode: RowSetRead P1 P2 P3 * * |
6990 | ** Synopsis: r[P3]=rowset(P1) |
6991 | ** |
6992 | ** Extract the smallest value from the RowSet object in P1 |
6993 | ** and put that value into register P3. |
6994 | ** Or, if RowSet object P1 is initially empty, leave P3 |
6995 | ** unchanged and jump to instruction P2. |
6996 | */ |
6997 | case OP_RowSetRead: { /* jump, in1, out3 */ |
6998 | i64 val; |
6999 | |
7000 | pIn1 = &aMem[pOp->p1]; |
7001 | assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) ); |
7002 | if( (pIn1->flags & MEM_Blob)==0 |
7003 | || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0 |
7004 | ){ |
7005 | /* The boolean index is empty */ |
7006 | sqlite3VdbeMemSetNull(pIn1); |
7007 | VdbeBranchTaken(1,2); |
7008 | goto jump_to_p2_and_check_for_interrupt; |
7009 | }else{ |
7010 | /* A value was pulled from the index */ |
7011 | VdbeBranchTaken(0,2); |
7012 | sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val); |
7013 | } |
7014 | goto check_for_interrupt; |
7015 | } |
7016 | |
7017 | /* Opcode: RowSetTest P1 P2 P3 P4 |
7018 | ** Synopsis: if r[P3] in rowset(P1) goto P2 |
7019 | ** |
7020 | ** Register P3 is assumed to hold a 64-bit integer value. If register P1 |
7021 | ** contains a RowSet object and that RowSet object contains |
7022 | ** the value held in P3, jump to register P2. Otherwise, insert the |
7023 | ** integer in P3 into the RowSet and continue on to the |
7024 | ** next opcode. |
7025 | ** |
7026 | ** The RowSet object is optimized for the case where sets of integers |
7027 | ** are inserted in distinct phases, which each set contains no duplicates. |
7028 | ** Each set is identified by a unique P4 value. The first set |
7029 | ** must have P4==0, the final set must have P4==-1, and for all other sets |
7030 | ** must have P4>0. |
7031 | ** |
7032 | ** This allows optimizations: (a) when P4==0 there is no need to test |
7033 | ** the RowSet object for P3, as it is guaranteed not to contain it, |
7034 | ** (b) when P4==-1 there is no need to insert the value, as it will |
7035 | ** never be tested for, and (c) when a value that is part of set X is |
7036 | ** inserted, there is no need to search to see if the same value was |
7037 | ** previously inserted as part of set X (only if it was previously |
7038 | ** inserted as part of some other set). |
7039 | */ |
7040 | case OP_RowSetTest: { /* jump, in1, in3 */ |
7041 | int iSet; |
7042 | int exists; |
7043 | |
7044 | pIn1 = &aMem[pOp->p1]; |
7045 | pIn3 = &aMem[pOp->p3]; |
7046 | iSet = pOp->p4.i; |
7047 | assert( pIn3->flags&MEM_Int ); |
7048 | |
7049 | /* If there is anything other than a rowset object in memory cell P1, |
7050 | ** delete it now and initialize P1 with an empty rowset |
7051 | */ |
7052 | if( (pIn1->flags & MEM_Blob)==0 ){ |
7053 | if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; |
7054 | } |
7055 | assert( sqlite3VdbeMemIsRowSet(pIn1) ); |
7056 | assert( pOp->p4type==P4_INT32 ); |
7057 | assert( iSet==-1 || iSet>=0 ); |
7058 | if( iSet ){ |
7059 | exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i); |
7060 | VdbeBranchTaken(exists!=0,2); |
7061 | if( exists ) goto jump_to_p2; |
7062 | } |
7063 | if( iSet>=0 ){ |
7064 | sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i); |
7065 | } |
7066 | break; |
7067 | } |
7068 | |
7069 | |
7070 | #ifndef SQLITE_OMIT_TRIGGER |
7071 | |
7072 | /* Opcode: Program P1 P2 P3 P4 P5 |
7073 | ** |
7074 | ** Execute the trigger program passed as P4 (type P4_SUBPROGRAM). |
7075 | ** |
7076 | ** P1 contains the address of the memory cell that contains the first memory |
7077 | ** cell in an array of values used as arguments to the sub-program. P2 |
7078 | ** contains the address to jump to if the sub-program throws an IGNORE |
7079 | ** exception using the RAISE() function. Register P3 contains the address |
7080 | ** of a memory cell in this (the parent) VM that is used to allocate the |
7081 | ** memory required by the sub-vdbe at runtime. |
7082 | ** |
7083 | ** P4 is a pointer to the VM containing the trigger program. |
7084 | ** |
7085 | ** If P5 is non-zero, then recursive program invocation is enabled. |
7086 | */ |
7087 | case OP_Program: { /* jump */ |
7088 | int nMem; /* Number of memory registers for sub-program */ |
7089 | int nByte; /* Bytes of runtime space required for sub-program */ |
7090 | Mem *pRt; /* Register to allocate runtime space */ |
7091 | Mem *pMem; /* Used to iterate through memory cells */ |
7092 | Mem *pEnd; /* Last memory cell in new array */ |
7093 | VdbeFrame *pFrame; /* New vdbe frame to execute in */ |
7094 | SubProgram *pProgram; /* Sub-program to execute */ |
7095 | void *t; /* Token identifying trigger */ |
7096 | |
7097 | pProgram = pOp->p4.pProgram; |
7098 | pRt = &aMem[pOp->p3]; |
7099 | assert( pProgram->nOp>0 ); |
7100 | |
7101 | /* If the p5 flag is clear, then recursive invocation of triggers is |
7102 | ** disabled for backwards compatibility (p5 is set if this sub-program |
7103 | ** is really a trigger, not a foreign key action, and the flag set |
7104 | ** and cleared by the "PRAGMA recursive_triggers" command is clear). |
7105 | ** |
7106 | ** It is recursive invocation of triggers, at the SQL level, that is |
7107 | ** disabled. In some cases a single trigger may generate more than one |
7108 | ** SubProgram (if the trigger may be executed with more than one different |
7109 | ** ON CONFLICT algorithm). SubProgram structures associated with a |
7110 | ** single trigger all have the same value for the SubProgram.token |
7111 | ** variable. */ |
7112 | if( pOp->p5 ){ |
7113 | t = pProgram->token; |
7114 | for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent); |
7115 | if( pFrame ) break; |
7116 | } |
7117 | |
7118 | if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){ |
7119 | rc = SQLITE_ERROR; |
7120 | sqlite3VdbeError(p, "too many levels of trigger recursion" ); |
7121 | goto abort_due_to_error; |
7122 | } |
7123 | |
7124 | /* Register pRt is used to store the memory required to save the state |
7125 | ** of the current program, and the memory required at runtime to execute |
7126 | ** the trigger program. If this trigger has been fired before, then pRt |
7127 | ** is already allocated. Otherwise, it must be initialized. */ |
7128 | if( (pRt->flags&MEM_Blob)==0 ){ |
7129 | /* SubProgram.nMem is set to the number of memory cells used by the |
7130 | ** program stored in SubProgram.aOp. As well as these, one memory |
7131 | ** cell is required for each cursor used by the program. Set local |
7132 | ** variable nMem (and later, VdbeFrame.nChildMem) to this value. |
7133 | */ |
7134 | nMem = pProgram->nMem + pProgram->nCsr; |
7135 | assert( nMem>0 ); |
7136 | if( pProgram->nCsr==0 ) nMem++; |
7137 | nByte = ROUND8(sizeof(VdbeFrame)) |
7138 | + nMem * sizeof(Mem) |
7139 | + pProgram->nCsr * sizeof(VdbeCursor*) |
7140 | + (pProgram->nOp + 7)/8; |
7141 | pFrame = sqlite3DbMallocZero(db, nByte); |
7142 | if( !pFrame ){ |
7143 | goto no_mem; |
7144 | } |
7145 | sqlite3VdbeMemRelease(pRt); |
7146 | pRt->flags = MEM_Blob|MEM_Dyn; |
7147 | pRt->z = (char*)pFrame; |
7148 | pRt->n = nByte; |
7149 | pRt->xDel = sqlite3VdbeFrameMemDel; |
7150 | |
7151 | pFrame->v = p; |
7152 | pFrame->nChildMem = nMem; |
7153 | pFrame->nChildCsr = pProgram->nCsr; |
7154 | pFrame->pc = (int)(pOp - aOp); |
7155 | pFrame->aMem = p->aMem; |
7156 | pFrame->nMem = p->nMem; |
7157 | pFrame->apCsr = p->apCsr; |
7158 | pFrame->nCursor = p->nCursor; |
7159 | pFrame->aOp = p->aOp; |
7160 | pFrame->nOp = p->nOp; |
7161 | pFrame->token = pProgram->token; |
7162 | #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
7163 | pFrame->anExec = p->anExec; |
7164 | #endif |
7165 | #ifdef SQLITE_DEBUG |
7166 | pFrame->iFrameMagic = SQLITE_FRAME_MAGIC; |
7167 | #endif |
7168 | |
7169 | pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem]; |
7170 | for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){ |
7171 | pMem->flags = MEM_Undefined; |
7172 | pMem->db = db; |
7173 | } |
7174 | }else{ |
7175 | pFrame = (VdbeFrame*)pRt->z; |
7176 | assert( pRt->xDel==sqlite3VdbeFrameMemDel ); |
7177 | assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem |
7178 | || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) ); |
7179 | assert( pProgram->nCsr==pFrame->nChildCsr ); |
7180 | assert( (int)(pOp - aOp)==pFrame->pc ); |
7181 | } |
7182 | |
7183 | p->nFrame++; |
7184 | pFrame->pParent = p->pFrame; |
7185 | pFrame->lastRowid = db->lastRowid; |
7186 | pFrame->nChange = p->nChange; |
7187 | pFrame->nDbChange = p->db->nChange; |
7188 | assert( pFrame->pAuxData==0 ); |
7189 | pFrame->pAuxData = p->pAuxData; |
7190 | p->pAuxData = 0; |
7191 | p->nChange = 0; |
7192 | p->pFrame = pFrame; |
7193 | p->aMem = aMem = VdbeFrameMem(pFrame); |
7194 | p->nMem = pFrame->nChildMem; |
7195 | p->nCursor = (u16)pFrame->nChildCsr; |
7196 | p->apCsr = (VdbeCursor **)&aMem[p->nMem]; |
7197 | pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr]; |
7198 | memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8); |
7199 | p->aOp = aOp = pProgram->aOp; |
7200 | p->nOp = pProgram->nOp; |
7201 | #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
7202 | p->anExec = 0; |
7203 | #endif |
7204 | #ifdef SQLITE_DEBUG |
7205 | /* Verify that second and subsequent executions of the same trigger do not |
7206 | ** try to reuse register values from the first use. */ |
7207 | { |
7208 | int i; |
7209 | for(i=0; i<p->nMem; i++){ |
7210 | aMem[i].pScopyFrom = 0; /* Prevent false-positive AboutToChange() errs */ |
7211 | MemSetTypeFlag(&aMem[i], MEM_Undefined); /* Fault if this reg is reused */ |
7212 | } |
7213 | } |
7214 | #endif |
7215 | pOp = &aOp[-1]; |
7216 | goto check_for_interrupt; |
7217 | } |
7218 | |
7219 | /* Opcode: Param P1 P2 * * * |
7220 | ** |
7221 | ** This opcode is only ever present in sub-programs called via the |
7222 | ** OP_Program instruction. Copy a value currently stored in a memory |
7223 | ** cell of the calling (parent) frame to cell P2 in the current frames |
7224 | ** address space. This is used by trigger programs to access the new.* |
7225 | ** and old.* values. |
7226 | ** |
7227 | ** The address of the cell in the parent frame is determined by adding |
7228 | ** the value of the P1 argument to the value of the P1 argument to the |
7229 | ** calling OP_Program instruction. |
7230 | */ |
7231 | case OP_Param: { /* out2 */ |
7232 | VdbeFrame *pFrame; |
7233 | Mem *pIn; |
7234 | pOut = out2Prerelease(p, pOp); |
7235 | pFrame = p->pFrame; |
7236 | pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1]; |
7237 | sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem); |
7238 | break; |
7239 | } |
7240 | |
7241 | #endif /* #ifndef SQLITE_OMIT_TRIGGER */ |
7242 | |
7243 | #ifndef SQLITE_OMIT_FOREIGN_KEY |
7244 | /* Opcode: FkCounter P1 P2 * * * |
7245 | ** Synopsis: fkctr[P1]+=P2 |
7246 | ** |
7247 | ** Increment a "constraint counter" by P2 (P2 may be negative or positive). |
7248 | ** If P1 is non-zero, the database constraint counter is incremented |
7249 | ** (deferred foreign key constraints). Otherwise, if P1 is zero, the |
7250 | ** statement counter is incremented (immediate foreign key constraints). |
7251 | */ |
7252 | case OP_FkCounter: { |
7253 | if( db->flags & SQLITE_DeferFKs ){ |
7254 | db->nDeferredImmCons += pOp->p2; |
7255 | }else if( pOp->p1 ){ |
7256 | db->nDeferredCons += pOp->p2; |
7257 | }else{ |
7258 | p->nFkConstraint += pOp->p2; |
7259 | } |
7260 | break; |
7261 | } |
7262 | |
7263 | /* Opcode: FkIfZero P1 P2 * * * |
7264 | ** Synopsis: if fkctr[P1]==0 goto P2 |
7265 | ** |
7266 | ** This opcode tests if a foreign key constraint-counter is currently zero. |
7267 | ** If so, jump to instruction P2. Otherwise, fall through to the next |
7268 | ** instruction. |
7269 | ** |
7270 | ** If P1 is non-zero, then the jump is taken if the database constraint-counter |
7271 | ** is zero (the one that counts deferred constraint violations). If P1 is |
7272 | ** zero, the jump is taken if the statement constraint-counter is zero |
7273 | ** (immediate foreign key constraint violations). |
7274 | */ |
7275 | case OP_FkIfZero: { /* jump */ |
7276 | if( pOp->p1 ){ |
7277 | VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2); |
7278 | if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; |
7279 | }else{ |
7280 | VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2); |
7281 | if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; |
7282 | } |
7283 | break; |
7284 | } |
7285 | #endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */ |
7286 | |
7287 | #ifndef SQLITE_OMIT_AUTOINCREMENT |
7288 | /* Opcode: MemMax P1 P2 * * * |
7289 | ** Synopsis: r[P1]=max(r[P1],r[P2]) |
7290 | ** |
7291 | ** P1 is a register in the root frame of this VM (the root frame is |
7292 | ** different from the current frame if this instruction is being executed |
7293 | ** within a sub-program). Set the value of register P1 to the maximum of |
7294 | ** its current value and the value in register P2. |
7295 | ** |
7296 | ** This instruction throws an error if the memory cell is not initially |
7297 | ** an integer. |
7298 | */ |
7299 | case OP_MemMax: { /* in2 */ |
7300 | VdbeFrame *pFrame; |
7301 | if( p->pFrame ){ |
7302 | for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); |
7303 | pIn1 = &pFrame->aMem[pOp->p1]; |
7304 | }else{ |
7305 | pIn1 = &aMem[pOp->p1]; |
7306 | } |
7307 | assert( memIsValid(pIn1) ); |
7308 | sqlite3VdbeMemIntegerify(pIn1); |
7309 | pIn2 = &aMem[pOp->p2]; |
7310 | sqlite3VdbeMemIntegerify(pIn2); |
7311 | if( pIn1->u.i<pIn2->u.i){ |
7312 | pIn1->u.i = pIn2->u.i; |
7313 | } |
7314 | break; |
7315 | } |
7316 | #endif /* SQLITE_OMIT_AUTOINCREMENT */ |
7317 | |
7318 | /* Opcode: IfPos P1 P2 P3 * * |
7319 | ** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 |
7320 | ** |
7321 | ** Register P1 must contain an integer. |
7322 | ** If the value of register P1 is 1 or greater, subtract P3 from the |
7323 | ** value in P1 and jump to P2. |
7324 | ** |
7325 | ** If the initial value of register P1 is less than 1, then the |
7326 | ** value is unchanged and control passes through to the next instruction. |
7327 | */ |
7328 | case OP_IfPos: { /* jump, in1 */ |
7329 | pIn1 = &aMem[pOp->p1]; |
7330 | assert( pIn1->flags&MEM_Int ); |
7331 | VdbeBranchTaken( pIn1->u.i>0, 2); |
7332 | if( pIn1->u.i>0 ){ |
7333 | pIn1->u.i -= pOp->p3; |
7334 | goto jump_to_p2; |
7335 | } |
7336 | break; |
7337 | } |
7338 | |
7339 | /* Opcode: OffsetLimit P1 P2 P3 * * |
7340 | ** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) |
7341 | ** |
7342 | ** This opcode performs a commonly used computation associated with |
7343 | ** LIMIT and OFFSET processing. r[P1] holds the limit counter. r[P3] |
7344 | ** holds the offset counter. The opcode computes the combined value |
7345 | ** of the LIMIT and OFFSET and stores that value in r[P2]. The r[P2] |
7346 | ** value computed is the total number of rows that will need to be |
7347 | ** visited in order to complete the query. |
7348 | ** |
7349 | ** If r[P3] is zero or negative, that means there is no OFFSET |
7350 | ** and r[P2] is set to be the value of the LIMIT, r[P1]. |
7351 | ** |
7352 | ** if r[P1] is zero or negative, that means there is no LIMIT |
7353 | ** and r[P2] is set to -1. |
7354 | ** |
7355 | ** Otherwise, r[P2] is set to the sum of r[P1] and r[P3]. |
7356 | */ |
7357 | case OP_OffsetLimit: { /* in1, out2, in3 */ |
7358 | i64 x; |
7359 | pIn1 = &aMem[pOp->p1]; |
7360 | pIn3 = &aMem[pOp->p3]; |
7361 | pOut = out2Prerelease(p, pOp); |
7362 | assert( pIn1->flags & MEM_Int ); |
7363 | assert( pIn3->flags & MEM_Int ); |
7364 | x = pIn1->u.i; |
7365 | if( x<=0 || sqlite3AddInt64(&x, pIn3->u.i>0?pIn3->u.i:0) ){ |
7366 | /* If the LIMIT is less than or equal to zero, loop forever. This |
7367 | ** is documented. But also, if the LIMIT+OFFSET exceeds 2^63 then |
7368 | ** also loop forever. This is undocumented. In fact, one could argue |
7369 | ** that the loop should terminate. But assuming 1 billion iterations |
7370 | ** per second (far exceeding the capabilities of any current hardware) |
7371 | ** it would take nearly 300 years to actually reach the limit. So |
7372 | ** looping forever is a reasonable approximation. */ |
7373 | pOut->u.i = -1; |
7374 | }else{ |
7375 | pOut->u.i = x; |
7376 | } |
7377 | break; |
7378 | } |
7379 | |
7380 | /* Opcode: IfNotZero P1 P2 * * * |
7381 | ** Synopsis: if r[P1]!=0 then r[P1]--, goto P2 |
7382 | ** |
7383 | ** Register P1 must contain an integer. If the content of register P1 is |
7384 | ** initially greater than zero, then decrement the value in register P1. |
7385 | ** If it is non-zero (negative or positive) and then also jump to P2. |
7386 | ** If register P1 is initially zero, leave it unchanged and fall through. |
7387 | */ |
7388 | case OP_IfNotZero: { /* jump, in1 */ |
7389 | pIn1 = &aMem[pOp->p1]; |
7390 | assert( pIn1->flags&MEM_Int ); |
7391 | VdbeBranchTaken(pIn1->u.i<0, 2); |
7392 | if( pIn1->u.i ){ |
7393 | if( pIn1->u.i>0 ) pIn1->u.i--; |
7394 | goto jump_to_p2; |
7395 | } |
7396 | break; |
7397 | } |
7398 | |
7399 | /* Opcode: DecrJumpZero P1 P2 * * * |
7400 | ** Synopsis: if (--r[P1])==0 goto P2 |
7401 | ** |
7402 | ** Register P1 must hold an integer. Decrement the value in P1 |
7403 | ** and jump to P2 if the new value is exactly zero. |
7404 | */ |
7405 | case OP_DecrJumpZero: { /* jump, in1 */ |
7406 | pIn1 = &aMem[pOp->p1]; |
7407 | assert( pIn1->flags&MEM_Int ); |
7408 | if( pIn1->u.i>SMALLEST_INT64 ) pIn1->u.i--; |
7409 | VdbeBranchTaken(pIn1->u.i==0, 2); |
7410 | if( pIn1->u.i==0 ) goto jump_to_p2; |
7411 | break; |
7412 | } |
7413 | |
7414 | |
7415 | /* Opcode: AggStep * P2 P3 P4 P5 |
7416 | ** Synopsis: accum=r[P3] step(r[P2@P5]) |
7417 | ** |
7418 | ** Execute the xStep function for an aggregate. |
7419 | ** The function has P5 arguments. P4 is a pointer to the |
7420 | ** FuncDef structure that specifies the function. Register P3 is the |
7421 | ** accumulator. |
7422 | ** |
7423 | ** The P5 arguments are taken from register P2 and its |
7424 | ** successors. |
7425 | */ |
7426 | /* Opcode: AggInverse * P2 P3 P4 P5 |
7427 | ** Synopsis: accum=r[P3] inverse(r[P2@P5]) |
7428 | ** |
7429 | ** Execute the xInverse function for an aggregate. |
7430 | ** The function has P5 arguments. P4 is a pointer to the |
7431 | ** FuncDef structure that specifies the function. Register P3 is the |
7432 | ** accumulator. |
7433 | ** |
7434 | ** The P5 arguments are taken from register P2 and its |
7435 | ** successors. |
7436 | */ |
7437 | /* Opcode: AggStep1 P1 P2 P3 P4 P5 |
7438 | ** Synopsis: accum=r[P3] step(r[P2@P5]) |
7439 | ** |
7440 | ** Execute the xStep (if P1==0) or xInverse (if P1!=0) function for an |
7441 | ** aggregate. The function has P5 arguments. P4 is a pointer to the |
7442 | ** FuncDef structure that specifies the function. Register P3 is the |
7443 | ** accumulator. |
7444 | ** |
7445 | ** The P5 arguments are taken from register P2 and its |
7446 | ** successors. |
7447 | ** |
7448 | ** This opcode is initially coded as OP_AggStep0. On first evaluation, |
7449 | ** the FuncDef stored in P4 is converted into an sqlite3_context and |
7450 | ** the opcode is changed. In this way, the initialization of the |
7451 | ** sqlite3_context only happens once, instead of on each call to the |
7452 | ** step function. |
7453 | */ |
7454 | case OP_AggInverse: |
7455 | case OP_AggStep: { |
7456 | int n; |
7457 | sqlite3_context *pCtx; |
7458 | |
7459 | assert( pOp->p4type==P4_FUNCDEF ); |
7460 | n = pOp->p5; |
7461 | assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
7462 | assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) ); |
7463 | assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n ); |
7464 | pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) + |
7465 | (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*))); |
7466 | if( pCtx==0 ) goto no_mem; |
7467 | pCtx->pMem = 0; |
7468 | pCtx->pOut = (Mem*)&(pCtx->argv[n]); |
7469 | sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null); |
7470 | pCtx->pFunc = pOp->p4.pFunc; |
7471 | pCtx->iOp = (int)(pOp - aOp); |
7472 | pCtx->pVdbe = p; |
7473 | pCtx->skipFlag = 0; |
7474 | pCtx->isError = 0; |
7475 | pCtx->enc = encoding; |
7476 | pCtx->argc = n; |
7477 | pOp->p4type = P4_FUNCCTX; |
7478 | pOp->p4.pCtx = pCtx; |
7479 | |
7480 | /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */ |
7481 | assert( pOp->p1==(pOp->opcode==OP_AggInverse) ); |
7482 | |
7483 | pOp->opcode = OP_AggStep1; |
7484 | /* Fall through into OP_AggStep */ |
7485 | /* no break */ deliberate_fall_through |
7486 | } |
7487 | case OP_AggStep1: { |
7488 | int i; |
7489 | sqlite3_context *pCtx; |
7490 | Mem *pMem; |
7491 | |
7492 | assert( pOp->p4type==P4_FUNCCTX ); |
7493 | pCtx = pOp->p4.pCtx; |
7494 | pMem = &aMem[pOp->p3]; |
7495 | |
7496 | #ifdef SQLITE_DEBUG |
7497 | if( pOp->p1 ){ |
7498 | /* This is an OP_AggInverse call. Verify that xStep has always |
7499 | ** been called at least once prior to any xInverse call. */ |
7500 | assert( pMem->uTemp==0x1122e0e3 ); |
7501 | }else{ |
7502 | /* This is an OP_AggStep call. Mark it as such. */ |
7503 | pMem->uTemp = 0x1122e0e3; |
7504 | } |
7505 | #endif |
7506 | |
7507 | /* If this function is inside of a trigger, the register array in aMem[] |
7508 | ** might change from one evaluation to the next. The next block of code |
7509 | ** checks to see if the register array has changed, and if so it |
7510 | ** reinitializes the relavant parts of the sqlite3_context object */ |
7511 | if( pCtx->pMem != pMem ){ |
7512 | pCtx->pMem = pMem; |
7513 | for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; |
7514 | } |
7515 | |
7516 | #ifdef SQLITE_DEBUG |
7517 | for(i=0; i<pCtx->argc; i++){ |
7518 | assert( memIsValid(pCtx->argv[i]) ); |
7519 | REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); |
7520 | } |
7521 | #endif |
7522 | |
7523 | pMem->n++; |
7524 | assert( pCtx->pOut->flags==MEM_Null ); |
7525 | assert( pCtx->isError==0 ); |
7526 | assert( pCtx->skipFlag==0 ); |
7527 | #ifndef SQLITE_OMIT_WINDOWFUNC |
7528 | if( pOp->p1 ){ |
7529 | (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv); |
7530 | }else |
7531 | #endif |
7532 | (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */ |
7533 | |
7534 | if( pCtx->isError ){ |
7535 | if( pCtx->isError>0 ){ |
7536 | sqlite3VdbeError(p, "%s" , sqlite3_value_text(pCtx->pOut)); |
7537 | rc = pCtx->isError; |
7538 | } |
7539 | if( pCtx->skipFlag ){ |
7540 | assert( pOp[-1].opcode==OP_CollSeq ); |
7541 | i = pOp[-1].p1; |
7542 | if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1); |
7543 | pCtx->skipFlag = 0; |
7544 | } |
7545 | sqlite3VdbeMemRelease(pCtx->pOut); |
7546 | pCtx->pOut->flags = MEM_Null; |
7547 | pCtx->isError = 0; |
7548 | if( rc ) goto abort_due_to_error; |
7549 | } |
7550 | assert( pCtx->pOut->flags==MEM_Null ); |
7551 | assert( pCtx->skipFlag==0 ); |
7552 | break; |
7553 | } |
7554 | |
7555 | /* Opcode: AggFinal P1 P2 * P4 * |
7556 | ** Synopsis: accum=r[P1] N=P2 |
7557 | ** |
7558 | ** P1 is the memory location that is the accumulator for an aggregate |
7559 | ** or window function. Execute the finalizer function |
7560 | ** for an aggregate and store the result in P1. |
7561 | ** |
7562 | ** P2 is the number of arguments that the step function takes and |
7563 | ** P4 is a pointer to the FuncDef for this function. The P2 |
7564 | ** argument is not used by this opcode. It is only there to disambiguate |
7565 | ** functions that can take varying numbers of arguments. The |
7566 | ** P4 argument is only needed for the case where |
7567 | ** the step function was not previously called. |
7568 | */ |
7569 | /* Opcode: AggValue * P2 P3 P4 * |
7570 | ** Synopsis: r[P3]=value N=P2 |
7571 | ** |
7572 | ** Invoke the xValue() function and store the result in register P3. |
7573 | ** |
7574 | ** P2 is the number of arguments that the step function takes and |
7575 | ** P4 is a pointer to the FuncDef for this function. The P2 |
7576 | ** argument is not used by this opcode. It is only there to disambiguate |
7577 | ** functions that can take varying numbers of arguments. The |
7578 | ** P4 argument is only needed for the case where |
7579 | ** the step function was not previously called. |
7580 | */ |
7581 | case OP_AggValue: |
7582 | case OP_AggFinal: { |
7583 | Mem *pMem; |
7584 | assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
7585 | assert( pOp->p3==0 || pOp->opcode==OP_AggValue ); |
7586 | pMem = &aMem[pOp->p1]; |
7587 | assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 ); |
7588 | #ifndef SQLITE_OMIT_WINDOWFUNC |
7589 | if( pOp->p3 ){ |
7590 | memAboutToChange(p, &aMem[pOp->p3]); |
7591 | rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc); |
7592 | pMem = &aMem[pOp->p3]; |
7593 | }else |
7594 | #endif |
7595 | { |
7596 | rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc); |
7597 | } |
7598 | |
7599 | if( rc ){ |
7600 | sqlite3VdbeError(p, "%s" , sqlite3_value_text(pMem)); |
7601 | goto abort_due_to_error; |
7602 | } |
7603 | sqlite3VdbeChangeEncoding(pMem, encoding); |
7604 | UPDATE_MAX_BLOBSIZE(pMem); |
7605 | break; |
7606 | } |
7607 | |
7608 | #ifndef SQLITE_OMIT_WAL |
7609 | /* Opcode: Checkpoint P1 P2 P3 * * |
7610 | ** |
7611 | ** Checkpoint database P1. This is a no-op if P1 is not currently in |
7612 | ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL, |
7613 | ** RESTART, or TRUNCATE. Write 1 or 0 into mem[P3] if the checkpoint returns |
7614 | ** SQLITE_BUSY or not, respectively. Write the number of pages in the |
7615 | ** WAL after the checkpoint into mem[P3+1] and the number of pages |
7616 | ** in the WAL that have been checkpointed after the checkpoint |
7617 | ** completes into mem[P3+2]. However on an error, mem[P3+1] and |
7618 | ** mem[P3+2] are initialized to -1. |
7619 | */ |
7620 | case OP_Checkpoint: { |
7621 | int i; /* Loop counter */ |
7622 | int aRes[3]; /* Results */ |
7623 | Mem *pMem; /* Write results here */ |
7624 | |
7625 | assert( p->readOnly==0 ); |
7626 | aRes[0] = 0; |
7627 | aRes[1] = aRes[2] = -1; |
7628 | assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE |
7629 | || pOp->p2==SQLITE_CHECKPOINT_FULL |
7630 | || pOp->p2==SQLITE_CHECKPOINT_RESTART |
7631 | || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE |
7632 | ); |
7633 | rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]); |
7634 | if( rc ){ |
7635 | if( rc!=SQLITE_BUSY ) goto abort_due_to_error; |
7636 | rc = SQLITE_OK; |
7637 | aRes[0] = 1; |
7638 | } |
7639 | for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){ |
7640 | sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]); |
7641 | } |
7642 | break; |
7643 | }; |
7644 | #endif |
7645 | |
7646 | #ifndef SQLITE_OMIT_PRAGMA |
7647 | /* Opcode: JournalMode P1 P2 P3 * * |
7648 | ** |
7649 | ** Change the journal mode of database P1 to P3. P3 must be one of the |
7650 | ** PAGER_JOURNALMODE_XXX values. If changing between the various rollback |
7651 | ** modes (delete, truncate, persist, off and memory), this is a simple |
7652 | ** operation. No IO is required. |
7653 | ** |
7654 | ** If changing into or out of WAL mode the procedure is more complicated. |
7655 | ** |
7656 | ** Write a string containing the final journal-mode to register P2. |
7657 | */ |
7658 | case OP_JournalMode: { /* out2 */ |
7659 | Btree *pBt; /* Btree to change journal mode of */ |
7660 | Pager *; /* Pager associated with pBt */ |
7661 | int eNew; /* New journal mode */ |
7662 | int eOld; /* The old journal mode */ |
7663 | #ifndef SQLITE_OMIT_WAL |
7664 | const char *zFilename; /* Name of database file for pPager */ |
7665 | #endif |
7666 | |
7667 | pOut = out2Prerelease(p, pOp); |
7668 | eNew = pOp->p3; |
7669 | assert( eNew==PAGER_JOURNALMODE_DELETE |
7670 | || eNew==PAGER_JOURNALMODE_TRUNCATE |
7671 | || eNew==PAGER_JOURNALMODE_PERSIST |
7672 | || eNew==PAGER_JOURNALMODE_OFF |
7673 | || eNew==PAGER_JOURNALMODE_MEMORY |
7674 | || eNew==PAGER_JOURNALMODE_WAL |
7675 | || eNew==PAGER_JOURNALMODE_QUERY |
7676 | ); |
7677 | assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
7678 | assert( p->readOnly==0 ); |
7679 | |
7680 | pBt = db->aDb[pOp->p1].pBt; |
7681 | pPager = sqlite3BtreePager(pBt); |
7682 | eOld = sqlite3PagerGetJournalMode(pPager); |
7683 | if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld; |
7684 | assert( sqlite3BtreeHoldsMutex(pBt) ); |
7685 | if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld; |
7686 | |
7687 | #ifndef SQLITE_OMIT_WAL |
7688 | zFilename = sqlite3PagerFilename(pPager, 1); |
7689 | |
7690 | /* Do not allow a transition to journal_mode=WAL for a database |
7691 | ** in temporary storage or if the VFS does not support shared memory |
7692 | */ |
7693 | if( eNew==PAGER_JOURNALMODE_WAL |
7694 | && (sqlite3Strlen30(zFilename)==0 /* Temp file */ |
7695 | || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */ |
7696 | ){ |
7697 | eNew = eOld; |
7698 | } |
7699 | |
7700 | if( (eNew!=eOld) |
7701 | && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL) |
7702 | ){ |
7703 | if( !db->autoCommit || db->nVdbeRead>1 ){ |
7704 | rc = SQLITE_ERROR; |
7705 | sqlite3VdbeError(p, |
7706 | "cannot change %s wal mode from within a transaction" , |
7707 | (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of" ) |
7708 | ); |
7709 | goto abort_due_to_error; |
7710 | }else{ |
7711 | |
7712 | if( eOld==PAGER_JOURNALMODE_WAL ){ |
7713 | /* If leaving WAL mode, close the log file. If successful, the call |
7714 | ** to PagerCloseWal() checkpoints and deletes the write-ahead-log |
7715 | ** file. An EXCLUSIVE lock may still be held on the database file |
7716 | ** after a successful return. |
7717 | */ |
7718 | rc = sqlite3PagerCloseWal(pPager, db); |
7719 | if( rc==SQLITE_OK ){ |
7720 | sqlite3PagerSetJournalMode(pPager, eNew); |
7721 | } |
7722 | }else if( eOld==PAGER_JOURNALMODE_MEMORY ){ |
7723 | /* Cannot transition directly from MEMORY to WAL. Use mode OFF |
7724 | ** as an intermediate */ |
7725 | sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF); |
7726 | } |
7727 | |
7728 | /* Open a transaction on the database file. Regardless of the journal |
7729 | ** mode, this transaction always uses a rollback journal. |
7730 | */ |
7731 | assert( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_WRITE ); |
7732 | if( rc==SQLITE_OK ){ |
7733 | rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1)); |
7734 | } |
7735 | } |
7736 | } |
7737 | #endif /* ifndef SQLITE_OMIT_WAL */ |
7738 | |
7739 | if( rc ) eNew = eOld; |
7740 | eNew = sqlite3PagerSetJournalMode(pPager, eNew); |
7741 | |
7742 | pOut->flags = MEM_Str|MEM_Static|MEM_Term; |
7743 | pOut->z = (char *)sqlite3JournalModename(eNew); |
7744 | pOut->n = sqlite3Strlen30(pOut->z); |
7745 | pOut->enc = SQLITE_UTF8; |
7746 | sqlite3VdbeChangeEncoding(pOut, encoding); |
7747 | if( rc ) goto abort_due_to_error; |
7748 | break; |
7749 | }; |
7750 | #endif /* SQLITE_OMIT_PRAGMA */ |
7751 | |
7752 | #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH) |
7753 | /* Opcode: Vacuum P1 P2 * * * |
7754 | ** |
7755 | ** Vacuum the entire database P1. P1 is 0 for "main", and 2 or more |
7756 | ** for an attached database. The "temp" database may not be vacuumed. |
7757 | ** |
7758 | ** If P2 is not zero, then it is a register holding a string which is |
7759 | ** the file into which the result of vacuum should be written. When |
7760 | ** P2 is zero, the vacuum overwrites the original database. |
7761 | */ |
7762 | case OP_Vacuum: { |
7763 | assert( p->readOnly==0 ); |
7764 | rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1, |
7765 | pOp->p2 ? &aMem[pOp->p2] : 0); |
7766 | if( rc ) goto abort_due_to_error; |
7767 | break; |
7768 | } |
7769 | #endif |
7770 | |
7771 | #if !defined(SQLITE_OMIT_AUTOVACUUM) |
7772 | /* Opcode: IncrVacuum P1 P2 * * * |
7773 | ** |
7774 | ** Perform a single step of the incremental vacuum procedure on |
7775 | ** the P1 database. If the vacuum has finished, jump to instruction |
7776 | ** P2. Otherwise, fall through to the next instruction. |
7777 | */ |
7778 | case OP_IncrVacuum: { /* jump */ |
7779 | Btree *pBt; |
7780 | |
7781 | assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
7782 | assert( DbMaskTest(p->btreeMask, pOp->p1) ); |
7783 | assert( p->readOnly==0 ); |
7784 | pBt = db->aDb[pOp->p1].pBt; |
7785 | rc = sqlite3BtreeIncrVacuum(pBt); |
7786 | VdbeBranchTaken(rc==SQLITE_DONE,2); |
7787 | if( rc ){ |
7788 | if( rc!=SQLITE_DONE ) goto abort_due_to_error; |
7789 | rc = SQLITE_OK; |
7790 | goto jump_to_p2; |
7791 | } |
7792 | break; |
7793 | } |
7794 | #endif |
7795 | |
7796 | /* Opcode: Expire P1 P2 * * * |
7797 | ** |
7798 | ** Cause precompiled statements to expire. When an expired statement |
7799 | ** is executed using sqlite3_step() it will either automatically |
7800 | ** reprepare itself (if it was originally created using sqlite3_prepare_v2()) |
7801 | ** or it will fail with SQLITE_SCHEMA. |
7802 | ** |
7803 | ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero, |
7804 | ** then only the currently executing statement is expired. |
7805 | ** |
7806 | ** If P2 is 0, then SQL statements are expired immediately. If P2 is 1, |
7807 | ** then running SQL statements are allowed to continue to run to completion. |
7808 | ** The P2==1 case occurs when a CREATE INDEX or similar schema change happens |
7809 | ** that might help the statement run faster but which does not affect the |
7810 | ** correctness of operation. |
7811 | */ |
7812 | case OP_Expire: { |
7813 | assert( pOp->p2==0 || pOp->p2==1 ); |
7814 | if( !pOp->p1 ){ |
7815 | sqlite3ExpirePreparedStatements(db, pOp->p2); |
7816 | }else{ |
7817 | p->expired = pOp->p2+1; |
7818 | } |
7819 | break; |
7820 | } |
7821 | |
7822 | /* Opcode: CursorLock P1 * * * * |
7823 | ** |
7824 | ** Lock the btree to which cursor P1 is pointing so that the btree cannot be |
7825 | ** written by an other cursor. |
7826 | */ |
7827 | case OP_CursorLock: { |
7828 | VdbeCursor *pC; |
7829 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
7830 | pC = p->apCsr[pOp->p1]; |
7831 | assert( pC!=0 ); |
7832 | assert( pC->eCurType==CURTYPE_BTREE ); |
7833 | sqlite3BtreeCursorPin(pC->uc.pCursor); |
7834 | break; |
7835 | } |
7836 | |
7837 | /* Opcode: CursorUnlock P1 * * * * |
7838 | ** |
7839 | ** Unlock the btree to which cursor P1 is pointing so that it can be |
7840 | ** written by other cursors. |
7841 | */ |
7842 | case OP_CursorUnlock: { |
7843 | VdbeCursor *pC; |
7844 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
7845 | pC = p->apCsr[pOp->p1]; |
7846 | assert( pC!=0 ); |
7847 | assert( pC->eCurType==CURTYPE_BTREE ); |
7848 | sqlite3BtreeCursorUnpin(pC->uc.pCursor); |
7849 | break; |
7850 | } |
7851 | |
7852 | #ifndef SQLITE_OMIT_SHARED_CACHE |
7853 | /* Opcode: TableLock P1 P2 P3 P4 * |
7854 | ** Synopsis: iDb=P1 root=P2 write=P3 |
7855 | ** |
7856 | ** Obtain a lock on a particular table. This instruction is only used when |
7857 | ** the shared-cache feature is enabled. |
7858 | ** |
7859 | ** P1 is the index of the database in sqlite3.aDb[] of the database |
7860 | ** on which the lock is acquired. A readlock is obtained if P3==0 or |
7861 | ** a write lock if P3==1. |
7862 | ** |
7863 | ** P2 contains the root-page of the table to lock. |
7864 | ** |
7865 | ** P4 contains a pointer to the name of the table being locked. This is only |
7866 | ** used to generate an error message if the lock cannot be obtained. |
7867 | */ |
7868 | case OP_TableLock: { |
7869 | u8 isWriteLock = (u8)pOp->p3; |
7870 | if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){ |
7871 | int p1 = pOp->p1; |
7872 | assert( p1>=0 && p1<db->nDb ); |
7873 | assert( DbMaskTest(p->btreeMask, p1) ); |
7874 | assert( isWriteLock==0 || isWriteLock==1 ); |
7875 | rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock); |
7876 | if( rc ){ |
7877 | if( (rc&0xFF)==SQLITE_LOCKED ){ |
7878 | const char *z = pOp->p4.z; |
7879 | sqlite3VdbeError(p, "database table is locked: %s" , z); |
7880 | } |
7881 | goto abort_due_to_error; |
7882 | } |
7883 | } |
7884 | break; |
7885 | } |
7886 | #endif /* SQLITE_OMIT_SHARED_CACHE */ |
7887 | |
7888 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
7889 | /* Opcode: VBegin * * * P4 * |
7890 | ** |
7891 | ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the |
7892 | ** xBegin method for that table. |
7893 | ** |
7894 | ** Also, whether or not P4 is set, check that this is not being called from |
7895 | ** within a callback to a virtual table xSync() method. If it is, the error |
7896 | ** code will be set to SQLITE_LOCKED. |
7897 | */ |
7898 | case OP_VBegin: { |
7899 | VTable *pVTab; |
7900 | pVTab = pOp->p4.pVtab; |
7901 | rc = sqlite3VtabBegin(db, pVTab); |
7902 | if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab); |
7903 | if( rc ) goto abort_due_to_error; |
7904 | break; |
7905 | } |
7906 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
7907 | |
7908 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
7909 | /* Opcode: VCreate P1 P2 * * * |
7910 | ** |
7911 | ** P2 is a register that holds the name of a virtual table in database |
7912 | ** P1. Call the xCreate method for that table. |
7913 | */ |
7914 | case OP_VCreate: { |
7915 | Mem sMem; /* For storing the record being decoded */ |
7916 | const char *zTab; /* Name of the virtual table */ |
7917 | |
7918 | memset(&sMem, 0, sizeof(sMem)); |
7919 | sMem.db = db; |
7920 | /* Because P2 is always a static string, it is impossible for the |
7921 | ** sqlite3VdbeMemCopy() to fail */ |
7922 | assert( (aMem[pOp->p2].flags & MEM_Str)!=0 ); |
7923 | assert( (aMem[pOp->p2].flags & MEM_Static)!=0 ); |
7924 | rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]); |
7925 | assert( rc==SQLITE_OK ); |
7926 | zTab = (const char*)sqlite3_value_text(&sMem); |
7927 | assert( zTab || db->mallocFailed ); |
7928 | if( zTab ){ |
7929 | rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg); |
7930 | } |
7931 | sqlite3VdbeMemRelease(&sMem); |
7932 | if( rc ) goto abort_due_to_error; |
7933 | break; |
7934 | } |
7935 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
7936 | |
7937 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
7938 | /* Opcode: VDestroy P1 * * P4 * |
7939 | ** |
7940 | ** P4 is the name of a virtual table in database P1. Call the xDestroy method |
7941 | ** of that table. |
7942 | */ |
7943 | case OP_VDestroy: { |
7944 | db->nVDestroy++; |
7945 | rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z); |
7946 | db->nVDestroy--; |
7947 | assert( p->errorAction==OE_Abort && p->usesStmtJournal ); |
7948 | if( rc ) goto abort_due_to_error; |
7949 | break; |
7950 | } |
7951 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
7952 | |
7953 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
7954 | /* Opcode: VOpen P1 * * P4 * |
7955 | ** |
7956 | ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. |
7957 | ** P1 is a cursor number. This opcode opens a cursor to the virtual |
7958 | ** table and stores that cursor in P1. |
7959 | */ |
7960 | case OP_VOpen: { |
7961 | VdbeCursor *pCur; |
7962 | sqlite3_vtab_cursor *pVCur; |
7963 | sqlite3_vtab *pVtab; |
7964 | const sqlite3_module *pModule; |
7965 | |
7966 | assert( p->bIsReader ); |
7967 | pCur = 0; |
7968 | pVCur = 0; |
7969 | pVtab = pOp->p4.pVtab->pVtab; |
7970 | if( pVtab==0 || NEVER(pVtab->pModule==0) ){ |
7971 | rc = SQLITE_LOCKED; |
7972 | goto abort_due_to_error; |
7973 | } |
7974 | pModule = pVtab->pModule; |
7975 | rc = pModule->xOpen(pVtab, &pVCur); |
7976 | sqlite3VtabImportErrmsg(p, pVtab); |
7977 | if( rc ) goto abort_due_to_error; |
7978 | |
7979 | /* Initialize sqlite3_vtab_cursor base class */ |
7980 | pVCur->pVtab = pVtab; |
7981 | |
7982 | /* Initialize vdbe cursor object */ |
7983 | pCur = allocateCursor(p, pOp->p1, 0, CURTYPE_VTAB); |
7984 | if( pCur ){ |
7985 | pCur->uc.pVCur = pVCur; |
7986 | pVtab->nRef++; |
7987 | }else{ |
7988 | assert( db->mallocFailed ); |
7989 | pModule->xClose(pVCur); |
7990 | goto no_mem; |
7991 | } |
7992 | break; |
7993 | } |
7994 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
7995 | |
7996 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
7997 | /* Opcode: VInitIn P1 P2 P3 * * |
7998 | ** Synopsis: r[P2]=ValueList(P1,P3) |
7999 | ** |
8000 | ** Set register P2 to be a pointer to a ValueList object for cursor P1 |
8001 | ** with cache register P3 and output register P3+1. This ValueList object |
8002 | ** can be used as the first argument to sqlite3_vtab_in_first() and |
8003 | ** sqlite3_vtab_in_next() to extract all of the values stored in the P1 |
8004 | ** cursor. Register P3 is used to hold the values returned by |
8005 | ** sqlite3_vtab_in_first() and sqlite3_vtab_in_next(). |
8006 | */ |
8007 | case OP_VInitIn: { /* out2 */ |
8008 | VdbeCursor *pC; /* The cursor containing the RHS values */ |
8009 | ValueList *pRhs; /* New ValueList object to put in reg[P2] */ |
8010 | |
8011 | pC = p->apCsr[pOp->p1]; |
8012 | pRhs = sqlite3_malloc64( sizeof(*pRhs) ); |
8013 | if( pRhs==0 ) goto no_mem; |
8014 | pRhs->pCsr = pC->uc.pCursor; |
8015 | pRhs->pOut = &aMem[pOp->p3]; |
8016 | pOut = out2Prerelease(p, pOp); |
8017 | pOut->flags = MEM_Null; |
8018 | sqlite3VdbeMemSetPointer(pOut, pRhs, "ValueList" , sqlite3_free); |
8019 | break; |
8020 | } |
8021 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
8022 | |
8023 | |
8024 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
8025 | /* Opcode: VFilter P1 P2 P3 P4 * |
8026 | ** Synopsis: iplan=r[P3] zplan='P4' |
8027 | ** |
8028 | ** P1 is a cursor opened using VOpen. P2 is an address to jump to if |
8029 | ** the filtered result set is empty. |
8030 | ** |
8031 | ** P4 is either NULL or a string that was generated by the xBestIndex |
8032 | ** method of the module. The interpretation of the P4 string is left |
8033 | ** to the module implementation. |
8034 | ** |
8035 | ** This opcode invokes the xFilter method on the virtual table specified |
8036 | ** by P1. The integer query plan parameter to xFilter is stored in register |
8037 | ** P3. Register P3+1 stores the argc parameter to be passed to the |
8038 | ** xFilter method. Registers P3+2..P3+1+argc are the argc |
8039 | ** additional parameters which are passed to |
8040 | ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter. |
8041 | ** |
8042 | ** A jump is made to P2 if the result set after filtering would be empty. |
8043 | */ |
8044 | case OP_VFilter: { /* jump */ |
8045 | int nArg; |
8046 | int iQuery; |
8047 | const sqlite3_module *pModule; |
8048 | Mem *pQuery; |
8049 | Mem *pArgc; |
8050 | sqlite3_vtab_cursor *pVCur; |
8051 | sqlite3_vtab *pVtab; |
8052 | VdbeCursor *pCur; |
8053 | int res; |
8054 | int i; |
8055 | Mem **apArg; |
8056 | |
8057 | pQuery = &aMem[pOp->p3]; |
8058 | pArgc = &pQuery[1]; |
8059 | pCur = p->apCsr[pOp->p1]; |
8060 | assert( memIsValid(pQuery) ); |
8061 | REGISTER_TRACE(pOp->p3, pQuery); |
8062 | assert( pCur!=0 ); |
8063 | assert( pCur->eCurType==CURTYPE_VTAB ); |
8064 | pVCur = pCur->uc.pVCur; |
8065 | pVtab = pVCur->pVtab; |
8066 | pModule = pVtab->pModule; |
8067 | |
8068 | /* Grab the index number and argc parameters */ |
8069 | assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int ); |
8070 | nArg = (int)pArgc->u.i; |
8071 | iQuery = (int)pQuery->u.i; |
8072 | |
8073 | /* Invoke the xFilter method */ |
8074 | apArg = p->apArg; |
8075 | for(i = 0; i<nArg; i++){ |
8076 | apArg[i] = &pArgc[i+1]; |
8077 | } |
8078 | rc = pModule->xFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg); |
8079 | sqlite3VtabImportErrmsg(p, pVtab); |
8080 | if( rc ) goto abort_due_to_error; |
8081 | res = pModule->xEof(pVCur); |
8082 | pCur->nullRow = 0; |
8083 | VdbeBranchTaken(res!=0,2); |
8084 | if( res ) goto jump_to_p2; |
8085 | break; |
8086 | } |
8087 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
8088 | |
8089 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
8090 | /* Opcode: VColumn P1 P2 P3 * P5 |
8091 | ** Synopsis: r[P3]=vcolumn(P2) |
8092 | ** |
8093 | ** Store in register P3 the value of the P2-th column of |
8094 | ** the current row of the virtual-table of cursor P1. |
8095 | ** |
8096 | ** If the VColumn opcode is being used to fetch the value of |
8097 | ** an unchanging column during an UPDATE operation, then the P5 |
8098 | ** value is OPFLAG_NOCHNG. This will cause the sqlite3_vtab_nochange() |
8099 | ** function to return true inside the xColumn method of the virtual |
8100 | ** table implementation. The P5 column might also contain other |
8101 | ** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are |
8102 | ** unused by OP_VColumn. |
8103 | */ |
8104 | case OP_VColumn: { |
8105 | sqlite3_vtab *pVtab; |
8106 | const sqlite3_module *pModule; |
8107 | Mem *pDest; |
8108 | sqlite3_context sContext; |
8109 | |
8110 | VdbeCursor *pCur = p->apCsr[pOp->p1]; |
8111 | assert( pCur!=0 ); |
8112 | assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
8113 | pDest = &aMem[pOp->p3]; |
8114 | memAboutToChange(p, pDest); |
8115 | if( pCur->nullRow ){ |
8116 | sqlite3VdbeMemSetNull(pDest); |
8117 | break; |
8118 | } |
8119 | assert( pCur->eCurType==CURTYPE_VTAB ); |
8120 | pVtab = pCur->uc.pVCur->pVtab; |
8121 | pModule = pVtab->pModule; |
8122 | assert( pModule->xColumn ); |
8123 | memset(&sContext, 0, sizeof(sContext)); |
8124 | sContext.pOut = pDest; |
8125 | sContext.enc = encoding; |
8126 | assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 ); |
8127 | if( pOp->p5 & OPFLAG_NOCHNG ){ |
8128 | sqlite3VdbeMemSetNull(pDest); |
8129 | pDest->flags = MEM_Null|MEM_Zero; |
8130 | pDest->u.nZero = 0; |
8131 | }else{ |
8132 | MemSetTypeFlag(pDest, MEM_Null); |
8133 | } |
8134 | rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2); |
8135 | sqlite3VtabImportErrmsg(p, pVtab); |
8136 | if( sContext.isError>0 ){ |
8137 | sqlite3VdbeError(p, "%s" , sqlite3_value_text(pDest)); |
8138 | rc = sContext.isError; |
8139 | } |
8140 | sqlite3VdbeChangeEncoding(pDest, encoding); |
8141 | REGISTER_TRACE(pOp->p3, pDest); |
8142 | UPDATE_MAX_BLOBSIZE(pDest); |
8143 | |
8144 | if( rc ) goto abort_due_to_error; |
8145 | break; |
8146 | } |
8147 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
8148 | |
8149 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
8150 | /* Opcode: VNext P1 P2 * * * |
8151 | ** |
8152 | ** Advance virtual table P1 to the next row in its result set and |
8153 | ** jump to instruction P2. Or, if the virtual table has reached |
8154 | ** the end of its result set, then fall through to the next instruction. |
8155 | */ |
8156 | case OP_VNext: { /* jump */ |
8157 | sqlite3_vtab *pVtab; |
8158 | const sqlite3_module *pModule; |
8159 | int res; |
8160 | VdbeCursor *pCur; |
8161 | |
8162 | pCur = p->apCsr[pOp->p1]; |
8163 | assert( pCur!=0 ); |
8164 | assert( pCur->eCurType==CURTYPE_VTAB ); |
8165 | if( pCur->nullRow ){ |
8166 | break; |
8167 | } |
8168 | pVtab = pCur->uc.pVCur->pVtab; |
8169 | pModule = pVtab->pModule; |
8170 | assert( pModule->xNext ); |
8171 | |
8172 | /* Invoke the xNext() method of the module. There is no way for the |
8173 | ** underlying implementation to return an error if one occurs during |
8174 | ** xNext(). Instead, if an error occurs, true is returned (indicating that |
8175 | ** data is available) and the error code returned when xColumn or |
8176 | ** some other method is next invoked on the save virtual table cursor. |
8177 | */ |
8178 | rc = pModule->xNext(pCur->uc.pVCur); |
8179 | sqlite3VtabImportErrmsg(p, pVtab); |
8180 | if( rc ) goto abort_due_to_error; |
8181 | res = pModule->xEof(pCur->uc.pVCur); |
8182 | VdbeBranchTaken(!res,2); |
8183 | if( !res ){ |
8184 | /* If there is data, jump to P2 */ |
8185 | goto jump_to_p2_and_check_for_interrupt; |
8186 | } |
8187 | goto check_for_interrupt; |
8188 | } |
8189 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
8190 | |
8191 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
8192 | /* Opcode: VRename P1 * * P4 * |
8193 | ** |
8194 | ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. |
8195 | ** This opcode invokes the corresponding xRename method. The value |
8196 | ** in register P1 is passed as the zName argument to the xRename method. |
8197 | */ |
8198 | case OP_VRename: { |
8199 | sqlite3_vtab *pVtab; |
8200 | Mem *pName; |
8201 | int isLegacy; |
8202 | |
8203 | isLegacy = (db->flags & SQLITE_LegacyAlter); |
8204 | db->flags |= SQLITE_LegacyAlter; |
8205 | pVtab = pOp->p4.pVtab->pVtab; |
8206 | pName = &aMem[pOp->p1]; |
8207 | assert( pVtab->pModule->xRename ); |
8208 | assert( memIsValid(pName) ); |
8209 | assert( p->readOnly==0 ); |
8210 | REGISTER_TRACE(pOp->p1, pName); |
8211 | assert( pName->flags & MEM_Str ); |
8212 | testcase( pName->enc==SQLITE_UTF8 ); |
8213 | testcase( pName->enc==SQLITE_UTF16BE ); |
8214 | testcase( pName->enc==SQLITE_UTF16LE ); |
8215 | rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8); |
8216 | if( rc ) goto abort_due_to_error; |
8217 | rc = pVtab->pModule->xRename(pVtab, pName->z); |
8218 | if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter; |
8219 | sqlite3VtabImportErrmsg(p, pVtab); |
8220 | p->expired = 0; |
8221 | if( rc ) goto abort_due_to_error; |
8222 | break; |
8223 | } |
8224 | #endif |
8225 | |
8226 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
8227 | /* Opcode: VUpdate P1 P2 P3 P4 P5 |
8228 | ** Synopsis: data=r[P3@P2] |
8229 | ** |
8230 | ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. |
8231 | ** This opcode invokes the corresponding xUpdate method. P2 values |
8232 | ** are contiguous memory cells starting at P3 to pass to the xUpdate |
8233 | ** invocation. The value in register (P3+P2-1) corresponds to the |
8234 | ** p2th element of the argv array passed to xUpdate. |
8235 | ** |
8236 | ** The xUpdate method will do a DELETE or an INSERT or both. |
8237 | ** The argv[0] element (which corresponds to memory cell P3) |
8238 | ** is the rowid of a row to delete. If argv[0] is NULL then no |
8239 | ** deletion occurs. The argv[1] element is the rowid of the new |
8240 | ** row. This can be NULL to have the virtual table select the new |
8241 | ** rowid for itself. The subsequent elements in the array are |
8242 | ** the values of columns in the new row. |
8243 | ** |
8244 | ** If P2==1 then no insert is performed. argv[0] is the rowid of |
8245 | ** a row to delete. |
8246 | ** |
8247 | ** P1 is a boolean flag. If it is set to true and the xUpdate call |
8248 | ** is successful, then the value returned by sqlite3_last_insert_rowid() |
8249 | ** is set to the value of the rowid for the row just inserted. |
8250 | ** |
8251 | ** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to |
8252 | ** apply in the case of a constraint failure on an insert or update. |
8253 | */ |
8254 | case OP_VUpdate: { |
8255 | sqlite3_vtab *pVtab; |
8256 | const sqlite3_module *pModule; |
8257 | int nArg; |
8258 | int i; |
8259 | sqlite_int64 rowid = 0; |
8260 | Mem **apArg; |
8261 | Mem *pX; |
8262 | |
8263 | assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback |
8264 | || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace |
8265 | ); |
8266 | assert( p->readOnly==0 ); |
8267 | if( db->mallocFailed ) goto no_mem; |
8268 | sqlite3VdbeIncrWriteCounter(p, 0); |
8269 | pVtab = pOp->p4.pVtab->pVtab; |
8270 | if( pVtab==0 || NEVER(pVtab->pModule==0) ){ |
8271 | rc = SQLITE_LOCKED; |
8272 | goto abort_due_to_error; |
8273 | } |
8274 | pModule = pVtab->pModule; |
8275 | nArg = pOp->p2; |
8276 | assert( pOp->p4type==P4_VTAB ); |
8277 | if( ALWAYS(pModule->xUpdate) ){ |
8278 | u8 vtabOnConflict = db->vtabOnConflict; |
8279 | apArg = p->apArg; |
8280 | pX = &aMem[pOp->p3]; |
8281 | for(i=0; i<nArg; i++){ |
8282 | assert( memIsValid(pX) ); |
8283 | memAboutToChange(p, pX); |
8284 | apArg[i] = pX; |
8285 | pX++; |
8286 | } |
8287 | db->vtabOnConflict = pOp->p5; |
8288 | rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid); |
8289 | db->vtabOnConflict = vtabOnConflict; |
8290 | sqlite3VtabImportErrmsg(p, pVtab); |
8291 | if( rc==SQLITE_OK && pOp->p1 ){ |
8292 | assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) ); |
8293 | db->lastRowid = rowid; |
8294 | } |
8295 | if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){ |
8296 | if( pOp->p5==OE_Ignore ){ |
8297 | rc = SQLITE_OK; |
8298 | }else{ |
8299 | p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5); |
8300 | } |
8301 | }else{ |
8302 | p->nChange++; |
8303 | } |
8304 | if( rc ) goto abort_due_to_error; |
8305 | } |
8306 | break; |
8307 | } |
8308 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
8309 | |
8310 | #ifndef SQLITE_OMIT_PAGER_PRAGMAS |
8311 | /* Opcode: Pagecount P1 P2 * * * |
8312 | ** |
8313 | ** Write the current number of pages in database P1 to memory cell P2. |
8314 | */ |
8315 | case OP_Pagecount: { /* out2 */ |
8316 | pOut = out2Prerelease(p, pOp); |
8317 | pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt); |
8318 | break; |
8319 | } |
8320 | #endif |
8321 | |
8322 | |
8323 | #ifndef SQLITE_OMIT_PAGER_PRAGMAS |
8324 | /* Opcode: MaxPgcnt P1 P2 P3 * * |
8325 | ** |
8326 | ** Try to set the maximum page count for database P1 to the value in P3. |
8327 | ** Do not let the maximum page count fall below the current page count and |
8328 | ** do not change the maximum page count value if P3==0. |
8329 | ** |
8330 | ** Store the maximum page count after the change in register P2. |
8331 | */ |
8332 | case OP_MaxPgcnt: { /* out2 */ |
8333 | unsigned int newMax; |
8334 | Btree *pBt; |
8335 | |
8336 | pOut = out2Prerelease(p, pOp); |
8337 | pBt = db->aDb[pOp->p1].pBt; |
8338 | newMax = 0; |
8339 | if( pOp->p3 ){ |
8340 | newMax = sqlite3BtreeLastPage(pBt); |
8341 | if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3; |
8342 | } |
8343 | pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax); |
8344 | break; |
8345 | } |
8346 | #endif |
8347 | |
8348 | /* Opcode: Function P1 P2 P3 P4 * |
8349 | ** Synopsis: r[P3]=func(r[P2@NP]) |
8350 | ** |
8351 | ** Invoke a user function (P4 is a pointer to an sqlite3_context object that |
8352 | ** contains a pointer to the function to be run) with arguments taken |
8353 | ** from register P2 and successors. The number of arguments is in |
8354 | ** the sqlite3_context object that P4 points to. |
8355 | ** The result of the function is stored |
8356 | ** in register P3. Register P3 must not be one of the function inputs. |
8357 | ** |
8358 | ** P1 is a 32-bit bitmask indicating whether or not each argument to the |
8359 | ** function was determined to be constant at compile time. If the first |
8360 | ** argument was constant then bit 0 of P1 is set. This is used to determine |
8361 | ** whether meta data associated with a user function argument using the |
8362 | ** sqlite3_set_auxdata() API may be safely retained until the next |
8363 | ** invocation of this opcode. |
8364 | ** |
8365 | ** See also: AggStep, AggFinal, PureFunc |
8366 | */ |
8367 | /* Opcode: PureFunc P1 P2 P3 P4 * |
8368 | ** Synopsis: r[P3]=func(r[P2@NP]) |
8369 | ** |
8370 | ** Invoke a user function (P4 is a pointer to an sqlite3_context object that |
8371 | ** contains a pointer to the function to be run) with arguments taken |
8372 | ** from register P2 and successors. The number of arguments is in |
8373 | ** the sqlite3_context object that P4 points to. |
8374 | ** The result of the function is stored |
8375 | ** in register P3. Register P3 must not be one of the function inputs. |
8376 | ** |
8377 | ** P1 is a 32-bit bitmask indicating whether or not each argument to the |
8378 | ** function was determined to be constant at compile time. If the first |
8379 | ** argument was constant then bit 0 of P1 is set. This is used to determine |
8380 | ** whether meta data associated with a user function argument using the |
8381 | ** sqlite3_set_auxdata() API may be safely retained until the next |
8382 | ** invocation of this opcode. |
8383 | ** |
8384 | ** This opcode works exactly like OP_Function. The only difference is in |
8385 | ** its name. This opcode is used in places where the function must be |
8386 | ** purely non-deterministic. Some built-in date/time functions can be |
8387 | ** either determinitic of non-deterministic, depending on their arguments. |
8388 | ** When those function are used in a non-deterministic way, they will check |
8389 | ** to see if they were called using OP_PureFunc instead of OP_Function, and |
8390 | ** if they were, they throw an error. |
8391 | ** |
8392 | ** See also: AggStep, AggFinal, Function |
8393 | */ |
8394 | case OP_PureFunc: /* group */ |
8395 | case OP_Function: { /* group */ |
8396 | int i; |
8397 | sqlite3_context *pCtx; |
8398 | |
8399 | assert( pOp->p4type==P4_FUNCCTX ); |
8400 | pCtx = pOp->p4.pCtx; |
8401 | |
8402 | /* If this function is inside of a trigger, the register array in aMem[] |
8403 | ** might change from one evaluation to the next. The next block of code |
8404 | ** checks to see if the register array has changed, and if so it |
8405 | ** reinitializes the relavant parts of the sqlite3_context object */ |
8406 | pOut = &aMem[pOp->p3]; |
8407 | if( pCtx->pOut != pOut ){ |
8408 | pCtx->pVdbe = p; |
8409 | pCtx->pOut = pOut; |
8410 | pCtx->enc = encoding; |
8411 | for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; |
8412 | } |
8413 | assert( pCtx->pVdbe==p ); |
8414 | |
8415 | memAboutToChange(p, pOut); |
8416 | #ifdef SQLITE_DEBUG |
8417 | for(i=0; i<pCtx->argc; i++){ |
8418 | assert( memIsValid(pCtx->argv[i]) ); |
8419 | REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); |
8420 | } |
8421 | #endif |
8422 | MemSetTypeFlag(pOut, MEM_Null); |
8423 | assert( pCtx->isError==0 ); |
8424 | (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */ |
8425 | |
8426 | /* If the function returned an error, throw an exception */ |
8427 | if( pCtx->isError ){ |
8428 | if( pCtx->isError>0 ){ |
8429 | sqlite3VdbeError(p, "%s" , sqlite3_value_text(pOut)); |
8430 | rc = pCtx->isError; |
8431 | } |
8432 | sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1); |
8433 | pCtx->isError = 0; |
8434 | if( rc ) goto abort_due_to_error; |
8435 | } |
8436 | |
8437 | assert( (pOut->flags&MEM_Str)==0 |
8438 | || pOut->enc==encoding |
8439 | || db->mallocFailed ); |
8440 | assert( !sqlite3VdbeMemTooBig(pOut) ); |
8441 | |
8442 | REGISTER_TRACE(pOp->p3, pOut); |
8443 | UPDATE_MAX_BLOBSIZE(pOut); |
8444 | break; |
8445 | } |
8446 | |
8447 | /* Opcode: ClrSubtype P1 * * * * |
8448 | ** Synopsis: r[P1].subtype = 0 |
8449 | ** |
8450 | ** Clear the subtype from register P1. |
8451 | */ |
8452 | case OP_ClrSubtype: { /* in1 */ |
8453 | pIn1 = &aMem[pOp->p1]; |
8454 | pIn1->flags &= ~MEM_Subtype; |
8455 | break; |
8456 | } |
8457 | |
8458 | /* Opcode: FilterAdd P1 * P3 P4 * |
8459 | ** Synopsis: filter(P1) += key(P3@P4) |
8460 | ** |
8461 | ** Compute a hash on the P4 registers starting with r[P3] and |
8462 | ** add that hash to the bloom filter contained in r[P1]. |
8463 | */ |
8464 | case OP_FilterAdd: { |
8465 | u64 h; |
8466 | |
8467 | assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
8468 | pIn1 = &aMem[pOp->p1]; |
8469 | assert( pIn1->flags & MEM_Blob ); |
8470 | assert( pIn1->n>0 ); |
8471 | h = filterHash(aMem, pOp); |
8472 | #ifdef SQLITE_DEBUG |
8473 | if( db->flags&SQLITE_VdbeTrace ){ |
8474 | int ii; |
8475 | for(ii=pOp->p3; ii<pOp->p3+pOp->p4.i; ii++){ |
8476 | registerTrace(ii, &aMem[ii]); |
8477 | } |
8478 | printf("hash: %llu modulo %d -> %u\n" , h, pIn1->n, (int)(h%pIn1->n)); |
8479 | } |
8480 | #endif |
8481 | h %= pIn1->n; |
8482 | pIn1->z[h/8] |= 1<<(h&7); |
8483 | break; |
8484 | } |
8485 | |
8486 | /* Opcode: Filter P1 P2 P3 P4 * |
8487 | ** Synopsis: if key(P3@P4) not in filter(P1) goto P2 |
8488 | ** |
8489 | ** Compute a hash on the key contained in the P4 registers starting |
8490 | ** with r[P3]. Check to see if that hash is found in the |
8491 | ** bloom filter hosted by register P1. If it is not present then |
8492 | ** maybe jump to P2. Otherwise fall through. |
8493 | ** |
8494 | ** False negatives are harmless. It is always safe to fall through, |
8495 | ** even if the value is in the bloom filter. A false negative causes |
8496 | ** more CPU cycles to be used, but it should still yield the correct |
8497 | ** answer. However, an incorrect answer may well arise from a |
8498 | ** false positive - if the jump is taken when it should fall through. |
8499 | */ |
8500 | case OP_Filter: { /* jump */ |
8501 | u64 h; |
8502 | |
8503 | assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
8504 | pIn1 = &aMem[pOp->p1]; |
8505 | assert( (pIn1->flags & MEM_Blob)!=0 ); |
8506 | assert( pIn1->n >= 1 ); |
8507 | h = filterHash(aMem, pOp); |
8508 | #ifdef SQLITE_DEBUG |
8509 | if( db->flags&SQLITE_VdbeTrace ){ |
8510 | int ii; |
8511 | for(ii=pOp->p3; ii<pOp->p3+pOp->p4.i; ii++){ |
8512 | registerTrace(ii, &aMem[ii]); |
8513 | } |
8514 | printf("hash: %llu modulo %d -> %u\n" , h, pIn1->n, (int)(h%pIn1->n)); |
8515 | } |
8516 | #endif |
8517 | h %= pIn1->n; |
8518 | if( (pIn1->z[h/8] & (1<<(h&7)))==0 ){ |
8519 | VdbeBranchTaken(1, 2); |
8520 | p->aCounter[SQLITE_STMTSTATUS_FILTER_HIT]++; |
8521 | goto jump_to_p2; |
8522 | }else{ |
8523 | p->aCounter[SQLITE_STMTSTATUS_FILTER_MISS]++; |
8524 | VdbeBranchTaken(0, 2); |
8525 | } |
8526 | break; |
8527 | } |
8528 | |
8529 | /* Opcode: Trace P1 P2 * P4 * |
8530 | ** |
8531 | ** Write P4 on the statement trace output if statement tracing is |
8532 | ** enabled. |
8533 | ** |
8534 | ** Operand P1 must be 0x7fffffff and P2 must positive. |
8535 | */ |
8536 | /* Opcode: Init P1 P2 P3 P4 * |
8537 | ** Synopsis: Start at P2 |
8538 | ** |
8539 | ** Programs contain a single instance of this opcode as the very first |
8540 | ** opcode. |
8541 | ** |
8542 | ** If tracing is enabled (by the sqlite3_trace()) interface, then |
8543 | ** the UTF-8 string contained in P4 is emitted on the trace callback. |
8544 | ** Or if P4 is blank, use the string returned by sqlite3_sql(). |
8545 | ** |
8546 | ** If P2 is not zero, jump to instruction P2. |
8547 | ** |
8548 | ** Increment the value of P1 so that OP_Once opcodes will jump the |
8549 | ** first time they are evaluated for this run. |
8550 | ** |
8551 | ** If P3 is not zero, then it is an address to jump to if an SQLITE_CORRUPT |
8552 | ** error is encountered. |
8553 | */ |
8554 | case OP_Trace: |
8555 | case OP_Init: { /* jump */ |
8556 | int i; |
8557 | #ifndef SQLITE_OMIT_TRACE |
8558 | char *zTrace; |
8559 | #endif |
8560 | |
8561 | /* If the P4 argument is not NULL, then it must be an SQL comment string. |
8562 | ** The "--" string is broken up to prevent false-positives with srcck1.c. |
8563 | ** |
8564 | ** This assert() provides evidence for: |
8565 | ** EVIDENCE-OF: R-50676-09860 The callback can compute the same text that |
8566 | ** would have been returned by the legacy sqlite3_trace() interface by |
8567 | ** using the X argument when X begins with "--" and invoking |
8568 | ** sqlite3_expanded_sql(P) otherwise. |
8569 | */ |
8570 | assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- " , 3)==0 ); |
8571 | |
8572 | /* OP_Init is always instruction 0 */ |
8573 | assert( pOp==p->aOp || pOp->opcode==OP_Trace ); |
8574 | |
8575 | #ifndef SQLITE_OMIT_TRACE |
8576 | if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0 |
8577 | && p->minWriteFileFormat!=254 /* tag-20220401a */ |
8578 | && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 |
8579 | ){ |
8580 | #ifndef SQLITE_OMIT_DEPRECATED |
8581 | if( db->mTrace & SQLITE_TRACE_LEGACY ){ |
8582 | char *z = sqlite3VdbeExpandSql(p, zTrace); |
8583 | db->trace.xLegacy(db->pTraceArg, z); |
8584 | sqlite3_free(z); |
8585 | }else |
8586 | #endif |
8587 | if( db->nVdbeExec>1 ){ |
8588 | char *z = sqlite3MPrintf(db, "-- %s" , zTrace); |
8589 | (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, z); |
8590 | sqlite3DbFree(db, z); |
8591 | }else{ |
8592 | (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace); |
8593 | } |
8594 | } |
8595 | #ifdef SQLITE_USE_FCNTL_TRACE |
8596 | zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql); |
8597 | if( zTrace ){ |
8598 | int j; |
8599 | for(j=0; j<db->nDb; j++){ |
8600 | if( DbMaskTest(p->btreeMask, j)==0 ) continue; |
8601 | sqlite3_file_control(db, db->aDb[j].zDbSName, SQLITE_FCNTL_TRACE, zTrace); |
8602 | } |
8603 | } |
8604 | #endif /* SQLITE_USE_FCNTL_TRACE */ |
8605 | #ifdef SQLITE_DEBUG |
8606 | if( (db->flags & SQLITE_SqlTrace)!=0 |
8607 | && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 |
8608 | ){ |
8609 | sqlite3DebugPrintf("SQL-trace: %s\n" , zTrace); |
8610 | } |
8611 | #endif /* SQLITE_DEBUG */ |
8612 | #endif /* SQLITE_OMIT_TRACE */ |
8613 | assert( pOp->p2>0 ); |
8614 | if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){ |
8615 | if( pOp->opcode==OP_Trace ) break; |
8616 | for(i=1; i<p->nOp; i++){ |
8617 | if( p->aOp[i].opcode==OP_Once ) p->aOp[i].p1 = 0; |
8618 | } |
8619 | pOp->p1 = 0; |
8620 | } |
8621 | pOp->p1++; |
8622 | p->aCounter[SQLITE_STMTSTATUS_RUN]++; |
8623 | goto jump_to_p2; |
8624 | } |
8625 | |
8626 | #ifdef SQLITE_ENABLE_CURSOR_HINTS |
8627 | /* Opcode: CursorHint P1 * * P4 * |
8628 | ** |
8629 | ** Provide a hint to cursor P1 that it only needs to return rows that |
8630 | ** satisfy the Expr in P4. TK_REGISTER terms in the P4 expression refer |
8631 | ** to values currently held in registers. TK_COLUMN terms in the P4 |
8632 | ** expression refer to columns in the b-tree to which cursor P1 is pointing. |
8633 | */ |
8634 | case OP_CursorHint: { |
8635 | VdbeCursor *pC; |
8636 | |
8637 | assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
8638 | assert( pOp->p4type==P4_EXPR ); |
8639 | pC = p->apCsr[pOp->p1]; |
8640 | if( pC ){ |
8641 | assert( pC->eCurType==CURTYPE_BTREE ); |
8642 | sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE, |
8643 | pOp->p4.pExpr, aMem); |
8644 | } |
8645 | break; |
8646 | } |
8647 | #endif /* SQLITE_ENABLE_CURSOR_HINTS */ |
8648 | |
8649 | #ifdef SQLITE_DEBUG |
8650 | /* Opcode: Abortable * * * * * |
8651 | ** |
8652 | ** Verify that an Abort can happen. Assert if an Abort at this point |
8653 | ** might cause database corruption. This opcode only appears in debugging |
8654 | ** builds. |
8655 | ** |
8656 | ** An Abort is safe if either there have been no writes, or if there is |
8657 | ** an active statement journal. |
8658 | */ |
8659 | case OP_Abortable: { |
8660 | sqlite3VdbeAssertAbortable(p); |
8661 | break; |
8662 | } |
8663 | #endif |
8664 | |
8665 | #ifdef SQLITE_DEBUG |
8666 | /* Opcode: ReleaseReg P1 P2 P3 * P5 |
8667 | ** Synopsis: release r[P1@P2] mask P3 |
8668 | ** |
8669 | ** Release registers from service. Any content that was in the |
8670 | ** the registers is unreliable after this opcode completes. |
8671 | ** |
8672 | ** The registers released will be the P2 registers starting at P1, |
8673 | ** except if bit ii of P3 set, then do not release register P1+ii. |
8674 | ** In other words, P3 is a mask of registers to preserve. |
8675 | ** |
8676 | ** Releasing a register clears the Mem.pScopyFrom pointer. That means |
8677 | ** that if the content of the released register was set using OP_SCopy, |
8678 | ** a change to the value of the source register for the OP_SCopy will no longer |
8679 | ** generate an assertion fault in sqlite3VdbeMemAboutToChange(). |
8680 | ** |
8681 | ** If P5 is set, then all released registers have their type set |
8682 | ** to MEM_Undefined so that any subsequent attempt to read the released |
8683 | ** register (before it is reinitialized) will generate an assertion fault. |
8684 | ** |
8685 | ** P5 ought to be set on every call to this opcode. |
8686 | ** However, there are places in the code generator will release registers |
8687 | ** before their are used, under the (valid) assumption that the registers |
8688 | ** will not be reallocated for some other purpose before they are used and |
8689 | ** hence are safe to release. |
8690 | ** |
8691 | ** This opcode is only available in testing and debugging builds. It is |
8692 | ** not generated for release builds. The purpose of this opcode is to help |
8693 | ** validate the generated bytecode. This opcode does not actually contribute |
8694 | ** to computing an answer. |
8695 | */ |
8696 | case OP_ReleaseReg: { |
8697 | Mem *pMem; |
8698 | int i; |
8699 | u32 constMask; |
8700 | assert( pOp->p1>0 ); |
8701 | assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 ); |
8702 | pMem = &aMem[pOp->p1]; |
8703 | constMask = pOp->p3; |
8704 | for(i=0; i<pOp->p2; i++, pMem++){ |
8705 | if( i>=32 || (constMask & MASKBIT32(i))==0 ){ |
8706 | pMem->pScopyFrom = 0; |
8707 | if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined); |
8708 | } |
8709 | } |
8710 | break; |
8711 | } |
8712 | #endif |
8713 | |
8714 | /* Opcode: Noop * * * * * |
8715 | ** |
8716 | ** Do nothing. This instruction is often useful as a jump |
8717 | ** destination. |
8718 | */ |
8719 | /* |
8720 | ** The magic Explain opcode are only inserted when explain==2 (which |
8721 | ** is to say when the EXPLAIN QUERY PLAN syntax is used.) |
8722 | ** This opcode records information from the optimizer. It is the |
8723 | ** the same as a no-op. This opcodesnever appears in a real VM program. |
8724 | */ |
8725 | default: { /* This is really OP_Noop, OP_Explain */ |
8726 | assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain ); |
8727 | |
8728 | break; |
8729 | } |
8730 | |
8731 | /***************************************************************************** |
8732 | ** The cases of the switch statement above this line should all be indented |
8733 | ** by 6 spaces. But the left-most 6 spaces have been removed to improve the |
8734 | ** readability. From this point on down, the normal indentation rules are |
8735 | ** restored. |
8736 | *****************************************************************************/ |
8737 | } |
8738 | |
8739 | #ifdef VDBE_PROFILE |
8740 | { |
8741 | u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime(); |
8742 | if( endTime>start ) pOrigOp->cycles += endTime - start; |
8743 | pOrigOp->cnt++; |
8744 | } |
8745 | #endif |
8746 | |
8747 | /* The following code adds nothing to the actual functionality |
8748 | ** of the program. It is only here for testing and debugging. |
8749 | ** On the other hand, it does burn CPU cycles every time through |
8750 | ** the evaluator loop. So we can leave it out when NDEBUG is defined. |
8751 | */ |
8752 | #ifndef NDEBUG |
8753 | assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] ); |
8754 | |
8755 | #ifdef SQLITE_DEBUG |
8756 | if( db->flags & SQLITE_VdbeTrace ){ |
8757 | u8 opProperty = sqlite3OpcodeProperty[pOrigOp->opcode]; |
8758 | if( rc!=0 ) printf("rc=%d\n" ,rc); |
8759 | if( opProperty & (OPFLG_OUT2) ){ |
8760 | registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]); |
8761 | } |
8762 | if( opProperty & OPFLG_OUT3 ){ |
8763 | registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]); |
8764 | } |
8765 | if( opProperty==0xff ){ |
8766 | /* Never happens. This code exists to avoid a harmless linkage |
8767 | ** warning aboud sqlite3VdbeRegisterDump() being defined but not |
8768 | ** used. */ |
8769 | sqlite3VdbeRegisterDump(p); |
8770 | } |
8771 | } |
8772 | #endif /* SQLITE_DEBUG */ |
8773 | #endif /* NDEBUG */ |
8774 | } /* The end of the for(;;) loop the loops through opcodes */ |
8775 | |
8776 | /* If we reach this point, it means that execution is finished with |
8777 | ** an error of some kind. |
8778 | */ |
8779 | abort_due_to_error: |
8780 | if( db->mallocFailed ){ |
8781 | rc = SQLITE_NOMEM_BKPT; |
8782 | }else if( rc==SQLITE_IOERR_CORRUPTFS ){ |
8783 | rc = SQLITE_CORRUPT_BKPT; |
8784 | } |
8785 | assert( rc ); |
8786 | #ifdef SQLITE_DEBUG |
8787 | if( db->flags & SQLITE_VdbeTrace ){ |
8788 | const char *zTrace = p->zSql; |
8789 | if( zTrace==0 ){ |
8790 | if( aOp[0].opcode==OP_Trace ){ |
8791 | zTrace = aOp[0].p4.z; |
8792 | } |
8793 | if( zTrace==0 ) zTrace = "???" ; |
8794 | } |
8795 | printf("ABORT-due-to-error (rc=%d): %s\n" , rc, zTrace); |
8796 | } |
8797 | #endif |
8798 | if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){ |
8799 | sqlite3VdbeError(p, "%s" , sqlite3ErrStr(rc)); |
8800 | } |
8801 | p->rc = rc; |
8802 | sqlite3SystemError(db, rc); |
8803 | testcase( sqlite3GlobalConfig.xLog!=0 ); |
8804 | sqlite3_log(rc, "statement aborts at %d: [%s] %s" , |
8805 | (int)(pOp - aOp), p->zSql, p->zErrMsg); |
8806 | if( p->eVdbeState==VDBE_RUN_STATE ) sqlite3VdbeHalt(p); |
8807 | if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db); |
8808 | if( rc==SQLITE_CORRUPT && db->autoCommit==0 ){ |
8809 | db->flags |= SQLITE_CorruptRdOnly; |
8810 | } |
8811 | rc = SQLITE_ERROR; |
8812 | if( resetSchemaOnFault>0 ){ |
8813 | sqlite3ResetOneSchema(db, resetSchemaOnFault-1); |
8814 | } |
8815 | |
8816 | /* This is the only way out of this procedure. We have to |
8817 | ** release the mutexes on btrees that were acquired at the |
8818 | ** top. */ |
8819 | vdbe_return: |
8820 | #ifndef SQLITE_OMIT_PROGRESS_CALLBACK |
8821 | while( nVmStep>=nProgressLimit && db->xProgress!=0 ){ |
8822 | nProgressLimit += db->nProgressOps; |
8823 | if( db->xProgress(db->pProgressArg) ){ |
8824 | nProgressLimit = LARGEST_UINT64; |
8825 | rc = SQLITE_INTERRUPT; |
8826 | goto abort_due_to_error; |
8827 | } |
8828 | } |
8829 | #endif |
8830 | p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep; |
8831 | sqlite3VdbeLeave(p); |
8832 | assert( rc!=SQLITE_OK || nExtraDelete==0 |
8833 | || sqlite3_strlike("DELETE%" ,p->zSql,0)!=0 |
8834 | ); |
8835 | return rc; |
8836 | |
8837 | /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH |
8838 | ** is encountered. |
8839 | */ |
8840 | too_big: |
8841 | sqlite3VdbeError(p, "string or blob too big" ); |
8842 | rc = SQLITE_TOOBIG; |
8843 | goto abort_due_to_error; |
8844 | |
8845 | /* Jump to here if a malloc() fails. |
8846 | */ |
8847 | no_mem: |
8848 | sqlite3OomFault(db); |
8849 | sqlite3VdbeError(p, "out of memory" ); |
8850 | rc = SQLITE_NOMEM_BKPT; |
8851 | goto abort_due_to_error; |
8852 | |
8853 | /* Jump to here if the sqlite3_interrupt() API sets the interrupt |
8854 | ** flag. |
8855 | */ |
8856 | abort_due_to_interrupt: |
8857 | assert( AtomicLoad(&db->u1.isInterrupted) ); |
8858 | rc = SQLITE_INTERRUPT; |
8859 | goto abort_due_to_error; |
8860 | } |
8861 | |