1 | /* |
2 | ** 2003 September 6 |
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 | ** This file contains code used for creating, destroying, and populating |
13 | ** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) |
14 | */ |
15 | #include "sqliteInt.h" |
16 | #include "vdbeInt.h" |
17 | |
18 | /* Forward references */ |
19 | static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef); |
20 | static void vdbeFreeOpArray(sqlite3 *, Op *, int); |
21 | |
22 | /* |
23 | ** Create a new virtual database engine. |
24 | */ |
25 | Vdbe *sqlite3VdbeCreate(Parse *pParse){ |
26 | sqlite3 *db = pParse->db; |
27 | Vdbe *p; |
28 | p = sqlite3DbMallocRawNN(db, sizeof(Vdbe) ); |
29 | if( p==0 ) return 0; |
30 | memset(&p->aOp, 0, sizeof(Vdbe)-offsetof(Vdbe,aOp)); |
31 | p->db = db; |
32 | if( db->pVdbe ){ |
33 | db->pVdbe->ppVPrev = &p->pVNext; |
34 | } |
35 | p->pVNext = db->pVdbe; |
36 | p->ppVPrev = &db->pVdbe; |
37 | db->pVdbe = p; |
38 | assert( p->eVdbeState==VDBE_INIT_STATE ); |
39 | p->pParse = pParse; |
40 | pParse->pVdbe = p; |
41 | assert( pParse->aLabel==0 ); |
42 | assert( pParse->nLabel==0 ); |
43 | assert( p->nOpAlloc==0 ); |
44 | assert( pParse->szOpAlloc==0 ); |
45 | sqlite3VdbeAddOp2(p, OP_Init, 0, 1); |
46 | return p; |
47 | } |
48 | |
49 | /* |
50 | ** Return the Parse object that owns a Vdbe object. |
51 | */ |
52 | Parse *sqlite3VdbeParser(Vdbe *p){ |
53 | return p->pParse; |
54 | } |
55 | |
56 | /* |
57 | ** Change the error string stored in Vdbe.zErrMsg |
58 | */ |
59 | void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){ |
60 | va_list ap; |
61 | sqlite3DbFree(p->db, p->zErrMsg); |
62 | va_start(ap, zFormat); |
63 | p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap); |
64 | va_end(ap); |
65 | } |
66 | |
67 | /* |
68 | ** Remember the SQL string for a prepared statement. |
69 | */ |
70 | void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlags){ |
71 | if( p==0 ) return; |
72 | p->prepFlags = prepFlags; |
73 | if( (prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){ |
74 | p->expmask = 0; |
75 | } |
76 | assert( p->zSql==0 ); |
77 | p->zSql = sqlite3DbStrNDup(p->db, z, n); |
78 | } |
79 | |
80 | #ifdef SQLITE_ENABLE_NORMALIZE |
81 | /* |
82 | ** Add a new element to the Vdbe->pDblStr list. |
83 | */ |
84 | void sqlite3VdbeAddDblquoteStr(sqlite3 *db, Vdbe *p, const char *z){ |
85 | if( p ){ |
86 | int n = sqlite3Strlen30(z); |
87 | DblquoteStr *pStr = sqlite3DbMallocRawNN(db, |
88 | sizeof(*pStr)+n+1-sizeof(pStr->z)); |
89 | if( pStr ){ |
90 | pStr->pNextStr = p->pDblStr; |
91 | p->pDblStr = pStr; |
92 | memcpy(pStr->z, z, n+1); |
93 | } |
94 | } |
95 | } |
96 | #endif |
97 | |
98 | #ifdef SQLITE_ENABLE_NORMALIZE |
99 | /* |
100 | ** zId of length nId is a double-quoted identifier. Check to see if |
101 | ** that identifier is really used as a string literal. |
102 | */ |
103 | int sqlite3VdbeUsesDoubleQuotedString( |
104 | Vdbe *pVdbe, /* The prepared statement */ |
105 | const char *zId /* The double-quoted identifier, already dequoted */ |
106 | ){ |
107 | DblquoteStr *pStr; |
108 | assert( zId!=0 ); |
109 | if( pVdbe->pDblStr==0 ) return 0; |
110 | for(pStr=pVdbe->pDblStr; pStr; pStr=pStr->pNextStr){ |
111 | if( strcmp(zId, pStr->z)==0 ) return 1; |
112 | } |
113 | return 0; |
114 | } |
115 | #endif |
116 | |
117 | /* |
118 | ** Swap byte-code between two VDBE structures. |
119 | ** |
120 | ** This happens after pB was previously run and returned |
121 | ** SQLITE_SCHEMA. The statement was then reprepared in pA. |
122 | ** This routine transfers the new bytecode in pA over to pB |
123 | ** so that pB can be run again. The old pB byte code is |
124 | ** moved back to pA so that it will be cleaned up when pA is |
125 | ** finalized. |
126 | */ |
127 | void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){ |
128 | Vdbe tmp, *pTmp, **ppTmp; |
129 | char *zTmp; |
130 | assert( pA->db==pB->db ); |
131 | tmp = *pA; |
132 | *pA = *pB; |
133 | *pB = tmp; |
134 | pTmp = pA->pVNext; |
135 | pA->pVNext = pB->pVNext; |
136 | pB->pVNext = pTmp; |
137 | ppTmp = pA->ppVPrev; |
138 | pA->ppVPrev = pB->ppVPrev; |
139 | pB->ppVPrev = ppTmp; |
140 | zTmp = pA->zSql; |
141 | pA->zSql = pB->zSql; |
142 | pB->zSql = zTmp; |
143 | #ifdef SQLITE_ENABLE_NORMALIZE |
144 | zTmp = pA->zNormSql; |
145 | pA->zNormSql = pB->zNormSql; |
146 | pB->zNormSql = zTmp; |
147 | #endif |
148 | pB->expmask = pA->expmask; |
149 | pB->prepFlags = pA->prepFlags; |
150 | memcpy(pB->aCounter, pA->aCounter, sizeof(pB->aCounter)); |
151 | pB->aCounter[SQLITE_STMTSTATUS_REPREPARE]++; |
152 | } |
153 | |
154 | /* |
155 | ** Resize the Vdbe.aOp array so that it is at least nOp elements larger |
156 | ** than its current size. nOp is guaranteed to be less than or equal |
157 | ** to 1024/sizeof(Op). |
158 | ** |
159 | ** If an out-of-memory error occurs while resizing the array, return |
160 | ** SQLITE_NOMEM. In this case Vdbe.aOp and Vdbe.nOpAlloc remain |
161 | ** unchanged (this is so that any opcodes already allocated can be |
162 | ** correctly deallocated along with the rest of the Vdbe). |
163 | */ |
164 | static int growOpArray(Vdbe *v, int nOp){ |
165 | VdbeOp *pNew; |
166 | Parse *p = v->pParse; |
167 | |
168 | /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force |
169 | ** more frequent reallocs and hence provide more opportunities for |
170 | ** simulated OOM faults. SQLITE_TEST_REALLOC_STRESS is generally used |
171 | ** during testing only. With SQLITE_TEST_REALLOC_STRESS grow the op array |
172 | ** by the minimum* amount required until the size reaches 512. Normal |
173 | ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current |
174 | ** size of the op array or add 1KB of space, whichever is smaller. */ |
175 | #ifdef SQLITE_TEST_REALLOC_STRESS |
176 | sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc |
177 | : (sqlite3_int64)v->nOpAlloc+nOp); |
178 | #else |
179 | sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc |
180 | : (sqlite3_int64)(1024/sizeof(Op))); |
181 | UNUSED_PARAMETER(nOp); |
182 | #endif |
183 | |
184 | /* Ensure that the size of a VDBE does not grow too large */ |
185 | if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){ |
186 | sqlite3OomFault(p->db); |
187 | return SQLITE_NOMEM; |
188 | } |
189 | |
190 | assert( nOp<=(int)(1024/sizeof(Op)) ); |
191 | assert( nNew>=(v->nOpAlloc+nOp) ); |
192 | pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op)); |
193 | if( pNew ){ |
194 | p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew); |
195 | v->nOpAlloc = p->szOpAlloc/sizeof(Op); |
196 | v->aOp = pNew; |
197 | } |
198 | return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT); |
199 | } |
200 | |
201 | #ifdef SQLITE_DEBUG |
202 | /* This routine is just a convenient place to set a breakpoint that will |
203 | ** fire after each opcode is inserted and displayed using |
204 | ** "PRAGMA vdbe_addoptrace=on". Parameters "pc" (program counter) and |
205 | ** pOp are available to make the breakpoint conditional. |
206 | ** |
207 | ** Other useful labels for breakpoints include: |
208 | ** test_trace_breakpoint(pc,pOp) |
209 | ** sqlite3CorruptError(lineno) |
210 | ** sqlite3MisuseError(lineno) |
211 | ** sqlite3CantopenError(lineno) |
212 | */ |
213 | static void test_addop_breakpoint(int pc, Op *pOp){ |
214 | static int n = 0; |
215 | n++; |
216 | } |
217 | #endif |
218 | |
219 | /* |
220 | ** Add a new instruction to the list of instructions current in the |
221 | ** VDBE. Return the address of the new instruction. |
222 | ** |
223 | ** Parameters: |
224 | ** |
225 | ** p Pointer to the VDBE |
226 | ** |
227 | ** op The opcode for this instruction |
228 | ** |
229 | ** p1, p2, p3 Operands |
230 | ** |
231 | ** Use the sqlite3VdbeResolveLabel() function to fix an address and |
232 | ** the sqlite3VdbeChangeP4() function to change the value of the P4 |
233 | ** operand. |
234 | */ |
235 | static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){ |
236 | assert( p->nOpAlloc<=p->nOp ); |
237 | if( growOpArray(p, 1) ) return 1; |
238 | assert( p->nOpAlloc>p->nOp ); |
239 | return sqlite3VdbeAddOp3(p, op, p1, p2, p3); |
240 | } |
241 | int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){ |
242 | int i; |
243 | VdbeOp *pOp; |
244 | |
245 | i = p->nOp; |
246 | assert( p->eVdbeState==VDBE_INIT_STATE ); |
247 | assert( op>=0 && op<0xff ); |
248 | if( p->nOpAlloc<=i ){ |
249 | return growOp3(p, op, p1, p2, p3); |
250 | } |
251 | assert( p->aOp!=0 ); |
252 | p->nOp++; |
253 | pOp = &p->aOp[i]; |
254 | assert( pOp!=0 ); |
255 | pOp->opcode = (u8)op; |
256 | pOp->p5 = 0; |
257 | pOp->p1 = p1; |
258 | pOp->p2 = p2; |
259 | pOp->p3 = p3; |
260 | pOp->p4.p = 0; |
261 | pOp->p4type = P4_NOTUSED; |
262 | #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS |
263 | pOp->zComment = 0; |
264 | #endif |
265 | #ifdef SQLITE_DEBUG |
266 | if( p->db->flags & SQLITE_VdbeAddopTrace ){ |
267 | sqlite3VdbePrintOp(0, i, &p->aOp[i]); |
268 | test_addop_breakpoint(i, &p->aOp[i]); |
269 | } |
270 | #endif |
271 | #ifdef VDBE_PROFILE |
272 | pOp->cycles = 0; |
273 | pOp->cnt = 0; |
274 | #endif |
275 | #ifdef SQLITE_VDBE_COVERAGE |
276 | pOp->iSrcLine = 0; |
277 | #endif |
278 | return i; |
279 | } |
280 | int sqlite3VdbeAddOp0(Vdbe *p, int op){ |
281 | return sqlite3VdbeAddOp3(p, op, 0, 0, 0); |
282 | } |
283 | int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){ |
284 | return sqlite3VdbeAddOp3(p, op, p1, 0, 0); |
285 | } |
286 | int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){ |
287 | return sqlite3VdbeAddOp3(p, op, p1, p2, 0); |
288 | } |
289 | |
290 | /* Generate code for an unconditional jump to instruction iDest |
291 | */ |
292 | int sqlite3VdbeGoto(Vdbe *p, int iDest){ |
293 | return sqlite3VdbeAddOp3(p, OP_Goto, 0, iDest, 0); |
294 | } |
295 | |
296 | /* Generate code to cause the string zStr to be loaded into |
297 | ** register iDest |
298 | */ |
299 | int sqlite3VdbeLoadString(Vdbe *p, int iDest, const char *zStr){ |
300 | return sqlite3VdbeAddOp4(p, OP_String8, 0, iDest, 0, zStr, 0); |
301 | } |
302 | |
303 | /* |
304 | ** Generate code that initializes multiple registers to string or integer |
305 | ** constants. The registers begin with iDest and increase consecutively. |
306 | ** One register is initialized for each characgter in zTypes[]. For each |
307 | ** "s" character in zTypes[], the register is a string if the argument is |
308 | ** not NULL, or OP_Null if the value is a null pointer. For each "i" character |
309 | ** in zTypes[], the register is initialized to an integer. |
310 | ** |
311 | ** If the input string does not end with "X" then an OP_ResultRow instruction |
312 | ** is generated for the values inserted. |
313 | */ |
314 | void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes, ...){ |
315 | va_list ap; |
316 | int i; |
317 | char c; |
318 | va_start(ap, zTypes); |
319 | for(i=0; (c = zTypes[i])!=0; i++){ |
320 | if( c=='s' ){ |
321 | const char *z = va_arg(ap, const char*); |
322 | sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest+i, 0, z, 0); |
323 | }else if( c=='i' ){ |
324 | sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest+i); |
325 | }else{ |
326 | goto skip_op_resultrow; |
327 | } |
328 | } |
329 | sqlite3VdbeAddOp2(p, OP_ResultRow, iDest, i); |
330 | skip_op_resultrow: |
331 | va_end(ap); |
332 | } |
333 | |
334 | /* |
335 | ** Add an opcode that includes the p4 value as a pointer. |
336 | */ |
337 | int sqlite3VdbeAddOp4( |
338 | Vdbe *p, /* Add the opcode to this VM */ |
339 | int op, /* The new opcode */ |
340 | int p1, /* The P1 operand */ |
341 | int p2, /* The P2 operand */ |
342 | int p3, /* The P3 operand */ |
343 | const char *zP4, /* The P4 operand */ |
344 | int p4type /* P4 operand type */ |
345 | ){ |
346 | int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3); |
347 | sqlite3VdbeChangeP4(p, addr, zP4, p4type); |
348 | return addr; |
349 | } |
350 | |
351 | /* |
352 | ** Add an OP_Function or OP_PureFunc opcode. |
353 | ** |
354 | ** The eCallCtx argument is information (typically taken from Expr.op2) |
355 | ** that describes the calling context of the function. 0 means a general |
356 | ** function call. NC_IsCheck means called by a check constraint, |
357 | ** NC_IdxExpr means called as part of an index expression. NC_PartIdx |
358 | ** means in the WHERE clause of a partial index. NC_GenCol means called |
359 | ** while computing a generated column value. 0 is the usual case. |
360 | */ |
361 | int sqlite3VdbeAddFunctionCall( |
362 | Parse *pParse, /* Parsing context */ |
363 | int p1, /* Constant argument mask */ |
364 | int p2, /* First argument register */ |
365 | int p3, /* Register into which results are written */ |
366 | int nArg, /* Number of argument */ |
367 | const FuncDef *pFunc, /* The function to be invoked */ |
368 | int eCallCtx /* Calling context */ |
369 | ){ |
370 | Vdbe *v = pParse->pVdbe; |
371 | int nByte; |
372 | int addr; |
373 | sqlite3_context *pCtx; |
374 | assert( v ); |
375 | nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*); |
376 | pCtx = sqlite3DbMallocRawNN(pParse->db, nByte); |
377 | if( pCtx==0 ){ |
378 | assert( pParse->db->mallocFailed ); |
379 | freeEphemeralFunction(pParse->db, (FuncDef*)pFunc); |
380 | return 0; |
381 | } |
382 | pCtx->pOut = 0; |
383 | pCtx->pFunc = (FuncDef*)pFunc; |
384 | pCtx->pVdbe = 0; |
385 | pCtx->isError = 0; |
386 | pCtx->argc = nArg; |
387 | pCtx->iOp = sqlite3VdbeCurrentAddr(v); |
388 | addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function, |
389 | p1, p2, p3, (char*)pCtx, P4_FUNCCTX); |
390 | sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef); |
391 | sqlite3MayAbort(pParse); |
392 | return addr; |
393 | } |
394 | |
395 | /* |
396 | ** Add an opcode that includes the p4 value with a P4_INT64 or |
397 | ** P4_REAL type. |
398 | */ |
399 | int sqlite3VdbeAddOp4Dup8( |
400 | Vdbe *p, /* Add the opcode to this VM */ |
401 | int op, /* The new opcode */ |
402 | int p1, /* The P1 operand */ |
403 | int p2, /* The P2 operand */ |
404 | int p3, /* The P3 operand */ |
405 | const u8 *zP4, /* The P4 operand */ |
406 | int p4type /* P4 operand type */ |
407 | ){ |
408 | char *p4copy = sqlite3DbMallocRawNN(sqlite3VdbeDb(p), 8); |
409 | if( p4copy ) memcpy(p4copy, zP4, 8); |
410 | return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type); |
411 | } |
412 | |
413 | #ifndef SQLITE_OMIT_EXPLAIN |
414 | /* |
415 | ** Return the address of the current EXPLAIN QUERY PLAN baseline. |
416 | ** 0 means "none". |
417 | */ |
418 | int sqlite3VdbeExplainParent(Parse *pParse){ |
419 | VdbeOp *pOp; |
420 | if( pParse->addrExplain==0 ) return 0; |
421 | pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain); |
422 | return pOp->p2; |
423 | } |
424 | |
425 | /* |
426 | ** Set a debugger breakpoint on the following routine in order to |
427 | ** monitor the EXPLAIN QUERY PLAN code generation. |
428 | */ |
429 | #if defined(SQLITE_DEBUG) |
430 | void sqlite3ExplainBreakpoint(const char *z1, const char *z2){ |
431 | (void)z1; |
432 | (void)z2; |
433 | } |
434 | #endif |
435 | |
436 | /* |
437 | ** Add a new OP_Explain opcode. |
438 | ** |
439 | ** If the bPush flag is true, then make this opcode the parent for |
440 | ** subsequent Explains until sqlite3VdbeExplainPop() is called. |
441 | */ |
442 | void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){ |
443 | #ifndef SQLITE_DEBUG |
444 | /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined. |
445 | ** But omit them (for performance) during production builds */ |
446 | if( pParse->explain==2 ) |
447 | #endif |
448 | { |
449 | char *zMsg; |
450 | Vdbe *v; |
451 | va_list ap; |
452 | int iThis; |
453 | va_start(ap, zFmt); |
454 | zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap); |
455 | va_end(ap); |
456 | v = pParse->pVdbe; |
457 | iThis = v->nOp; |
458 | sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0, |
459 | zMsg, P4_DYNAMIC); |
460 | sqlite3ExplainBreakpoint(bPush?"PUSH" :"" , sqlite3VdbeGetLastOp(v)->p4.z); |
461 | if( bPush){ |
462 | pParse->addrExplain = iThis; |
463 | } |
464 | } |
465 | } |
466 | |
467 | /* |
468 | ** Pop the EXPLAIN QUERY PLAN stack one level. |
469 | */ |
470 | void sqlite3VdbeExplainPop(Parse *pParse){ |
471 | sqlite3ExplainBreakpoint("POP" , 0); |
472 | pParse->addrExplain = sqlite3VdbeExplainParent(pParse); |
473 | } |
474 | #endif /* SQLITE_OMIT_EXPLAIN */ |
475 | |
476 | /* |
477 | ** Add an OP_ParseSchema opcode. This routine is broken out from |
478 | ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees |
479 | ** as having been used. |
480 | ** |
481 | ** The zWhere string must have been obtained from sqlite3_malloc(). |
482 | ** This routine will take ownership of the allocated memory. |
483 | */ |
484 | void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){ |
485 | int j; |
486 | sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC); |
487 | sqlite3VdbeChangeP5(p, p5); |
488 | for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j); |
489 | sqlite3MayAbort(p->pParse); |
490 | } |
491 | |
492 | /* |
493 | ** Add an opcode that includes the p4 value as an integer. |
494 | */ |
495 | int sqlite3VdbeAddOp4Int( |
496 | Vdbe *p, /* Add the opcode to this VM */ |
497 | int op, /* The new opcode */ |
498 | int p1, /* The P1 operand */ |
499 | int p2, /* The P2 operand */ |
500 | int p3, /* The P3 operand */ |
501 | int p4 /* The P4 operand as an integer */ |
502 | ){ |
503 | int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3); |
504 | if( p->db->mallocFailed==0 ){ |
505 | VdbeOp *pOp = &p->aOp[addr]; |
506 | pOp->p4type = P4_INT32; |
507 | pOp->p4.i = p4; |
508 | } |
509 | return addr; |
510 | } |
511 | |
512 | /* Insert the end of a co-routine |
513 | */ |
514 | void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){ |
515 | sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield); |
516 | |
517 | /* Clear the temporary register cache, thereby ensuring that each |
518 | ** co-routine has its own independent set of registers, because co-routines |
519 | ** might expect their registers to be preserved across an OP_Yield, and |
520 | ** that could cause problems if two or more co-routines are using the same |
521 | ** temporary register. |
522 | */ |
523 | v->pParse->nTempReg = 0; |
524 | v->pParse->nRangeReg = 0; |
525 | } |
526 | |
527 | /* |
528 | ** Create a new symbolic label for an instruction that has yet to be |
529 | ** coded. The symbolic label is really just a negative number. The |
530 | ** label can be used as the P2 value of an operation. Later, when |
531 | ** the label is resolved to a specific address, the VDBE will scan |
532 | ** through its operation list and change all values of P2 which match |
533 | ** the label into the resolved address. |
534 | ** |
535 | ** The VDBE knows that a P2 value is a label because labels are |
536 | ** always negative and P2 values are suppose to be non-negative. |
537 | ** Hence, a negative P2 value is a label that has yet to be resolved. |
538 | ** (Later:) This is only true for opcodes that have the OPFLG_JUMP |
539 | ** property. |
540 | ** |
541 | ** Variable usage notes: |
542 | ** |
543 | ** Parse.aLabel[x] Stores the address that the x-th label resolves |
544 | ** into. For testing (SQLITE_DEBUG), unresolved |
545 | ** labels stores -1, but that is not required. |
546 | ** Parse.nLabelAlloc Number of slots allocated to Parse.aLabel[] |
547 | ** Parse.nLabel The *negative* of the number of labels that have |
548 | ** been issued. The negative is stored because |
549 | ** that gives a performance improvement over storing |
550 | ** the equivalent positive value. |
551 | */ |
552 | int sqlite3VdbeMakeLabel(Parse *pParse){ |
553 | return --pParse->nLabel; |
554 | } |
555 | |
556 | /* |
557 | ** Resolve label "x" to be the address of the next instruction to |
558 | ** be inserted. The parameter "x" must have been obtained from |
559 | ** a prior call to sqlite3VdbeMakeLabel(). |
560 | */ |
561 | static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){ |
562 | int nNewSize = 10 - p->nLabel; |
563 | p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel, |
564 | nNewSize*sizeof(p->aLabel[0])); |
565 | if( p->aLabel==0 ){ |
566 | p->nLabelAlloc = 0; |
567 | }else{ |
568 | #ifdef SQLITE_DEBUG |
569 | int i; |
570 | for(i=p->nLabelAlloc; i<nNewSize; i++) p->aLabel[i] = -1; |
571 | #endif |
572 | p->nLabelAlloc = nNewSize; |
573 | p->aLabel[j] = v->nOp; |
574 | } |
575 | } |
576 | void sqlite3VdbeResolveLabel(Vdbe *v, int x){ |
577 | Parse *p = v->pParse; |
578 | int j = ADDR(x); |
579 | assert( v->eVdbeState==VDBE_INIT_STATE ); |
580 | assert( j<-p->nLabel ); |
581 | assert( j>=0 ); |
582 | #ifdef SQLITE_DEBUG |
583 | if( p->db->flags & SQLITE_VdbeAddopTrace ){ |
584 | printf("RESOLVE LABEL %d to %d\n" , x, v->nOp); |
585 | } |
586 | #endif |
587 | if( p->nLabelAlloc + p->nLabel < 0 ){ |
588 | resizeResolveLabel(p,v,j); |
589 | }else{ |
590 | assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */ |
591 | p->aLabel[j] = v->nOp; |
592 | } |
593 | } |
594 | |
595 | /* |
596 | ** Mark the VDBE as one that can only be run one time. |
597 | */ |
598 | void sqlite3VdbeRunOnlyOnce(Vdbe *p){ |
599 | sqlite3VdbeAddOp2(p, OP_Expire, 1, 1); |
600 | } |
601 | |
602 | /* |
603 | ** Mark the VDBE as one that can be run multiple times. |
604 | */ |
605 | void sqlite3VdbeReusable(Vdbe *p){ |
606 | int i; |
607 | for(i=1; ALWAYS(i<p->nOp); i++){ |
608 | if( ALWAYS(p->aOp[i].opcode==OP_Expire) ){ |
609 | p->aOp[1].opcode = OP_Noop; |
610 | break; |
611 | } |
612 | } |
613 | } |
614 | |
615 | #ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */ |
616 | |
617 | /* |
618 | ** The following type and function are used to iterate through all opcodes |
619 | ** in a Vdbe main program and each of the sub-programs (triggers) it may |
620 | ** invoke directly or indirectly. It should be used as follows: |
621 | ** |
622 | ** Op *pOp; |
623 | ** VdbeOpIter sIter; |
624 | ** |
625 | ** memset(&sIter, 0, sizeof(sIter)); |
626 | ** sIter.v = v; // v is of type Vdbe* |
627 | ** while( (pOp = opIterNext(&sIter)) ){ |
628 | ** // Do something with pOp |
629 | ** } |
630 | ** sqlite3DbFree(v->db, sIter.apSub); |
631 | ** |
632 | */ |
633 | typedef struct VdbeOpIter VdbeOpIter; |
634 | struct VdbeOpIter { |
635 | Vdbe *v; /* Vdbe to iterate through the opcodes of */ |
636 | SubProgram **apSub; /* Array of subprograms */ |
637 | int nSub; /* Number of entries in apSub */ |
638 | int iAddr; /* Address of next instruction to return */ |
639 | int iSub; /* 0 = main program, 1 = first sub-program etc. */ |
640 | }; |
641 | static Op *opIterNext(VdbeOpIter *p){ |
642 | Vdbe *v = p->v; |
643 | Op *pRet = 0; |
644 | Op *aOp; |
645 | int nOp; |
646 | |
647 | if( p->iSub<=p->nSub ){ |
648 | |
649 | if( p->iSub==0 ){ |
650 | aOp = v->aOp; |
651 | nOp = v->nOp; |
652 | }else{ |
653 | aOp = p->apSub[p->iSub-1]->aOp; |
654 | nOp = p->apSub[p->iSub-1]->nOp; |
655 | } |
656 | assert( p->iAddr<nOp ); |
657 | |
658 | pRet = &aOp[p->iAddr]; |
659 | p->iAddr++; |
660 | if( p->iAddr==nOp ){ |
661 | p->iSub++; |
662 | p->iAddr = 0; |
663 | } |
664 | |
665 | if( pRet->p4type==P4_SUBPROGRAM ){ |
666 | int nByte = (p->nSub+1)*sizeof(SubProgram*); |
667 | int j; |
668 | for(j=0; j<p->nSub; j++){ |
669 | if( p->apSub[j]==pRet->p4.pProgram ) break; |
670 | } |
671 | if( j==p->nSub ){ |
672 | p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte); |
673 | if( !p->apSub ){ |
674 | pRet = 0; |
675 | }else{ |
676 | p->apSub[p->nSub++] = pRet->p4.pProgram; |
677 | } |
678 | } |
679 | } |
680 | } |
681 | |
682 | return pRet; |
683 | } |
684 | |
685 | /* |
686 | ** Check if the program stored in the VM associated with pParse may |
687 | ** throw an ABORT exception (causing the statement, but not entire transaction |
688 | ** to be rolled back). This condition is true if the main program or any |
689 | ** sub-programs contains any of the following: |
690 | ** |
691 | ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort. |
692 | ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort. |
693 | ** * OP_Destroy |
694 | ** * OP_VUpdate |
695 | ** * OP_VCreate |
696 | ** * OP_VRename |
697 | ** * OP_FkCounter with P2==0 (immediate foreign key constraint) |
698 | ** * OP_CreateBtree/BTREE_INTKEY and OP_InitCoroutine |
699 | ** (for CREATE TABLE AS SELECT ...) |
700 | ** |
701 | ** Then check that the value of Parse.mayAbort is true if an |
702 | ** ABORT may be thrown, or false otherwise. Return true if it does |
703 | ** match, or false otherwise. This function is intended to be used as |
704 | ** part of an assert statement in the compiler. Similar to: |
705 | ** |
706 | ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) ); |
707 | */ |
708 | int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){ |
709 | int hasAbort = 0; |
710 | int hasFkCounter = 0; |
711 | int hasCreateTable = 0; |
712 | int hasCreateIndex = 0; |
713 | int hasInitCoroutine = 0; |
714 | Op *pOp; |
715 | VdbeOpIter sIter; |
716 | |
717 | if( v==0 ) return 0; |
718 | memset(&sIter, 0, sizeof(sIter)); |
719 | sIter.v = v; |
720 | |
721 | while( (pOp = opIterNext(&sIter))!=0 ){ |
722 | int opcode = pOp->opcode; |
723 | if( opcode==OP_Destroy || opcode==OP_VUpdate || opcode==OP_VRename |
724 | || opcode==OP_VDestroy |
725 | || opcode==OP_VCreate |
726 | || opcode==OP_ParseSchema |
727 | || opcode==OP_Function || opcode==OP_PureFunc |
728 | || ((opcode==OP_Halt || opcode==OP_HaltIfNull) |
729 | && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort)) |
730 | ){ |
731 | hasAbort = 1; |
732 | break; |
733 | } |
734 | if( opcode==OP_CreateBtree && pOp->p3==BTREE_INTKEY ) hasCreateTable = 1; |
735 | if( mayAbort ){ |
736 | /* hasCreateIndex may also be set for some DELETE statements that use |
737 | ** OP_Clear. So this routine may end up returning true in the case |
738 | ** where a "DELETE FROM tbl" has a statement-journal but does not |
739 | ** require one. This is not so bad - it is an inefficiency, not a bug. */ |
740 | if( opcode==OP_CreateBtree && pOp->p3==BTREE_BLOBKEY ) hasCreateIndex = 1; |
741 | if( opcode==OP_Clear ) hasCreateIndex = 1; |
742 | } |
743 | if( opcode==OP_InitCoroutine ) hasInitCoroutine = 1; |
744 | #ifndef SQLITE_OMIT_FOREIGN_KEY |
745 | if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){ |
746 | hasFkCounter = 1; |
747 | } |
748 | #endif |
749 | } |
750 | sqlite3DbFree(v->db, sIter.apSub); |
751 | |
752 | /* Return true if hasAbort==mayAbort. Or if a malloc failure occurred. |
753 | ** If malloc failed, then the while() loop above may not have iterated |
754 | ** through all opcodes and hasAbort may be set incorrectly. Return |
755 | ** true for this case to prevent the assert() in the callers frame |
756 | ** from failing. */ |
757 | return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter |
758 | || (hasCreateTable && hasInitCoroutine) || hasCreateIndex |
759 | ); |
760 | } |
761 | #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */ |
762 | |
763 | #ifdef SQLITE_DEBUG |
764 | /* |
765 | ** Increment the nWrite counter in the VDBE if the cursor is not an |
766 | ** ephemeral cursor, or if the cursor argument is NULL. |
767 | */ |
768 | void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){ |
769 | if( pC==0 |
770 | || (pC->eCurType!=CURTYPE_SORTER |
771 | && pC->eCurType!=CURTYPE_PSEUDO |
772 | && !pC->isEphemeral) |
773 | ){ |
774 | p->nWrite++; |
775 | } |
776 | } |
777 | #endif |
778 | |
779 | #ifdef SQLITE_DEBUG |
780 | /* |
781 | ** Assert if an Abort at this point in time might result in a corrupt |
782 | ** database. |
783 | */ |
784 | void sqlite3VdbeAssertAbortable(Vdbe *p){ |
785 | assert( p->nWrite==0 || p->usesStmtJournal ); |
786 | } |
787 | #endif |
788 | |
789 | /* |
790 | ** This routine is called after all opcodes have been inserted. It loops |
791 | ** through all the opcodes and fixes up some details. |
792 | ** |
793 | ** (1) For each jump instruction with a negative P2 value (a label) |
794 | ** resolve the P2 value to an actual address. |
795 | ** |
796 | ** (2) Compute the maximum number of arguments used by any SQL function |
797 | ** and store that value in *pMaxFuncArgs. |
798 | ** |
799 | ** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately |
800 | ** indicate what the prepared statement actually does. |
801 | ** |
802 | ** (4) (discontinued) |
803 | ** |
804 | ** (5) Reclaim the memory allocated for storing labels. |
805 | ** |
806 | ** This routine will only function correctly if the mkopcodeh.tcl generator |
807 | ** script numbers the opcodes correctly. Changes to this routine must be |
808 | ** coordinated with changes to mkopcodeh.tcl. |
809 | */ |
810 | static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){ |
811 | int nMaxArgs = *pMaxFuncArgs; |
812 | Op *pOp; |
813 | Parse *pParse = p->pParse; |
814 | int *aLabel = pParse->aLabel; |
815 | p->readOnly = 1; |
816 | p->bIsReader = 0; |
817 | pOp = &p->aOp[p->nOp-1]; |
818 | assert( p->aOp[0].opcode==OP_Init ); |
819 | while( 1 /* Loop termates when it reaches the OP_Init opcode */ ){ |
820 | /* Only JUMP opcodes and the short list of special opcodes in the switch |
821 | ** below need to be considered. The mkopcodeh.tcl generator script groups |
822 | ** all these opcodes together near the front of the opcode list. Skip |
823 | ** any opcode that does not need processing by virtual of the fact that |
824 | ** it is larger than SQLITE_MX_JUMP_OPCODE, as a performance optimization. |
825 | */ |
826 | if( pOp->opcode<=SQLITE_MX_JUMP_OPCODE ){ |
827 | /* NOTE: Be sure to update mkopcodeh.tcl when adding or removing |
828 | ** cases from this switch! */ |
829 | switch( pOp->opcode ){ |
830 | case OP_Transaction: { |
831 | if( pOp->p2!=0 ) p->readOnly = 0; |
832 | /* no break */ deliberate_fall_through |
833 | } |
834 | case OP_AutoCommit: |
835 | case OP_Savepoint: { |
836 | p->bIsReader = 1; |
837 | break; |
838 | } |
839 | #ifndef SQLITE_OMIT_WAL |
840 | case OP_Checkpoint: |
841 | #endif |
842 | case OP_Vacuum: |
843 | case OP_JournalMode: { |
844 | p->readOnly = 0; |
845 | p->bIsReader = 1; |
846 | break; |
847 | } |
848 | case OP_Init: { |
849 | assert( pOp->p2>=0 ); |
850 | goto resolve_p2_values_loop_exit; |
851 | } |
852 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
853 | case OP_VUpdate: { |
854 | if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2; |
855 | break; |
856 | } |
857 | case OP_VFilter: { |
858 | int n; |
859 | assert( (pOp - p->aOp) >= 3 ); |
860 | assert( pOp[-1].opcode==OP_Integer ); |
861 | n = pOp[-1].p1; |
862 | if( n>nMaxArgs ) nMaxArgs = n; |
863 | /* Fall through into the default case */ |
864 | /* no break */ deliberate_fall_through |
865 | } |
866 | #endif |
867 | default: { |
868 | if( pOp->p2<0 ){ |
869 | /* The mkopcodeh.tcl script has so arranged things that the only |
870 | ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to |
871 | ** have non-negative values for P2. */ |
872 | assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 ); |
873 | assert( ADDR(pOp->p2)<-pParse->nLabel ); |
874 | pOp->p2 = aLabel[ADDR(pOp->p2)]; |
875 | } |
876 | break; |
877 | } |
878 | } |
879 | /* The mkopcodeh.tcl script has so arranged things that the only |
880 | ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to |
881 | ** have non-negative values for P2. */ |
882 | assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0); |
883 | } |
884 | assert( pOp>p->aOp ); |
885 | pOp--; |
886 | } |
887 | resolve_p2_values_loop_exit: |
888 | if( aLabel ){ |
889 | sqlite3DbNNFreeNN(p->db, pParse->aLabel); |
890 | pParse->aLabel = 0; |
891 | } |
892 | pParse->nLabel = 0; |
893 | *pMaxFuncArgs = nMaxArgs; |
894 | assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) ); |
895 | } |
896 | |
897 | #ifdef SQLITE_DEBUG |
898 | /* |
899 | ** Check to see if a subroutine contains a jump to a location outside of |
900 | ** the subroutine. If a jump outside the subroutine is detected, add code |
901 | ** that will cause the program to halt with an error message. |
902 | ** |
903 | ** The subroutine consists of opcodes between iFirst and iLast. Jumps to |
904 | ** locations within the subroutine are acceptable. iRetReg is a register |
905 | ** that contains the return address. Jumps to outside the range of iFirst |
906 | ** through iLast are also acceptable as long as the jump destination is |
907 | ** an OP_Return to iReturnAddr. |
908 | ** |
909 | ** A jump to an unresolved label means that the jump destination will be |
910 | ** beyond the current address. That is normally a jump to an early |
911 | ** termination and is consider acceptable. |
912 | ** |
913 | ** This routine only runs during debug builds. The purpose is (of course) |
914 | ** to detect invalid escapes out of a subroutine. The OP_Halt opcode |
915 | ** is generated rather than an assert() or other error, so that ".eqp full" |
916 | ** will still work to show the original bytecode, to aid in debugging. |
917 | */ |
918 | void sqlite3VdbeNoJumpsOutsideSubrtn( |
919 | Vdbe *v, /* The byte-code program under construction */ |
920 | int iFirst, /* First opcode of the subroutine */ |
921 | int iLast, /* Last opcode of the subroutine */ |
922 | int iRetReg /* Subroutine return address register */ |
923 | ){ |
924 | VdbeOp *pOp; |
925 | Parse *pParse; |
926 | int i; |
927 | sqlite3_str *pErr = 0; |
928 | assert( v!=0 ); |
929 | pParse = v->pParse; |
930 | assert( pParse!=0 ); |
931 | if( pParse->nErr ) return; |
932 | assert( iLast>=iFirst ); |
933 | assert( iLast<v->nOp ); |
934 | pOp = &v->aOp[iFirst]; |
935 | for(i=iFirst; i<=iLast; i++, pOp++){ |
936 | if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 ){ |
937 | int iDest = pOp->p2; /* Jump destination */ |
938 | if( iDest==0 ) continue; |
939 | if( pOp->opcode==OP_Gosub ) continue; |
940 | if( iDest<0 ){ |
941 | int j = ADDR(iDest); |
942 | assert( j>=0 ); |
943 | if( j>=-pParse->nLabel || pParse->aLabel[j]<0 ){ |
944 | continue; |
945 | } |
946 | iDest = pParse->aLabel[j]; |
947 | } |
948 | if( iDest<iFirst || iDest>iLast ){ |
949 | int j = iDest; |
950 | for(; j<v->nOp; j++){ |
951 | VdbeOp *pX = &v->aOp[j]; |
952 | if( pX->opcode==OP_Return ){ |
953 | if( pX->p1==iRetReg ) break; |
954 | continue; |
955 | } |
956 | if( pX->opcode==OP_Noop ) continue; |
957 | if( pX->opcode==OP_Explain ) continue; |
958 | if( pErr==0 ){ |
959 | pErr = sqlite3_str_new(0); |
960 | }else{ |
961 | sqlite3_str_appendchar(pErr, 1, '\n'); |
962 | } |
963 | sqlite3_str_appendf(pErr, |
964 | "Opcode at %d jumps to %d which is outside the " |
965 | "subroutine at %d..%d" , |
966 | i, iDest, iFirst, iLast); |
967 | break; |
968 | } |
969 | } |
970 | } |
971 | } |
972 | if( pErr ){ |
973 | char *zErr = sqlite3_str_finish(pErr); |
974 | sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_INTERNAL, OE_Abort, 0, zErr, 0); |
975 | sqlite3_free(zErr); |
976 | sqlite3MayAbort(pParse); |
977 | } |
978 | } |
979 | #endif /* SQLITE_DEBUG */ |
980 | |
981 | /* |
982 | ** Return the address of the next instruction to be inserted. |
983 | */ |
984 | int sqlite3VdbeCurrentAddr(Vdbe *p){ |
985 | assert( p->eVdbeState==VDBE_INIT_STATE ); |
986 | return p->nOp; |
987 | } |
988 | |
989 | /* |
990 | ** Verify that at least N opcode slots are available in p without |
991 | ** having to malloc for more space (except when compiled using |
992 | ** SQLITE_TEST_REALLOC_STRESS). This interface is used during testing |
993 | ** to verify that certain calls to sqlite3VdbeAddOpList() can never |
994 | ** fail due to a OOM fault and hence that the return value from |
995 | ** sqlite3VdbeAddOpList() will always be non-NULL. |
996 | */ |
997 | #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS) |
998 | void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N){ |
999 | assert( p->nOp + N <= p->nOpAlloc ); |
1000 | } |
1001 | #endif |
1002 | |
1003 | /* |
1004 | ** Verify that the VM passed as the only argument does not contain |
1005 | ** an OP_ResultRow opcode. Fail an assert() if it does. This is used |
1006 | ** by code in pragma.c to ensure that the implementation of certain |
1007 | ** pragmas comports with the flags specified in the mkpragmatab.tcl |
1008 | ** script. |
1009 | */ |
1010 | #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS) |
1011 | void sqlite3VdbeVerifyNoResultRow(Vdbe *p){ |
1012 | int i; |
1013 | for(i=0; i<p->nOp; i++){ |
1014 | assert( p->aOp[i].opcode!=OP_ResultRow ); |
1015 | } |
1016 | } |
1017 | #endif |
1018 | |
1019 | /* |
1020 | ** Generate code (a single OP_Abortable opcode) that will |
1021 | ** verify that the VDBE program can safely call Abort in the current |
1022 | ** context. |
1023 | */ |
1024 | #if defined(SQLITE_DEBUG) |
1025 | void sqlite3VdbeVerifyAbortable(Vdbe *p, int onError){ |
1026 | if( onError==OE_Abort ) sqlite3VdbeAddOp0(p, OP_Abortable); |
1027 | } |
1028 | #endif |
1029 | |
1030 | /* |
1031 | ** This function returns a pointer to the array of opcodes associated with |
1032 | ** the Vdbe passed as the first argument. It is the callers responsibility |
1033 | ** to arrange for the returned array to be eventually freed using the |
1034 | ** vdbeFreeOpArray() function. |
1035 | ** |
1036 | ** Before returning, *pnOp is set to the number of entries in the returned |
1037 | ** array. Also, *pnMaxArg is set to the larger of its current value and |
1038 | ** the number of entries in the Vdbe.apArg[] array required to execute the |
1039 | ** returned program. |
1040 | */ |
1041 | VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){ |
1042 | VdbeOp *aOp = p->aOp; |
1043 | assert( aOp && !p->db->mallocFailed ); |
1044 | |
1045 | /* Check that sqlite3VdbeUsesBtree() was not called on this VM */ |
1046 | assert( DbMaskAllZero(p->btreeMask) ); |
1047 | |
1048 | resolveP2Values(p, pnMaxArg); |
1049 | *pnOp = p->nOp; |
1050 | p->aOp = 0; |
1051 | return aOp; |
1052 | } |
1053 | |
1054 | /* |
1055 | ** Add a whole list of operations to the operation stack. Return a |
1056 | ** pointer to the first operation inserted. |
1057 | ** |
1058 | ** Non-zero P2 arguments to jump instructions are automatically adjusted |
1059 | ** so that the jump target is relative to the first operation inserted. |
1060 | */ |
1061 | VdbeOp *sqlite3VdbeAddOpList( |
1062 | Vdbe *p, /* Add opcodes to the prepared statement */ |
1063 | int nOp, /* Number of opcodes to add */ |
1064 | VdbeOpList const *aOp, /* The opcodes to be added */ |
1065 | int iLineno /* Source-file line number of first opcode */ |
1066 | ){ |
1067 | int i; |
1068 | VdbeOp *pOut, *pFirst; |
1069 | assert( nOp>0 ); |
1070 | assert( p->eVdbeState==VDBE_INIT_STATE ); |
1071 | if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){ |
1072 | return 0; |
1073 | } |
1074 | pFirst = pOut = &p->aOp[p->nOp]; |
1075 | for(i=0; i<nOp; i++, aOp++, pOut++){ |
1076 | pOut->opcode = aOp->opcode; |
1077 | pOut->p1 = aOp->p1; |
1078 | pOut->p2 = aOp->p2; |
1079 | assert( aOp->p2>=0 ); |
1080 | if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){ |
1081 | pOut->p2 += p->nOp; |
1082 | } |
1083 | pOut->p3 = aOp->p3; |
1084 | pOut->p4type = P4_NOTUSED; |
1085 | pOut->p4.p = 0; |
1086 | pOut->p5 = 0; |
1087 | #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS |
1088 | pOut->zComment = 0; |
1089 | #endif |
1090 | #ifdef SQLITE_VDBE_COVERAGE |
1091 | pOut->iSrcLine = iLineno+i; |
1092 | #else |
1093 | (void)iLineno; |
1094 | #endif |
1095 | #ifdef SQLITE_DEBUG |
1096 | if( p->db->flags & SQLITE_VdbeAddopTrace ){ |
1097 | sqlite3VdbePrintOp(0, i+p->nOp, &p->aOp[i+p->nOp]); |
1098 | } |
1099 | #endif |
1100 | } |
1101 | p->nOp += nOp; |
1102 | return pFirst; |
1103 | } |
1104 | |
1105 | #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) |
1106 | /* |
1107 | ** Add an entry to the array of counters managed by sqlite3_stmt_scanstatus(). |
1108 | */ |
1109 | void sqlite3VdbeScanStatus( |
1110 | Vdbe *p, /* VM to add scanstatus() to */ |
1111 | int addrExplain, /* Address of OP_Explain (or 0) */ |
1112 | int addrLoop, /* Address of loop counter */ |
1113 | int addrVisit, /* Address of rows visited counter */ |
1114 | LogEst nEst, /* Estimated number of output rows */ |
1115 | const char *zName /* Name of table or index being scanned */ |
1116 | ){ |
1117 | sqlite3_int64 nByte = (p->nScan+1) * sizeof(ScanStatus); |
1118 | ScanStatus *aNew; |
1119 | aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte); |
1120 | if( aNew ){ |
1121 | ScanStatus *pNew = &aNew[p->nScan++]; |
1122 | pNew->addrExplain = addrExplain; |
1123 | pNew->addrLoop = addrLoop; |
1124 | pNew->addrVisit = addrVisit; |
1125 | pNew->nEst = nEst; |
1126 | pNew->zName = sqlite3DbStrDup(p->db, zName); |
1127 | p->aScan = aNew; |
1128 | } |
1129 | } |
1130 | #endif |
1131 | |
1132 | |
1133 | /* |
1134 | ** Change the value of the opcode, or P1, P2, P3, or P5 operands |
1135 | ** for a specific instruction. |
1136 | */ |
1137 | void sqlite3VdbeChangeOpcode(Vdbe *p, int addr, u8 iNewOpcode){ |
1138 | assert( addr>=0 ); |
1139 | sqlite3VdbeGetOp(p,addr)->opcode = iNewOpcode; |
1140 | } |
1141 | void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){ |
1142 | assert( addr>=0 ); |
1143 | sqlite3VdbeGetOp(p,addr)->p1 = val; |
1144 | } |
1145 | void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){ |
1146 | assert( addr>=0 || p->db->mallocFailed ); |
1147 | sqlite3VdbeGetOp(p,addr)->p2 = val; |
1148 | } |
1149 | void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){ |
1150 | assert( addr>=0 ); |
1151 | sqlite3VdbeGetOp(p,addr)->p3 = val; |
1152 | } |
1153 | void sqlite3VdbeChangeP5(Vdbe *p, u16 p5){ |
1154 | assert( p->nOp>0 || p->db->mallocFailed ); |
1155 | if( p->nOp>0 ) p->aOp[p->nOp-1].p5 = p5; |
1156 | } |
1157 | |
1158 | /* |
1159 | ** If the previous opcode is an OP_Column that delivers results |
1160 | ** into register iDest, then add the OPFLAG_TYPEOFARG flag to that |
1161 | ** opcode. |
1162 | */ |
1163 | void sqlite3VdbeTypeofColumn(Vdbe *p, int iDest){ |
1164 | VdbeOp *pOp = sqlite3VdbeGetLastOp(p); |
1165 | if( pOp->p3==iDest && pOp->opcode==OP_Column ){ |
1166 | pOp->p5 |= OPFLAG_TYPEOFARG; |
1167 | } |
1168 | } |
1169 | |
1170 | /* |
1171 | ** Change the P2 operand of instruction addr so that it points to |
1172 | ** the address of the next instruction to be coded. |
1173 | */ |
1174 | void sqlite3VdbeJumpHere(Vdbe *p, int addr){ |
1175 | sqlite3VdbeChangeP2(p, addr, p->nOp); |
1176 | } |
1177 | |
1178 | /* |
1179 | ** Change the P2 operand of the jump instruction at addr so that |
1180 | ** the jump lands on the next opcode. Or if the jump instruction was |
1181 | ** the previous opcode (and is thus a no-op) then simply back up |
1182 | ** the next instruction counter by one slot so that the jump is |
1183 | ** overwritten by the next inserted opcode. |
1184 | ** |
1185 | ** This routine is an optimization of sqlite3VdbeJumpHere() that |
1186 | ** strives to omit useless byte-code like this: |
1187 | ** |
1188 | ** 7 Once 0 8 0 |
1189 | ** 8 ... |
1190 | */ |
1191 | void sqlite3VdbeJumpHereOrPopInst(Vdbe *p, int addr){ |
1192 | if( addr==p->nOp-1 ){ |
1193 | assert( p->aOp[addr].opcode==OP_Once |
1194 | || p->aOp[addr].opcode==OP_If |
1195 | || p->aOp[addr].opcode==OP_FkIfZero ); |
1196 | assert( p->aOp[addr].p4type==0 ); |
1197 | #ifdef SQLITE_VDBE_COVERAGE |
1198 | sqlite3VdbeGetLastOp(p)->iSrcLine = 0; /* Erase VdbeCoverage() macros */ |
1199 | #endif |
1200 | p->nOp--; |
1201 | }else{ |
1202 | sqlite3VdbeChangeP2(p, addr, p->nOp); |
1203 | } |
1204 | } |
1205 | |
1206 | |
1207 | /* |
1208 | ** If the input FuncDef structure is ephemeral, then free it. If |
1209 | ** the FuncDef is not ephermal, then do nothing. |
1210 | */ |
1211 | static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){ |
1212 | assert( db!=0 ); |
1213 | if( (pDef->funcFlags & SQLITE_FUNC_EPHEM)!=0 ){ |
1214 | sqlite3DbNNFreeNN(db, pDef); |
1215 | } |
1216 | } |
1217 | |
1218 | /* |
1219 | ** Delete a P4 value if necessary. |
1220 | */ |
1221 | static SQLITE_NOINLINE void freeP4Mem(sqlite3 *db, Mem *p){ |
1222 | if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc); |
1223 | sqlite3DbNNFreeNN(db, p); |
1224 | } |
1225 | static SQLITE_NOINLINE void freeP4FuncCtx(sqlite3 *db, sqlite3_context *p){ |
1226 | assert( db!=0 ); |
1227 | freeEphemeralFunction(db, p->pFunc); |
1228 | sqlite3DbNNFreeNN(db, p); |
1229 | } |
1230 | static void freeP4(sqlite3 *db, int p4type, void *p4){ |
1231 | assert( db ); |
1232 | switch( p4type ){ |
1233 | case P4_FUNCCTX: { |
1234 | freeP4FuncCtx(db, (sqlite3_context*)p4); |
1235 | break; |
1236 | } |
1237 | case P4_REAL: |
1238 | case P4_INT64: |
1239 | case P4_DYNAMIC: |
1240 | case P4_INTARRAY: { |
1241 | if( p4 ) sqlite3DbNNFreeNN(db, p4); |
1242 | break; |
1243 | } |
1244 | case P4_KEYINFO: { |
1245 | if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4); |
1246 | break; |
1247 | } |
1248 | #ifdef SQLITE_ENABLE_CURSOR_HINTS |
1249 | case P4_EXPR: { |
1250 | sqlite3ExprDelete(db, (Expr*)p4); |
1251 | break; |
1252 | } |
1253 | #endif |
1254 | case P4_FUNCDEF: { |
1255 | freeEphemeralFunction(db, (FuncDef*)p4); |
1256 | break; |
1257 | } |
1258 | case P4_MEM: { |
1259 | if( db->pnBytesFreed==0 ){ |
1260 | sqlite3ValueFree((sqlite3_value*)p4); |
1261 | }else{ |
1262 | freeP4Mem(db, (Mem*)p4); |
1263 | } |
1264 | break; |
1265 | } |
1266 | case P4_VTAB : { |
1267 | if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4); |
1268 | break; |
1269 | } |
1270 | } |
1271 | } |
1272 | |
1273 | /* |
1274 | ** Free the space allocated for aOp and any p4 values allocated for the |
1275 | ** opcodes contained within. If aOp is not NULL it is assumed to contain |
1276 | ** nOp entries. |
1277 | */ |
1278 | static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){ |
1279 | assert( nOp>=0 ); |
1280 | assert( db!=0 ); |
1281 | if( aOp ){ |
1282 | Op *pOp = &aOp[nOp-1]; |
1283 | while(1){ /* Exit via break */ |
1284 | if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p); |
1285 | #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS |
1286 | sqlite3DbFree(db, pOp->zComment); |
1287 | #endif |
1288 | if( pOp==aOp ) break; |
1289 | pOp--; |
1290 | } |
1291 | sqlite3DbNNFreeNN(db, aOp); |
1292 | } |
1293 | } |
1294 | |
1295 | /* |
1296 | ** Link the SubProgram object passed as the second argument into the linked |
1297 | ** list at Vdbe.pSubProgram. This list is used to delete all sub-program |
1298 | ** objects when the VM is no longer required. |
1299 | */ |
1300 | void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){ |
1301 | p->pNext = pVdbe->pProgram; |
1302 | pVdbe->pProgram = p; |
1303 | } |
1304 | |
1305 | /* |
1306 | ** Return true if the given Vdbe has any SubPrograms. |
1307 | */ |
1308 | int sqlite3VdbeHasSubProgram(Vdbe *pVdbe){ |
1309 | return pVdbe->pProgram!=0; |
1310 | } |
1311 | |
1312 | /* |
1313 | ** Change the opcode at addr into OP_Noop |
1314 | */ |
1315 | int sqlite3VdbeChangeToNoop(Vdbe *p, int addr){ |
1316 | VdbeOp *pOp; |
1317 | if( p->db->mallocFailed ) return 0; |
1318 | assert( addr>=0 && addr<p->nOp ); |
1319 | pOp = &p->aOp[addr]; |
1320 | freeP4(p->db, pOp->p4type, pOp->p4.p); |
1321 | pOp->p4type = P4_NOTUSED; |
1322 | pOp->p4.z = 0; |
1323 | pOp->opcode = OP_Noop; |
1324 | return 1; |
1325 | } |
1326 | |
1327 | /* |
1328 | ** If the last opcode is "op" and it is not a jump destination, |
1329 | ** then remove it. Return true if and only if an opcode was removed. |
1330 | */ |
1331 | int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){ |
1332 | if( p->nOp>0 && p->aOp[p->nOp-1].opcode==op ){ |
1333 | return sqlite3VdbeChangeToNoop(p, p->nOp-1); |
1334 | }else{ |
1335 | return 0; |
1336 | } |
1337 | } |
1338 | |
1339 | #ifdef SQLITE_DEBUG |
1340 | /* |
1341 | ** Generate an OP_ReleaseReg opcode to indicate that a range of |
1342 | ** registers, except any identified by mask, are no longer in use. |
1343 | */ |
1344 | void sqlite3VdbeReleaseRegisters( |
1345 | Parse *pParse, /* Parsing context */ |
1346 | int iFirst, /* Index of first register to be released */ |
1347 | int N, /* Number of registers to release */ |
1348 | u32 mask, /* Mask of registers to NOT release */ |
1349 | int bUndefine /* If true, mark registers as undefined */ |
1350 | ){ |
1351 | if( N==0 || OptimizationDisabled(pParse->db, SQLITE_ReleaseReg) ) return; |
1352 | assert( pParse->pVdbe ); |
1353 | assert( iFirst>=1 ); |
1354 | assert( iFirst+N-1<=pParse->nMem ); |
1355 | if( N<=31 && mask!=0 ){ |
1356 | while( N>0 && (mask&1)!=0 ){ |
1357 | mask >>= 1; |
1358 | iFirst++; |
1359 | N--; |
1360 | } |
1361 | while( N>0 && N<=32 && (mask & MASKBIT32(N-1))!=0 ){ |
1362 | mask &= ~MASKBIT32(N-1); |
1363 | N--; |
1364 | } |
1365 | } |
1366 | if( N>0 ){ |
1367 | sqlite3VdbeAddOp3(pParse->pVdbe, OP_ReleaseReg, iFirst, N, *(int*)&mask); |
1368 | if( bUndefine ) sqlite3VdbeChangeP5(pParse->pVdbe, 1); |
1369 | } |
1370 | } |
1371 | #endif /* SQLITE_DEBUG */ |
1372 | |
1373 | |
1374 | /* |
1375 | ** Change the value of the P4 operand for a specific instruction. |
1376 | ** This routine is useful when a large program is loaded from a |
1377 | ** static array using sqlite3VdbeAddOpList but we want to make a |
1378 | ** few minor changes to the program. |
1379 | ** |
1380 | ** If n>=0 then the P4 operand is dynamic, meaning that a copy of |
1381 | ** the string is made into memory obtained from sqlite3_malloc(). |
1382 | ** A value of n==0 means copy bytes of zP4 up to and including the |
1383 | ** first null byte. If n>0 then copy n+1 bytes of zP4. |
1384 | ** |
1385 | ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points |
1386 | ** to a string or structure that is guaranteed to exist for the lifetime of |
1387 | ** the Vdbe. In these cases we can just copy the pointer. |
1388 | ** |
1389 | ** If addr<0 then change P4 on the most recently inserted instruction. |
1390 | */ |
1391 | static void SQLITE_NOINLINE vdbeChangeP4Full( |
1392 | Vdbe *p, |
1393 | Op *pOp, |
1394 | const char *zP4, |
1395 | int n |
1396 | ){ |
1397 | if( pOp->p4type ){ |
1398 | freeP4(p->db, pOp->p4type, pOp->p4.p); |
1399 | pOp->p4type = 0; |
1400 | pOp->p4.p = 0; |
1401 | } |
1402 | if( n<0 ){ |
1403 | sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n); |
1404 | }else{ |
1405 | if( n==0 ) n = sqlite3Strlen30(zP4); |
1406 | pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n); |
1407 | pOp->p4type = P4_DYNAMIC; |
1408 | } |
1409 | } |
1410 | void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){ |
1411 | Op *pOp; |
1412 | sqlite3 *db; |
1413 | assert( p!=0 ); |
1414 | db = p->db; |
1415 | assert( p->eVdbeState==VDBE_INIT_STATE ); |
1416 | assert( p->aOp!=0 || db->mallocFailed ); |
1417 | if( db->mallocFailed ){ |
1418 | if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4); |
1419 | return; |
1420 | } |
1421 | assert( p->nOp>0 ); |
1422 | assert( addr<p->nOp ); |
1423 | if( addr<0 ){ |
1424 | addr = p->nOp - 1; |
1425 | } |
1426 | pOp = &p->aOp[addr]; |
1427 | if( n>=0 || pOp->p4type ){ |
1428 | vdbeChangeP4Full(p, pOp, zP4, n); |
1429 | return; |
1430 | } |
1431 | if( n==P4_INT32 ){ |
1432 | /* Note: this cast is safe, because the origin data point was an int |
1433 | ** that was cast to a (const char *). */ |
1434 | pOp->p4.i = SQLITE_PTR_TO_INT(zP4); |
1435 | pOp->p4type = P4_INT32; |
1436 | }else if( zP4!=0 ){ |
1437 | assert( n<0 ); |
1438 | pOp->p4.p = (void*)zP4; |
1439 | pOp->p4type = (signed char)n; |
1440 | if( n==P4_VTAB ) sqlite3VtabLock((VTable*)zP4); |
1441 | } |
1442 | } |
1443 | |
1444 | /* |
1445 | ** Change the P4 operand of the most recently coded instruction |
1446 | ** to the value defined by the arguments. This is a high-speed |
1447 | ** version of sqlite3VdbeChangeP4(). |
1448 | ** |
1449 | ** The P4 operand must not have been previously defined. And the new |
1450 | ** P4 must not be P4_INT32. Use sqlite3VdbeChangeP4() in either of |
1451 | ** those cases. |
1452 | */ |
1453 | void sqlite3VdbeAppendP4(Vdbe *p, void *pP4, int n){ |
1454 | VdbeOp *pOp; |
1455 | assert( n!=P4_INT32 && n!=P4_VTAB ); |
1456 | assert( n<=0 ); |
1457 | if( p->db->mallocFailed ){ |
1458 | freeP4(p->db, n, pP4); |
1459 | }else{ |
1460 | assert( pP4!=0 || n==P4_DYNAMIC ); |
1461 | assert( p->nOp>0 ); |
1462 | pOp = &p->aOp[p->nOp-1]; |
1463 | assert( pOp->p4type==P4_NOTUSED ); |
1464 | pOp->p4type = n; |
1465 | pOp->p4.p = pP4; |
1466 | } |
1467 | } |
1468 | |
1469 | /* |
1470 | ** Set the P4 on the most recently added opcode to the KeyInfo for the |
1471 | ** index given. |
1472 | */ |
1473 | void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){ |
1474 | Vdbe *v = pParse->pVdbe; |
1475 | KeyInfo *pKeyInfo; |
1476 | assert( v!=0 ); |
1477 | assert( pIdx!=0 ); |
1478 | pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx); |
1479 | if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); |
1480 | } |
1481 | |
1482 | #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS |
1483 | /* |
1484 | ** Change the comment on the most recently coded instruction. Or |
1485 | ** insert a No-op and add the comment to that new instruction. This |
1486 | ** makes the code easier to read during debugging. None of this happens |
1487 | ** in a production build. |
1488 | */ |
1489 | static void (Vdbe *p, const char *zFormat, va_list ap){ |
1490 | assert( p->nOp>0 || p->aOp==0 ); |
1491 | assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->pParse->nErr>0 ); |
1492 | if( p->nOp ){ |
1493 | assert( p->aOp ); |
1494 | sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment); |
1495 | p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap); |
1496 | } |
1497 | } |
1498 | void (Vdbe *p, const char *zFormat, ...){ |
1499 | va_list ap; |
1500 | if( p ){ |
1501 | va_start(ap, zFormat); |
1502 | vdbeVComment(p, zFormat, ap); |
1503 | va_end(ap); |
1504 | } |
1505 | } |
1506 | void (Vdbe *p, const char *zFormat, ...){ |
1507 | va_list ap; |
1508 | if( p ){ |
1509 | sqlite3VdbeAddOp0(p, OP_Noop); |
1510 | va_start(ap, zFormat); |
1511 | vdbeVComment(p, zFormat, ap); |
1512 | va_end(ap); |
1513 | } |
1514 | } |
1515 | #endif /* NDEBUG */ |
1516 | |
1517 | #ifdef SQLITE_VDBE_COVERAGE |
1518 | /* |
1519 | ** Set the value if the iSrcLine field for the previously coded instruction. |
1520 | */ |
1521 | void sqlite3VdbeSetLineNumber(Vdbe *v, int iLine){ |
1522 | sqlite3VdbeGetLastOp(v)->iSrcLine = iLine; |
1523 | } |
1524 | #endif /* SQLITE_VDBE_COVERAGE */ |
1525 | |
1526 | /* |
1527 | ** Return the opcode for a given address. The address must be non-negative. |
1528 | ** See sqlite3VdbeGetLastOp() to get the most recently added opcode. |
1529 | ** |
1530 | ** If a memory allocation error has occurred prior to the calling of this |
1531 | ** routine, then a pointer to a dummy VdbeOp will be returned. That opcode |
1532 | ** is readable but not writable, though it is cast to a writable value. |
1533 | ** The return of a dummy opcode allows the call to continue functioning |
1534 | ** after an OOM fault without having to check to see if the return from |
1535 | ** this routine is a valid pointer. But because the dummy.opcode is 0, |
1536 | ** dummy will never be written to. This is verified by code inspection and |
1537 | ** by running with Valgrind. |
1538 | */ |
1539 | VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ |
1540 | /* C89 specifies that the constant "dummy" will be initialized to all |
1541 | ** zeros, which is correct. MSVC generates a warning, nevertheless. */ |
1542 | static VdbeOp dummy; /* Ignore the MSVC warning about no initializer */ |
1543 | assert( p->eVdbeState==VDBE_INIT_STATE ); |
1544 | assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed ); |
1545 | if( p->db->mallocFailed ){ |
1546 | return (VdbeOp*)&dummy; |
1547 | }else{ |
1548 | return &p->aOp[addr]; |
1549 | } |
1550 | } |
1551 | |
1552 | /* Return the most recently added opcode |
1553 | */ |
1554 | VdbeOp * sqlite3VdbeGetLastOp(Vdbe *p){ |
1555 | return sqlite3VdbeGetOp(p, p->nOp - 1); |
1556 | } |
1557 | |
1558 | #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) |
1559 | /* |
1560 | ** Return an integer value for one of the parameters to the opcode pOp |
1561 | ** determined by character c. |
1562 | */ |
1563 | static int translateP(char c, const Op *pOp){ |
1564 | if( c=='1' ) return pOp->p1; |
1565 | if( c=='2' ) return pOp->p2; |
1566 | if( c=='3' ) return pOp->p3; |
1567 | if( c=='4' ) return pOp->p4.i; |
1568 | return pOp->p5; |
1569 | } |
1570 | |
1571 | /* |
1572 | ** Compute a string for the "comment" field of a VDBE opcode listing. |
1573 | ** |
1574 | ** The Synopsis: field in comments in the vdbe.c source file gets converted |
1575 | ** to an extra string that is appended to the sqlite3OpcodeName(). In the |
1576 | ** absence of other comments, this synopsis becomes the comment on the opcode. |
1577 | ** Some translation occurs: |
1578 | ** |
1579 | ** "PX" -> "r[X]" |
1580 | ** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1 |
1581 | ** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0 |
1582 | ** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x |
1583 | */ |
1584 | char *( |
1585 | sqlite3 *db, /* Optional - Oom error reporting only */ |
1586 | const Op *pOp, /* The opcode to be commented */ |
1587 | const char *zP4 /* Previously obtained value for P4 */ |
1588 | ){ |
1589 | const char *zOpName; |
1590 | const char *zSynopsis; |
1591 | int nOpName; |
1592 | int ii; |
1593 | char zAlt[50]; |
1594 | StrAccum x; |
1595 | |
1596 | sqlite3StrAccumInit(&x, 0, 0, 0, SQLITE_MAX_LENGTH); |
1597 | zOpName = sqlite3OpcodeName(pOp->opcode); |
1598 | nOpName = sqlite3Strlen30(zOpName); |
1599 | if( zOpName[nOpName+1] ){ |
1600 | int seenCom = 0; |
1601 | char c; |
1602 | zSynopsis = zOpName + nOpName + 1; |
1603 | if( strncmp(zSynopsis,"IF " ,3)==0 ){ |
1604 | sqlite3_snprintf(sizeof(zAlt), zAlt, "if %s goto P2" , zSynopsis+3); |
1605 | zSynopsis = zAlt; |
1606 | } |
1607 | for(ii=0; (c = zSynopsis[ii])!=0; ii++){ |
1608 | if( c=='P' ){ |
1609 | c = zSynopsis[++ii]; |
1610 | if( c=='4' ){ |
1611 | sqlite3_str_appendall(&x, zP4); |
1612 | }else if( c=='X' ){ |
1613 | if( pOp->zComment && pOp->zComment[0] ){ |
1614 | sqlite3_str_appendall(&x, pOp->zComment); |
1615 | seenCom = 1; |
1616 | break; |
1617 | } |
1618 | }else{ |
1619 | int v1 = translateP(c, pOp); |
1620 | int v2; |
1621 | if( strncmp(zSynopsis+ii+1, "@P" , 2)==0 ){ |
1622 | ii += 3; |
1623 | v2 = translateP(zSynopsis[ii], pOp); |
1624 | if( strncmp(zSynopsis+ii+1,"+1" ,2)==0 ){ |
1625 | ii += 2; |
1626 | v2++; |
1627 | } |
1628 | if( v2<2 ){ |
1629 | sqlite3_str_appendf(&x, "%d" , v1); |
1630 | }else{ |
1631 | sqlite3_str_appendf(&x, "%d..%d" , v1, v1+v2-1); |
1632 | } |
1633 | }else if( strncmp(zSynopsis+ii+1, "@NP" , 3)==0 ){ |
1634 | sqlite3_context *pCtx = pOp->p4.pCtx; |
1635 | if( pOp->p4type!=P4_FUNCCTX || pCtx->argc==1 ){ |
1636 | sqlite3_str_appendf(&x, "%d" , v1); |
1637 | }else if( pCtx->argc>1 ){ |
1638 | sqlite3_str_appendf(&x, "%d..%d" , v1, v1+pCtx->argc-1); |
1639 | }else if( x.accError==0 ){ |
1640 | assert( x.nChar>2 ); |
1641 | x.nChar -= 2; |
1642 | ii++; |
1643 | } |
1644 | ii += 3; |
1645 | }else{ |
1646 | sqlite3_str_appendf(&x, "%d" , v1); |
1647 | if( strncmp(zSynopsis+ii+1, "..P3" , 4)==0 && pOp->p3==0 ){ |
1648 | ii += 4; |
1649 | } |
1650 | } |
1651 | } |
1652 | }else{ |
1653 | sqlite3_str_appendchar(&x, 1, c); |
1654 | } |
1655 | } |
1656 | if( !seenCom && pOp->zComment ){ |
1657 | sqlite3_str_appendf(&x, "; %s" , pOp->zComment); |
1658 | } |
1659 | }else if( pOp->zComment ){ |
1660 | sqlite3_str_appendall(&x, pOp->zComment); |
1661 | } |
1662 | if( (x.accError & SQLITE_NOMEM)!=0 && db!=0 ){ |
1663 | sqlite3OomFault(db); |
1664 | } |
1665 | return sqlite3StrAccumFinish(&x); |
1666 | } |
1667 | #endif /* SQLITE_ENABLE_EXPLAIN_COMMENTS */ |
1668 | |
1669 | #if VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) |
1670 | /* |
1671 | ** Translate the P4.pExpr value for an OP_CursorHint opcode into text |
1672 | ** that can be displayed in the P4 column of EXPLAIN output. |
1673 | */ |
1674 | static void displayP4Expr(StrAccum *p, Expr *pExpr){ |
1675 | const char *zOp = 0; |
1676 | switch( pExpr->op ){ |
1677 | case TK_STRING: |
1678 | assert( !ExprHasProperty(pExpr, EP_IntValue) ); |
1679 | sqlite3_str_appendf(p, "%Q" , pExpr->u.zToken); |
1680 | break; |
1681 | case TK_INTEGER: |
1682 | sqlite3_str_appendf(p, "%d" , pExpr->u.iValue); |
1683 | break; |
1684 | case TK_NULL: |
1685 | sqlite3_str_appendf(p, "NULL" ); |
1686 | break; |
1687 | case TK_REGISTER: { |
1688 | sqlite3_str_appendf(p, "r[%d]" , pExpr->iTable); |
1689 | break; |
1690 | } |
1691 | case TK_COLUMN: { |
1692 | if( pExpr->iColumn<0 ){ |
1693 | sqlite3_str_appendf(p, "rowid" ); |
1694 | }else{ |
1695 | sqlite3_str_appendf(p, "c%d" , (int)pExpr->iColumn); |
1696 | } |
1697 | break; |
1698 | } |
1699 | case TK_LT: zOp = "LT" ; break; |
1700 | case TK_LE: zOp = "LE" ; break; |
1701 | case TK_GT: zOp = "GT" ; break; |
1702 | case TK_GE: zOp = "GE" ; break; |
1703 | case TK_NE: zOp = "NE" ; break; |
1704 | case TK_EQ: zOp = "EQ" ; break; |
1705 | case TK_IS: zOp = "IS" ; break; |
1706 | case TK_ISNOT: zOp = "ISNOT" ; break; |
1707 | case TK_AND: zOp = "AND" ; break; |
1708 | case TK_OR: zOp = "OR" ; break; |
1709 | case TK_PLUS: zOp = "ADD" ; break; |
1710 | case TK_STAR: zOp = "MUL" ; break; |
1711 | case TK_MINUS: zOp = "SUB" ; break; |
1712 | case TK_REM: zOp = "REM" ; break; |
1713 | case TK_BITAND: zOp = "BITAND" ; break; |
1714 | case TK_BITOR: zOp = "BITOR" ; break; |
1715 | case TK_SLASH: zOp = "DIV" ; break; |
1716 | case TK_LSHIFT: zOp = "LSHIFT" ; break; |
1717 | case TK_RSHIFT: zOp = "RSHIFT" ; break; |
1718 | case TK_CONCAT: zOp = "CONCAT" ; break; |
1719 | case TK_UMINUS: zOp = "MINUS" ; break; |
1720 | case TK_UPLUS: zOp = "PLUS" ; break; |
1721 | case TK_BITNOT: zOp = "BITNOT" ; break; |
1722 | case TK_NOT: zOp = "NOT" ; break; |
1723 | case TK_ISNULL: zOp = "ISNULL" ; break; |
1724 | case TK_NOTNULL: zOp = "NOTNULL" ; break; |
1725 | |
1726 | default: |
1727 | sqlite3_str_appendf(p, "%s" , "expr" ); |
1728 | break; |
1729 | } |
1730 | |
1731 | if( zOp ){ |
1732 | sqlite3_str_appendf(p, "%s(" , zOp); |
1733 | displayP4Expr(p, pExpr->pLeft); |
1734 | if( pExpr->pRight ){ |
1735 | sqlite3_str_append(p, "," , 1); |
1736 | displayP4Expr(p, pExpr->pRight); |
1737 | } |
1738 | sqlite3_str_append(p, ")" , 1); |
1739 | } |
1740 | } |
1741 | #endif /* VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) */ |
1742 | |
1743 | |
1744 | #if VDBE_DISPLAY_P4 |
1745 | /* |
1746 | ** Compute a string that describes the P4 parameter for an opcode. |
1747 | ** Use zTemp for any required temporary buffer space. |
1748 | */ |
1749 | char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){ |
1750 | char *zP4 = 0; |
1751 | StrAccum x; |
1752 | |
1753 | sqlite3StrAccumInit(&x, 0, 0, 0, SQLITE_MAX_LENGTH); |
1754 | switch( pOp->p4type ){ |
1755 | case P4_KEYINFO: { |
1756 | int j; |
1757 | KeyInfo *pKeyInfo = pOp->p4.pKeyInfo; |
1758 | assert( pKeyInfo->aSortFlags!=0 ); |
1759 | sqlite3_str_appendf(&x, "k(%d" , pKeyInfo->nKeyField); |
1760 | for(j=0; j<pKeyInfo->nKeyField; j++){ |
1761 | CollSeq *pColl = pKeyInfo->aColl[j]; |
1762 | const char *zColl = pColl ? pColl->zName : "" ; |
1763 | if( strcmp(zColl, "BINARY" )==0 ) zColl = "B" ; |
1764 | sqlite3_str_appendf(&x, ",%s%s%s" , |
1765 | (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_DESC) ? "-" : "" , |
1766 | (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "" , |
1767 | zColl); |
1768 | } |
1769 | sqlite3_str_append(&x, ")" , 1); |
1770 | break; |
1771 | } |
1772 | #ifdef SQLITE_ENABLE_CURSOR_HINTS |
1773 | case P4_EXPR: { |
1774 | displayP4Expr(&x, pOp->p4.pExpr); |
1775 | break; |
1776 | } |
1777 | #endif |
1778 | case P4_COLLSEQ: { |
1779 | static const char *const encnames[] = {"?" , "8" , "16LE" , "16BE" }; |
1780 | CollSeq *pColl = pOp->p4.pColl; |
1781 | assert( pColl->enc<4 ); |
1782 | sqlite3_str_appendf(&x, "%.18s-%s" , pColl->zName, |
1783 | encnames[pColl->enc]); |
1784 | break; |
1785 | } |
1786 | case P4_FUNCDEF: { |
1787 | FuncDef *pDef = pOp->p4.pFunc; |
1788 | sqlite3_str_appendf(&x, "%s(%d)" , pDef->zName, pDef->nArg); |
1789 | break; |
1790 | } |
1791 | case P4_FUNCCTX: { |
1792 | FuncDef *pDef = pOp->p4.pCtx->pFunc; |
1793 | sqlite3_str_appendf(&x, "%s(%d)" , pDef->zName, pDef->nArg); |
1794 | break; |
1795 | } |
1796 | case P4_INT64: { |
1797 | sqlite3_str_appendf(&x, "%lld" , *pOp->p4.pI64); |
1798 | break; |
1799 | } |
1800 | case P4_INT32: { |
1801 | sqlite3_str_appendf(&x, "%d" , pOp->p4.i); |
1802 | break; |
1803 | } |
1804 | case P4_REAL: { |
1805 | sqlite3_str_appendf(&x, "%.16g" , *pOp->p4.pReal); |
1806 | break; |
1807 | } |
1808 | case P4_MEM: { |
1809 | Mem *pMem = pOp->p4.pMem; |
1810 | if( pMem->flags & MEM_Str ){ |
1811 | zP4 = pMem->z; |
1812 | }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){ |
1813 | sqlite3_str_appendf(&x, "%lld" , pMem->u.i); |
1814 | }else if( pMem->flags & MEM_Real ){ |
1815 | sqlite3_str_appendf(&x, "%.16g" , pMem->u.r); |
1816 | }else if( pMem->flags & MEM_Null ){ |
1817 | zP4 = "NULL" ; |
1818 | }else{ |
1819 | assert( pMem->flags & MEM_Blob ); |
1820 | zP4 = "(blob)" ; |
1821 | } |
1822 | break; |
1823 | } |
1824 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
1825 | case P4_VTAB: { |
1826 | sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab; |
1827 | sqlite3_str_appendf(&x, "vtab:%p" , pVtab); |
1828 | break; |
1829 | } |
1830 | #endif |
1831 | case P4_INTARRAY: { |
1832 | u32 i; |
1833 | u32 *ai = pOp->p4.ai; |
1834 | u32 n = ai[0]; /* The first element of an INTARRAY is always the |
1835 | ** count of the number of elements to follow */ |
1836 | for(i=1; i<=n; i++){ |
1837 | sqlite3_str_appendf(&x, "%c%u" , (i==1 ? '[' : ','), ai[i]); |
1838 | } |
1839 | sqlite3_str_append(&x, "]" , 1); |
1840 | break; |
1841 | } |
1842 | case P4_SUBPROGRAM: { |
1843 | zP4 = "program" ; |
1844 | break; |
1845 | } |
1846 | case P4_TABLE: { |
1847 | zP4 = pOp->p4.pTab->zName; |
1848 | break; |
1849 | } |
1850 | default: { |
1851 | zP4 = pOp->p4.z; |
1852 | } |
1853 | } |
1854 | if( zP4 ) sqlite3_str_appendall(&x, zP4); |
1855 | if( (x.accError & SQLITE_NOMEM)!=0 ){ |
1856 | sqlite3OomFault(db); |
1857 | } |
1858 | return sqlite3StrAccumFinish(&x); |
1859 | } |
1860 | #endif /* VDBE_DISPLAY_P4 */ |
1861 | |
1862 | /* |
1863 | ** Declare to the Vdbe that the BTree object at db->aDb[i] is used. |
1864 | ** |
1865 | ** The prepared statements need to know in advance the complete set of |
1866 | ** attached databases that will be use. A mask of these databases |
1867 | ** is maintained in p->btreeMask. The p->lockMask value is the subset of |
1868 | ** p->btreeMask of databases that will require a lock. |
1869 | */ |
1870 | void sqlite3VdbeUsesBtree(Vdbe *p, int i){ |
1871 | assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 ); |
1872 | assert( i<(int)sizeof(p->btreeMask)*8 ); |
1873 | DbMaskSet(p->btreeMask, i); |
1874 | if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){ |
1875 | DbMaskSet(p->lockMask, i); |
1876 | } |
1877 | } |
1878 | |
1879 | #if !defined(SQLITE_OMIT_SHARED_CACHE) |
1880 | /* |
1881 | ** If SQLite is compiled to support shared-cache mode and to be threadsafe, |
1882 | ** this routine obtains the mutex associated with each BtShared structure |
1883 | ** that may be accessed by the VM passed as an argument. In doing so it also |
1884 | ** sets the BtShared.db member of each of the BtShared structures, ensuring |
1885 | ** that the correct busy-handler callback is invoked if required. |
1886 | ** |
1887 | ** If SQLite is not threadsafe but does support shared-cache mode, then |
1888 | ** sqlite3BtreeEnter() is invoked to set the BtShared.db variables |
1889 | ** of all of BtShared structures accessible via the database handle |
1890 | ** associated with the VM. |
1891 | ** |
1892 | ** If SQLite is not threadsafe and does not support shared-cache mode, this |
1893 | ** function is a no-op. |
1894 | ** |
1895 | ** The p->btreeMask field is a bitmask of all btrees that the prepared |
1896 | ** statement p will ever use. Let N be the number of bits in p->btreeMask |
1897 | ** corresponding to btrees that use shared cache. Then the runtime of |
1898 | ** this routine is N*N. But as N is rarely more than 1, this should not |
1899 | ** be a problem. |
1900 | */ |
1901 | void sqlite3VdbeEnter(Vdbe *p){ |
1902 | int i; |
1903 | sqlite3 *db; |
1904 | Db *aDb; |
1905 | int nDb; |
1906 | if( DbMaskAllZero(p->lockMask) ) return; /* The common case */ |
1907 | db = p->db; |
1908 | aDb = db->aDb; |
1909 | nDb = db->nDb; |
1910 | for(i=0; i<nDb; i++){ |
1911 | if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){ |
1912 | sqlite3BtreeEnter(aDb[i].pBt); |
1913 | } |
1914 | } |
1915 | } |
1916 | #endif |
1917 | |
1918 | #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0 |
1919 | /* |
1920 | ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter(). |
1921 | */ |
1922 | static SQLITE_NOINLINE void vdbeLeave(Vdbe *p){ |
1923 | int i; |
1924 | sqlite3 *db; |
1925 | Db *aDb; |
1926 | int nDb; |
1927 | db = p->db; |
1928 | aDb = db->aDb; |
1929 | nDb = db->nDb; |
1930 | for(i=0; i<nDb; i++){ |
1931 | if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){ |
1932 | sqlite3BtreeLeave(aDb[i].pBt); |
1933 | } |
1934 | } |
1935 | } |
1936 | void sqlite3VdbeLeave(Vdbe *p){ |
1937 | if( DbMaskAllZero(p->lockMask) ) return; /* The common case */ |
1938 | vdbeLeave(p); |
1939 | } |
1940 | #endif |
1941 | |
1942 | #if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) |
1943 | /* |
1944 | ** Print a single opcode. This routine is used for debugging only. |
1945 | */ |
1946 | void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){ |
1947 | char *zP4; |
1948 | char *zCom; |
1949 | sqlite3 dummyDb; |
1950 | static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-13s %.2X %s\n" ; |
1951 | if( pOut==0 ) pOut = stdout; |
1952 | sqlite3BeginBenignMalloc(); |
1953 | dummyDb.mallocFailed = 1; |
1954 | zP4 = sqlite3VdbeDisplayP4(&dummyDb, pOp); |
1955 | #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS |
1956 | zCom = sqlite3VdbeDisplayComment(0, pOp, zP4); |
1957 | #else |
1958 | zCom = 0; |
1959 | #endif |
1960 | /* NB: The sqlite3OpcodeName() function is implemented by code created |
1961 | ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the |
1962 | ** information from the vdbe.c source text */ |
1963 | fprintf(pOut, zFormat1, pc, |
1964 | sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, |
1965 | zP4 ? zP4 : "" , pOp->p5, |
1966 | zCom ? zCom : "" |
1967 | ); |
1968 | fflush(pOut); |
1969 | sqlite3_free(zP4); |
1970 | sqlite3_free(zCom); |
1971 | sqlite3EndBenignMalloc(); |
1972 | } |
1973 | #endif |
1974 | |
1975 | /* |
1976 | ** Initialize an array of N Mem element. |
1977 | ** |
1978 | ** This is a high-runner, so only those fields that really do need to |
1979 | ** be initialized are set. The Mem structure is organized so that |
1980 | ** the fields that get initialized are nearby and hopefully on the same |
1981 | ** cache line. |
1982 | ** |
1983 | ** Mem.flags = flags |
1984 | ** Mem.db = db |
1985 | ** Mem.szMalloc = 0 |
1986 | ** |
1987 | ** All other fields of Mem can safely remain uninitialized for now. They |
1988 | ** will be initialized before use. |
1989 | */ |
1990 | static void initMemArray(Mem *p, int N, sqlite3 *db, u16 flags){ |
1991 | if( N>0 ){ |
1992 | do{ |
1993 | p->flags = flags; |
1994 | p->db = db; |
1995 | p->szMalloc = 0; |
1996 | #ifdef SQLITE_DEBUG |
1997 | p->pScopyFrom = 0; |
1998 | #endif |
1999 | p++; |
2000 | }while( (--N)>0 ); |
2001 | } |
2002 | } |
2003 | |
2004 | /* |
2005 | ** Release auxiliary memory held in an array of N Mem elements. |
2006 | ** |
2007 | ** After this routine returns, all Mem elements in the array will still |
2008 | ** be valid. Those Mem elements that were not holding auxiliary resources |
2009 | ** will be unchanged. Mem elements which had something freed will be |
2010 | ** set to MEM_Undefined. |
2011 | */ |
2012 | static void releaseMemArray(Mem *p, int N){ |
2013 | if( p && N ){ |
2014 | Mem *pEnd = &p[N]; |
2015 | sqlite3 *db = p->db; |
2016 | if( db->pnBytesFreed ){ |
2017 | do{ |
2018 | if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc); |
2019 | }while( (++p)<pEnd ); |
2020 | return; |
2021 | } |
2022 | do{ |
2023 | assert( (&p[1])==pEnd || p[0].db==p[1].db ); |
2024 | assert( sqlite3VdbeCheckMemInvariants(p) ); |
2025 | |
2026 | /* This block is really an inlined version of sqlite3VdbeMemRelease() |
2027 | ** that takes advantage of the fact that the memory cell value is |
2028 | ** being set to NULL after releasing any dynamic resources. |
2029 | ** |
2030 | ** The justification for duplicating code is that according to |
2031 | ** callgrind, this causes a certain test case to hit the CPU 4.7 |
2032 | ** percent less (x86 linux, gcc version 4.1.2, -O6) than if |
2033 | ** sqlite3MemRelease() were called from here. With -O2, this jumps |
2034 | ** to 6.6 percent. The test case is inserting 1000 rows into a table |
2035 | ** with no indexes using a single prepared INSERT statement, bind() |
2036 | ** and reset(). Inserts are grouped into a transaction. |
2037 | */ |
2038 | testcase( p->flags & MEM_Agg ); |
2039 | testcase( p->flags & MEM_Dyn ); |
2040 | if( p->flags&(MEM_Agg|MEM_Dyn) ){ |
2041 | testcase( (p->flags & MEM_Dyn)!=0 && p->xDel==sqlite3VdbeFrameMemDel ); |
2042 | sqlite3VdbeMemRelease(p); |
2043 | p->flags = MEM_Undefined; |
2044 | }else if( p->szMalloc ){ |
2045 | sqlite3DbNNFreeNN(db, p->zMalloc); |
2046 | p->szMalloc = 0; |
2047 | p->flags = MEM_Undefined; |
2048 | } |
2049 | #ifdef SQLITE_DEBUG |
2050 | else{ |
2051 | p->flags = MEM_Undefined; |
2052 | } |
2053 | #endif |
2054 | }while( (++p)<pEnd ); |
2055 | } |
2056 | } |
2057 | |
2058 | #ifdef SQLITE_DEBUG |
2059 | /* |
2060 | ** Verify that pFrame is a valid VdbeFrame pointer. Return true if it is |
2061 | ** and false if something is wrong. |
2062 | ** |
2063 | ** This routine is intended for use inside of assert() statements only. |
2064 | */ |
2065 | int sqlite3VdbeFrameIsValid(VdbeFrame *pFrame){ |
2066 | if( pFrame->iFrameMagic!=SQLITE_FRAME_MAGIC ) return 0; |
2067 | return 1; |
2068 | } |
2069 | #endif |
2070 | |
2071 | |
2072 | /* |
2073 | ** This is a destructor on a Mem object (which is really an sqlite3_value) |
2074 | ** that deletes the Frame object that is attached to it as a blob. |
2075 | ** |
2076 | ** This routine does not delete the Frame right away. It merely adds the |
2077 | ** frame to a list of frames to be deleted when the Vdbe halts. |
2078 | */ |
2079 | void sqlite3VdbeFrameMemDel(void *pArg){ |
2080 | VdbeFrame *pFrame = (VdbeFrame*)pArg; |
2081 | assert( sqlite3VdbeFrameIsValid(pFrame) ); |
2082 | pFrame->pParent = pFrame->v->pDelFrame; |
2083 | pFrame->v->pDelFrame = pFrame; |
2084 | } |
2085 | |
2086 | #if defined(SQLITE_ENABLE_BYTECODE_VTAB) || !defined(SQLITE_OMIT_EXPLAIN) |
2087 | /* |
2088 | ** Locate the next opcode to be displayed in EXPLAIN or EXPLAIN |
2089 | ** QUERY PLAN output. |
2090 | ** |
2091 | ** Return SQLITE_ROW on success. Return SQLITE_DONE if there are no |
2092 | ** more opcodes to be displayed. |
2093 | */ |
2094 | int sqlite3VdbeNextOpcode( |
2095 | Vdbe *p, /* The statement being explained */ |
2096 | Mem *pSub, /* Storage for keeping track of subprogram nesting */ |
2097 | int eMode, /* 0: normal. 1: EQP. 2: TablesUsed */ |
2098 | int *piPc, /* IN/OUT: Current rowid. Overwritten with next rowid */ |
2099 | int *piAddr, /* OUT: Write index into (*paOp)[] here */ |
2100 | Op **paOp /* OUT: Write the opcode array here */ |
2101 | ){ |
2102 | int nRow; /* Stop when row count reaches this */ |
2103 | int nSub = 0; /* Number of sub-vdbes seen so far */ |
2104 | SubProgram **apSub = 0; /* Array of sub-vdbes */ |
2105 | int i; /* Next instruction address */ |
2106 | int rc = SQLITE_OK; /* Result code */ |
2107 | Op *aOp = 0; /* Opcode array */ |
2108 | int iPc; /* Rowid. Copy of value in *piPc */ |
2109 | |
2110 | /* When the number of output rows reaches nRow, that means the |
2111 | ** listing has finished and sqlite3_step() should return SQLITE_DONE. |
2112 | ** nRow is the sum of the number of rows in the main program, plus |
2113 | ** the sum of the number of rows in all trigger subprograms encountered |
2114 | ** so far. The nRow value will increase as new trigger subprograms are |
2115 | ** encountered, but p->pc will eventually catch up to nRow. |
2116 | */ |
2117 | nRow = p->nOp; |
2118 | if( pSub!=0 ){ |
2119 | if( pSub->flags&MEM_Blob ){ |
2120 | /* pSub is initiallly NULL. It is initialized to a BLOB by |
2121 | ** the P4_SUBPROGRAM processing logic below */ |
2122 | nSub = pSub->n/sizeof(Vdbe*); |
2123 | apSub = (SubProgram **)pSub->z; |
2124 | } |
2125 | for(i=0; i<nSub; i++){ |
2126 | nRow += apSub[i]->nOp; |
2127 | } |
2128 | } |
2129 | iPc = *piPc; |
2130 | while(1){ /* Loop exits via break */ |
2131 | i = iPc++; |
2132 | if( i>=nRow ){ |
2133 | p->rc = SQLITE_OK; |
2134 | rc = SQLITE_DONE; |
2135 | break; |
2136 | } |
2137 | if( i<p->nOp ){ |
2138 | /* The rowid is small enough that we are still in the |
2139 | ** main program. */ |
2140 | aOp = p->aOp; |
2141 | }else{ |
2142 | /* We are currently listing subprograms. Figure out which one and |
2143 | ** pick up the appropriate opcode. */ |
2144 | int j; |
2145 | i -= p->nOp; |
2146 | assert( apSub!=0 ); |
2147 | assert( nSub>0 ); |
2148 | for(j=0; i>=apSub[j]->nOp; j++){ |
2149 | i -= apSub[j]->nOp; |
2150 | assert( i<apSub[j]->nOp || j+1<nSub ); |
2151 | } |
2152 | aOp = apSub[j]->aOp; |
2153 | } |
2154 | |
2155 | /* When an OP_Program opcode is encounter (the only opcode that has |
2156 | ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms |
2157 | ** kept in p->aMem[9].z to hold the new program - assuming this subprogram |
2158 | ** has not already been seen. |
2159 | */ |
2160 | if( pSub!=0 && aOp[i].p4type==P4_SUBPROGRAM ){ |
2161 | int nByte = (nSub+1)*sizeof(SubProgram*); |
2162 | int j; |
2163 | for(j=0; j<nSub; j++){ |
2164 | if( apSub[j]==aOp[i].p4.pProgram ) break; |
2165 | } |
2166 | if( j==nSub ){ |
2167 | p->rc = sqlite3VdbeMemGrow(pSub, nByte, nSub!=0); |
2168 | if( p->rc!=SQLITE_OK ){ |
2169 | rc = SQLITE_ERROR; |
2170 | break; |
2171 | } |
2172 | apSub = (SubProgram **)pSub->z; |
2173 | apSub[nSub++] = aOp[i].p4.pProgram; |
2174 | MemSetTypeFlag(pSub, MEM_Blob); |
2175 | pSub->n = nSub*sizeof(SubProgram*); |
2176 | nRow += aOp[i].p4.pProgram->nOp; |
2177 | } |
2178 | } |
2179 | if( eMode==0 ) break; |
2180 | #ifdef SQLITE_ENABLE_BYTECODE_VTAB |
2181 | if( eMode==2 ){ |
2182 | Op *pOp = aOp + i; |
2183 | if( pOp->opcode==OP_OpenRead ) break; |
2184 | if( pOp->opcode==OP_OpenWrite && (pOp->p5 & OPFLAG_P2ISREG)==0 ) break; |
2185 | if( pOp->opcode==OP_ReopenIdx ) break; |
2186 | }else |
2187 | #endif |
2188 | { |
2189 | assert( eMode==1 ); |
2190 | if( aOp[i].opcode==OP_Explain ) break; |
2191 | if( aOp[i].opcode==OP_Init && iPc>1 ) break; |
2192 | } |
2193 | } |
2194 | *piPc = iPc; |
2195 | *piAddr = i; |
2196 | *paOp = aOp; |
2197 | return rc; |
2198 | } |
2199 | #endif /* SQLITE_ENABLE_BYTECODE_VTAB || !SQLITE_OMIT_EXPLAIN */ |
2200 | |
2201 | |
2202 | /* |
2203 | ** Delete a VdbeFrame object and its contents. VdbeFrame objects are |
2204 | ** allocated by the OP_Program opcode in sqlite3VdbeExec(). |
2205 | */ |
2206 | void sqlite3VdbeFrameDelete(VdbeFrame *p){ |
2207 | int i; |
2208 | Mem *aMem = VdbeFrameMem(p); |
2209 | VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem]; |
2210 | assert( sqlite3VdbeFrameIsValid(p) ); |
2211 | for(i=0; i<p->nChildCsr; i++){ |
2212 | if( apCsr[i] ) sqlite3VdbeFreeCursorNN(p->v, apCsr[i]); |
2213 | } |
2214 | releaseMemArray(aMem, p->nChildMem); |
2215 | sqlite3VdbeDeleteAuxData(p->v->db, &p->pAuxData, -1, 0); |
2216 | sqlite3DbFree(p->v->db, p); |
2217 | } |
2218 | |
2219 | #ifndef SQLITE_OMIT_EXPLAIN |
2220 | /* |
2221 | ** Give a listing of the program in the virtual machine. |
2222 | ** |
2223 | ** The interface is the same as sqlite3VdbeExec(). But instead of |
2224 | ** running the code, it invokes the callback once for each instruction. |
2225 | ** This feature is used to implement "EXPLAIN". |
2226 | ** |
2227 | ** When p->explain==1, each instruction is listed. When |
2228 | ** p->explain==2, only OP_Explain instructions are listed and these |
2229 | ** are shown in a different format. p->explain==2 is used to implement |
2230 | ** EXPLAIN QUERY PLAN. |
2231 | ** 2018-04-24: In p->explain==2 mode, the OP_Init opcodes of triggers |
2232 | ** are also shown, so that the boundaries between the main program and |
2233 | ** each trigger are clear. |
2234 | ** |
2235 | ** When p->explain==1, first the main program is listed, then each of |
2236 | ** the trigger subprograms are listed one by one. |
2237 | */ |
2238 | int sqlite3VdbeList( |
2239 | Vdbe *p /* The VDBE */ |
2240 | ){ |
2241 | Mem *pSub = 0; /* Memory cell hold array of subprogs */ |
2242 | sqlite3 *db = p->db; /* The database connection */ |
2243 | int i; /* Loop counter */ |
2244 | int rc = SQLITE_OK; /* Return code */ |
2245 | Mem *pMem = &p->aMem[1]; /* First Mem of result set */ |
2246 | int bListSubprogs = (p->explain==1 || (db->flags & SQLITE_TriggerEQP)!=0); |
2247 | Op *aOp; /* Array of opcodes */ |
2248 | Op *pOp; /* Current opcode */ |
2249 | |
2250 | assert( p->explain ); |
2251 | assert( p->eVdbeState==VDBE_RUN_STATE ); |
2252 | assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM ); |
2253 | |
2254 | /* Even though this opcode does not use dynamic strings for |
2255 | ** the result, result columns may become dynamic if the user calls |
2256 | ** sqlite3_column_text16(), causing a translation to UTF-16 encoding. |
2257 | */ |
2258 | releaseMemArray(pMem, 8); |
2259 | p->pResultSet = 0; |
2260 | |
2261 | if( p->rc==SQLITE_NOMEM ){ |
2262 | /* This happens if a malloc() inside a call to sqlite3_column_text() or |
2263 | ** sqlite3_column_text16() failed. */ |
2264 | sqlite3OomFault(db); |
2265 | return SQLITE_ERROR; |
2266 | } |
2267 | |
2268 | if( bListSubprogs ){ |
2269 | /* The first 8 memory cells are used for the result set. So we will |
2270 | ** commandeer the 9th cell to use as storage for an array of pointers |
2271 | ** to trigger subprograms. The VDBE is guaranteed to have at least 9 |
2272 | ** cells. */ |
2273 | assert( p->nMem>9 ); |
2274 | pSub = &p->aMem[9]; |
2275 | }else{ |
2276 | pSub = 0; |
2277 | } |
2278 | |
2279 | /* Figure out which opcode is next to display */ |
2280 | rc = sqlite3VdbeNextOpcode(p, pSub, p->explain==2, &p->pc, &i, &aOp); |
2281 | |
2282 | if( rc==SQLITE_OK ){ |
2283 | pOp = aOp + i; |
2284 | if( AtomicLoad(&db->u1.isInterrupted) ){ |
2285 | p->rc = SQLITE_INTERRUPT; |
2286 | rc = SQLITE_ERROR; |
2287 | sqlite3VdbeError(p, sqlite3ErrStr(p->rc)); |
2288 | }else{ |
2289 | char *zP4 = sqlite3VdbeDisplayP4(db, pOp); |
2290 | if( p->explain==2 ){ |
2291 | sqlite3VdbeMemSetInt64(pMem, pOp->p1); |
2292 | sqlite3VdbeMemSetInt64(pMem+1, pOp->p2); |
2293 | sqlite3VdbeMemSetInt64(pMem+2, pOp->p3); |
2294 | sqlite3VdbeMemSetStr(pMem+3, zP4, -1, SQLITE_UTF8, sqlite3_free); |
2295 | p->nResColumn = 4; |
2296 | }else{ |
2297 | sqlite3VdbeMemSetInt64(pMem+0, i); |
2298 | sqlite3VdbeMemSetStr(pMem+1, (char*)sqlite3OpcodeName(pOp->opcode), |
2299 | -1, SQLITE_UTF8, SQLITE_STATIC); |
2300 | sqlite3VdbeMemSetInt64(pMem+2, pOp->p1); |
2301 | sqlite3VdbeMemSetInt64(pMem+3, pOp->p2); |
2302 | sqlite3VdbeMemSetInt64(pMem+4, pOp->p3); |
2303 | /* pMem+5 for p4 is done last */ |
2304 | sqlite3VdbeMemSetInt64(pMem+6, pOp->p5); |
2305 | #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS |
2306 | { |
2307 | char *zCom = sqlite3VdbeDisplayComment(db, pOp, zP4); |
2308 | sqlite3VdbeMemSetStr(pMem+7, zCom, -1, SQLITE_UTF8, sqlite3_free); |
2309 | } |
2310 | #else |
2311 | sqlite3VdbeMemSetNull(pMem+7); |
2312 | #endif |
2313 | sqlite3VdbeMemSetStr(pMem+5, zP4, -1, SQLITE_UTF8, sqlite3_free); |
2314 | p->nResColumn = 8; |
2315 | } |
2316 | p->pResultSet = pMem; |
2317 | if( db->mallocFailed ){ |
2318 | p->rc = SQLITE_NOMEM; |
2319 | rc = SQLITE_ERROR; |
2320 | }else{ |
2321 | p->rc = SQLITE_OK; |
2322 | rc = SQLITE_ROW; |
2323 | } |
2324 | } |
2325 | } |
2326 | return rc; |
2327 | } |
2328 | #endif /* SQLITE_OMIT_EXPLAIN */ |
2329 | |
2330 | #ifdef SQLITE_DEBUG |
2331 | /* |
2332 | ** Print the SQL that was used to generate a VDBE program. |
2333 | */ |
2334 | void sqlite3VdbePrintSql(Vdbe *p){ |
2335 | const char *z = 0; |
2336 | if( p->zSql ){ |
2337 | z = p->zSql; |
2338 | }else if( p->nOp>=1 ){ |
2339 | const VdbeOp *pOp = &p->aOp[0]; |
2340 | if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){ |
2341 | z = pOp->p4.z; |
2342 | while( sqlite3Isspace(*z) ) z++; |
2343 | } |
2344 | } |
2345 | if( z ) printf("SQL: [%s]\n" , z); |
2346 | } |
2347 | #endif |
2348 | |
2349 | #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) |
2350 | /* |
2351 | ** Print an IOTRACE message showing SQL content. |
2352 | */ |
2353 | void sqlite3VdbeIOTraceSql(Vdbe *p){ |
2354 | int nOp = p->nOp; |
2355 | VdbeOp *pOp; |
2356 | if( sqlite3IoTrace==0 ) return; |
2357 | if( nOp<1 ) return; |
2358 | pOp = &p->aOp[0]; |
2359 | if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){ |
2360 | int i, j; |
2361 | char z[1000]; |
2362 | sqlite3_snprintf(sizeof(z), z, "%s" , pOp->p4.z); |
2363 | for(i=0; sqlite3Isspace(z[i]); i++){} |
2364 | for(j=0; z[i]; i++){ |
2365 | if( sqlite3Isspace(z[i]) ){ |
2366 | if( z[i-1]!=' ' ){ |
2367 | z[j++] = ' '; |
2368 | } |
2369 | }else{ |
2370 | z[j++] = z[i]; |
2371 | } |
2372 | } |
2373 | z[j] = 0; |
2374 | sqlite3IoTrace("SQL %s\n" , z); |
2375 | } |
2376 | } |
2377 | #endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */ |
2378 | |
2379 | /* An instance of this object describes bulk memory available for use |
2380 | ** by subcomponents of a prepared statement. Space is allocated out |
2381 | ** of a ReusableSpace object by the allocSpace() routine below. |
2382 | */ |
2383 | struct ReusableSpace { |
2384 | u8 *pSpace; /* Available memory */ |
2385 | sqlite3_int64 nFree; /* Bytes of available memory */ |
2386 | sqlite3_int64 nNeeded; /* Total bytes that could not be allocated */ |
2387 | }; |
2388 | |
2389 | /* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf |
2390 | ** from the ReusableSpace object. Return a pointer to the allocated |
2391 | ** memory on success. If insufficient memory is available in the |
2392 | ** ReusableSpace object, increase the ReusableSpace.nNeeded |
2393 | ** value by the amount needed and return NULL. |
2394 | ** |
2395 | ** If pBuf is not initially NULL, that means that the memory has already |
2396 | ** been allocated by a prior call to this routine, so just return a copy |
2397 | ** of pBuf and leave ReusableSpace unchanged. |
2398 | ** |
2399 | ** This allocator is employed to repurpose unused slots at the end of the |
2400 | ** opcode array of prepared state for other memory needs of the prepared |
2401 | ** statement. |
2402 | */ |
2403 | static void *allocSpace( |
2404 | struct ReusableSpace *p, /* Bulk memory available for allocation */ |
2405 | void *pBuf, /* Pointer to a prior allocation */ |
2406 | sqlite3_int64 nByte /* Bytes of memory needed. */ |
2407 | ){ |
2408 | assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) ); |
2409 | if( pBuf==0 ){ |
2410 | nByte = ROUND8P(nByte); |
2411 | if( nByte <= p->nFree ){ |
2412 | p->nFree -= nByte; |
2413 | pBuf = &p->pSpace[p->nFree]; |
2414 | }else{ |
2415 | p->nNeeded += nByte; |
2416 | } |
2417 | } |
2418 | assert( EIGHT_BYTE_ALIGNMENT(pBuf) ); |
2419 | return pBuf; |
2420 | } |
2421 | |
2422 | /* |
2423 | ** Rewind the VDBE back to the beginning in preparation for |
2424 | ** running it. |
2425 | */ |
2426 | void sqlite3VdbeRewind(Vdbe *p){ |
2427 | #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) |
2428 | int i; |
2429 | #endif |
2430 | assert( p!=0 ); |
2431 | assert( p->eVdbeState==VDBE_INIT_STATE |
2432 | || p->eVdbeState==VDBE_READY_STATE |
2433 | || p->eVdbeState==VDBE_HALT_STATE ); |
2434 | |
2435 | /* There should be at least one opcode. |
2436 | */ |
2437 | assert( p->nOp>0 ); |
2438 | |
2439 | p->eVdbeState = VDBE_READY_STATE; |
2440 | |
2441 | #ifdef SQLITE_DEBUG |
2442 | for(i=0; i<p->nMem; i++){ |
2443 | assert( p->aMem[i].db==p->db ); |
2444 | } |
2445 | #endif |
2446 | p->pc = -1; |
2447 | p->rc = SQLITE_OK; |
2448 | p->errorAction = OE_Abort; |
2449 | p->nChange = 0; |
2450 | p->cacheCtr = 1; |
2451 | p->minWriteFileFormat = 255; |
2452 | p->iStatement = 0; |
2453 | p->nFkConstraint = 0; |
2454 | #ifdef VDBE_PROFILE |
2455 | for(i=0; i<p->nOp; i++){ |
2456 | p->aOp[i].cnt = 0; |
2457 | p->aOp[i].cycles = 0; |
2458 | } |
2459 | #endif |
2460 | } |
2461 | |
2462 | /* |
2463 | ** Prepare a virtual machine for execution for the first time after |
2464 | ** creating the virtual machine. This involves things such |
2465 | ** as allocating registers and initializing the program counter. |
2466 | ** After the VDBE has be prepped, it can be executed by one or more |
2467 | ** calls to sqlite3VdbeExec(). |
2468 | ** |
2469 | ** This function may be called exactly once on each virtual machine. |
2470 | ** After this routine is called the VM has been "packaged" and is ready |
2471 | ** to run. After this routine is called, further calls to |
2472 | ** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects |
2473 | ** the Vdbe from the Parse object that helped generate it so that the |
2474 | ** the Vdbe becomes an independent entity and the Parse object can be |
2475 | ** destroyed. |
2476 | ** |
2477 | ** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back |
2478 | ** to its initial state after it has been run. |
2479 | */ |
2480 | void sqlite3VdbeMakeReady( |
2481 | Vdbe *p, /* The VDBE */ |
2482 | Parse *pParse /* Parsing context */ |
2483 | ){ |
2484 | sqlite3 *db; /* The database connection */ |
2485 | int nVar; /* Number of parameters */ |
2486 | int nMem; /* Number of VM memory registers */ |
2487 | int nCursor; /* Number of cursors required */ |
2488 | int nArg; /* Number of arguments in subprograms */ |
2489 | int n; /* Loop counter */ |
2490 | struct ReusableSpace x; /* Reusable bulk memory */ |
2491 | |
2492 | assert( p!=0 ); |
2493 | assert( p->nOp>0 ); |
2494 | assert( pParse!=0 ); |
2495 | assert( p->eVdbeState==VDBE_INIT_STATE ); |
2496 | assert( pParse==p->pParse ); |
2497 | p->pVList = pParse->pVList; |
2498 | pParse->pVList = 0; |
2499 | db = p->db; |
2500 | assert( db->mallocFailed==0 ); |
2501 | nVar = pParse->nVar; |
2502 | nMem = pParse->nMem; |
2503 | nCursor = pParse->nTab; |
2504 | nArg = pParse->nMaxArg; |
2505 | |
2506 | /* Each cursor uses a memory cell. The first cursor (cursor 0) can |
2507 | ** use aMem[0] which is not otherwise used by the VDBE program. Allocate |
2508 | ** space at the end of aMem[] for cursors 1 and greater. |
2509 | ** See also: allocateCursor(). |
2510 | */ |
2511 | nMem += nCursor; |
2512 | if( nCursor==0 && nMem>0 ) nMem++; /* Space for aMem[0] even if not used */ |
2513 | |
2514 | /* Figure out how much reusable memory is available at the end of the |
2515 | ** opcode array. This extra memory will be reallocated for other elements |
2516 | ** of the prepared statement. |
2517 | */ |
2518 | n = ROUND8P(sizeof(Op)*p->nOp); /* Bytes of opcode memory used */ |
2519 | x.pSpace = &((u8*)p->aOp)[n]; /* Unused opcode memory */ |
2520 | assert( EIGHT_BYTE_ALIGNMENT(x.pSpace) ); |
2521 | x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n); /* Bytes of unused memory */ |
2522 | assert( x.nFree>=0 ); |
2523 | assert( EIGHT_BYTE_ALIGNMENT(&x.pSpace[x.nFree]) ); |
2524 | |
2525 | resolveP2Values(p, &nArg); |
2526 | p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort); |
2527 | if( pParse->explain ){ |
2528 | static const char * const azColName[] = { |
2529 | "addr" , "opcode" , "p1" , "p2" , "p3" , "p4" , "p5" , "comment" , |
2530 | "id" , "parent" , "notused" , "detail" |
2531 | }; |
2532 | int iFirst, mx, i; |
2533 | if( nMem<10 ) nMem = 10; |
2534 | p->explain = pParse->explain; |
2535 | if( pParse->explain==2 ){ |
2536 | sqlite3VdbeSetNumCols(p, 4); |
2537 | iFirst = 8; |
2538 | mx = 12; |
2539 | }else{ |
2540 | sqlite3VdbeSetNumCols(p, 8); |
2541 | iFirst = 0; |
2542 | mx = 8; |
2543 | } |
2544 | for(i=iFirst; i<mx; i++){ |
2545 | sqlite3VdbeSetColName(p, i-iFirst, COLNAME_NAME, |
2546 | azColName[i], SQLITE_STATIC); |
2547 | } |
2548 | } |
2549 | p->expired = 0; |
2550 | |
2551 | /* Memory for registers, parameters, cursor, etc, is allocated in one or two |
2552 | ** passes. On the first pass, we try to reuse unused memory at the |
2553 | ** end of the opcode array. If we are unable to satisfy all memory |
2554 | ** requirements by reusing the opcode array tail, then the second |
2555 | ** pass will fill in the remainder using a fresh memory allocation. |
2556 | ** |
2557 | ** This two-pass approach that reuses as much memory as possible from |
2558 | ** the leftover memory at the end of the opcode array. This can significantly |
2559 | ** reduce the amount of memory held by a prepared statement. |
2560 | */ |
2561 | x.nNeeded = 0; |
2562 | p->aMem = allocSpace(&x, 0, nMem*sizeof(Mem)); |
2563 | p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem)); |
2564 | p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*)); |
2565 | p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*)); |
2566 | #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
2567 | p->anExec = allocSpace(&x, 0, p->nOp*sizeof(i64)); |
2568 | #endif |
2569 | if( x.nNeeded ){ |
2570 | x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded); |
2571 | x.nFree = x.nNeeded; |
2572 | if( !db->mallocFailed ){ |
2573 | p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem)); |
2574 | p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem)); |
2575 | p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*)); |
2576 | p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*)); |
2577 | #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
2578 | p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64)); |
2579 | #endif |
2580 | } |
2581 | } |
2582 | |
2583 | if( db->mallocFailed ){ |
2584 | p->nVar = 0; |
2585 | p->nCursor = 0; |
2586 | p->nMem = 0; |
2587 | }else{ |
2588 | p->nCursor = nCursor; |
2589 | p->nVar = (ynVar)nVar; |
2590 | initMemArray(p->aVar, nVar, db, MEM_Null); |
2591 | p->nMem = nMem; |
2592 | initMemArray(p->aMem, nMem, db, MEM_Undefined); |
2593 | memset(p->apCsr, 0, nCursor*sizeof(VdbeCursor*)); |
2594 | #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
2595 | memset(p->anExec, 0, p->nOp*sizeof(i64)); |
2596 | #endif |
2597 | } |
2598 | sqlite3VdbeRewind(p); |
2599 | } |
2600 | |
2601 | /* |
2602 | ** Close a VDBE cursor and release all the resources that cursor |
2603 | ** happens to hold. |
2604 | */ |
2605 | void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){ |
2606 | if( pCx ) sqlite3VdbeFreeCursorNN(p,pCx); |
2607 | } |
2608 | void sqlite3VdbeFreeCursorNN(Vdbe *p, VdbeCursor *pCx){ |
2609 | switch( pCx->eCurType ){ |
2610 | case CURTYPE_SORTER: { |
2611 | sqlite3VdbeSorterClose(p->db, pCx); |
2612 | break; |
2613 | } |
2614 | case CURTYPE_BTREE: { |
2615 | assert( pCx->uc.pCursor!=0 ); |
2616 | sqlite3BtreeCloseCursor(pCx->uc.pCursor); |
2617 | break; |
2618 | } |
2619 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
2620 | case CURTYPE_VTAB: { |
2621 | sqlite3_vtab_cursor *pVCur = pCx->uc.pVCur; |
2622 | const sqlite3_module *pModule = pVCur->pVtab->pModule; |
2623 | assert( pVCur->pVtab->nRef>0 ); |
2624 | pVCur->pVtab->nRef--; |
2625 | pModule->xClose(pVCur); |
2626 | break; |
2627 | } |
2628 | #endif |
2629 | } |
2630 | } |
2631 | |
2632 | /* |
2633 | ** Close all cursors in the current frame. |
2634 | */ |
2635 | static void closeCursorsInFrame(Vdbe *p){ |
2636 | int i; |
2637 | for(i=0; i<p->nCursor; i++){ |
2638 | VdbeCursor *pC = p->apCsr[i]; |
2639 | if( pC ){ |
2640 | sqlite3VdbeFreeCursorNN(p, pC); |
2641 | p->apCsr[i] = 0; |
2642 | } |
2643 | } |
2644 | } |
2645 | |
2646 | /* |
2647 | ** Copy the values stored in the VdbeFrame structure to its Vdbe. This |
2648 | ** is used, for example, when a trigger sub-program is halted to restore |
2649 | ** control to the main program. |
2650 | */ |
2651 | int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){ |
2652 | Vdbe *v = pFrame->v; |
2653 | closeCursorsInFrame(v); |
2654 | #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
2655 | v->anExec = pFrame->anExec; |
2656 | #endif |
2657 | v->aOp = pFrame->aOp; |
2658 | v->nOp = pFrame->nOp; |
2659 | v->aMem = pFrame->aMem; |
2660 | v->nMem = pFrame->nMem; |
2661 | v->apCsr = pFrame->apCsr; |
2662 | v->nCursor = pFrame->nCursor; |
2663 | v->db->lastRowid = pFrame->lastRowid; |
2664 | v->nChange = pFrame->nChange; |
2665 | v->db->nChange = pFrame->nDbChange; |
2666 | sqlite3VdbeDeleteAuxData(v->db, &v->pAuxData, -1, 0); |
2667 | v->pAuxData = pFrame->pAuxData; |
2668 | pFrame->pAuxData = 0; |
2669 | return pFrame->pc; |
2670 | } |
2671 | |
2672 | /* |
2673 | ** Close all cursors. |
2674 | ** |
2675 | ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory |
2676 | ** cell array. This is necessary as the memory cell array may contain |
2677 | ** pointers to VdbeFrame objects, which may in turn contain pointers to |
2678 | ** open cursors. |
2679 | */ |
2680 | static void closeAllCursors(Vdbe *p){ |
2681 | if( p->pFrame ){ |
2682 | VdbeFrame *pFrame; |
2683 | for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); |
2684 | sqlite3VdbeFrameRestore(pFrame); |
2685 | p->pFrame = 0; |
2686 | p->nFrame = 0; |
2687 | } |
2688 | assert( p->nFrame==0 ); |
2689 | closeCursorsInFrame(p); |
2690 | releaseMemArray(p->aMem, p->nMem); |
2691 | while( p->pDelFrame ){ |
2692 | VdbeFrame *pDel = p->pDelFrame; |
2693 | p->pDelFrame = pDel->pParent; |
2694 | sqlite3VdbeFrameDelete(pDel); |
2695 | } |
2696 | |
2697 | /* Delete any auxdata allocations made by the VM */ |
2698 | if( p->pAuxData ) sqlite3VdbeDeleteAuxData(p->db, &p->pAuxData, -1, 0); |
2699 | assert( p->pAuxData==0 ); |
2700 | } |
2701 | |
2702 | /* |
2703 | ** Set the number of result columns that will be returned by this SQL |
2704 | ** statement. This is now set at compile time, rather than during |
2705 | ** execution of the vdbe program so that sqlite3_column_count() can |
2706 | ** be called on an SQL statement before sqlite3_step(). |
2707 | */ |
2708 | void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){ |
2709 | int n; |
2710 | sqlite3 *db = p->db; |
2711 | |
2712 | if( p->nResColumn ){ |
2713 | releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); |
2714 | sqlite3DbFree(db, p->aColName); |
2715 | } |
2716 | n = nResColumn*COLNAME_N; |
2717 | p->nResColumn = (u16)nResColumn; |
2718 | p->aColName = (Mem*)sqlite3DbMallocRawNN(db, sizeof(Mem)*n ); |
2719 | if( p->aColName==0 ) return; |
2720 | initMemArray(p->aColName, n, db, MEM_Null); |
2721 | } |
2722 | |
2723 | /* |
2724 | ** Set the name of the idx'th column to be returned by the SQL statement. |
2725 | ** zName must be a pointer to a nul terminated string. |
2726 | ** |
2727 | ** This call must be made after a call to sqlite3VdbeSetNumCols(). |
2728 | ** |
2729 | ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC |
2730 | ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed |
2731 | ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed. |
2732 | */ |
2733 | int sqlite3VdbeSetColName( |
2734 | Vdbe *p, /* Vdbe being configured */ |
2735 | int idx, /* Index of column zName applies to */ |
2736 | int var, /* One of the COLNAME_* constants */ |
2737 | const char *zName, /* Pointer to buffer containing name */ |
2738 | void (*xDel)(void*) /* Memory management strategy for zName */ |
2739 | ){ |
2740 | int rc; |
2741 | Mem *pColName; |
2742 | assert( idx<p->nResColumn ); |
2743 | assert( var<COLNAME_N ); |
2744 | if( p->db->mallocFailed ){ |
2745 | assert( !zName || xDel!=SQLITE_DYNAMIC ); |
2746 | return SQLITE_NOMEM_BKPT; |
2747 | } |
2748 | assert( p->aColName!=0 ); |
2749 | pColName = &(p->aColName[idx+var*p->nResColumn]); |
2750 | rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel); |
2751 | assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 ); |
2752 | return rc; |
2753 | } |
2754 | |
2755 | /* |
2756 | ** A read or write transaction may or may not be active on database handle |
2757 | ** db. If a transaction is active, commit it. If there is a |
2758 | ** write-transaction spanning more than one database file, this routine |
2759 | ** takes care of the super-journal trickery. |
2760 | */ |
2761 | static int vdbeCommit(sqlite3 *db, Vdbe *p){ |
2762 | int i; |
2763 | int nTrans = 0; /* Number of databases with an active write-transaction |
2764 | ** that are candidates for a two-phase commit using a |
2765 | ** super-journal */ |
2766 | int rc = SQLITE_OK; |
2767 | int needXcommit = 0; |
2768 | |
2769 | #ifdef SQLITE_OMIT_VIRTUALTABLE |
2770 | /* With this option, sqlite3VtabSync() is defined to be simply |
2771 | ** SQLITE_OK so p is not used. |
2772 | */ |
2773 | UNUSED_PARAMETER(p); |
2774 | #endif |
2775 | |
2776 | /* Before doing anything else, call the xSync() callback for any |
2777 | ** virtual module tables written in this transaction. This has to |
2778 | ** be done before determining whether a super-journal file is |
2779 | ** required, as an xSync() callback may add an attached database |
2780 | ** to the transaction. |
2781 | */ |
2782 | rc = sqlite3VtabSync(db, p); |
2783 | |
2784 | /* This loop determines (a) if the commit hook should be invoked and |
2785 | ** (b) how many database files have open write transactions, not |
2786 | ** including the temp database. (b) is important because if more than |
2787 | ** one database file has an open write transaction, a super-journal |
2788 | ** file is required for an atomic commit. |
2789 | */ |
2790 | for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ |
2791 | Btree *pBt = db->aDb[i].pBt; |
2792 | if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){ |
2793 | /* Whether or not a database might need a super-journal depends upon |
2794 | ** its journal mode (among other things). This matrix determines which |
2795 | ** journal modes use a super-journal and which do not */ |
2796 | static const u8 aMJNeeded[] = { |
2797 | /* DELETE */ 1, |
2798 | /* PERSIST */ 1, |
2799 | /* OFF */ 0, |
2800 | /* TRUNCATE */ 1, |
2801 | /* MEMORY */ 0, |
2802 | /* WAL */ 0 |
2803 | }; |
2804 | Pager *; /* Pager associated with pBt */ |
2805 | needXcommit = 1; |
2806 | sqlite3BtreeEnter(pBt); |
2807 | pPager = sqlite3BtreePager(pBt); |
2808 | if( db->aDb[i].safety_level!=PAGER_SYNCHRONOUS_OFF |
2809 | && aMJNeeded[sqlite3PagerGetJournalMode(pPager)] |
2810 | && sqlite3PagerIsMemdb(pPager)==0 |
2811 | ){ |
2812 | assert( i!=1 ); |
2813 | nTrans++; |
2814 | } |
2815 | rc = sqlite3PagerExclusiveLock(pPager); |
2816 | sqlite3BtreeLeave(pBt); |
2817 | } |
2818 | } |
2819 | if( rc!=SQLITE_OK ){ |
2820 | return rc; |
2821 | } |
2822 | |
2823 | /* If there are any write-transactions at all, invoke the commit hook */ |
2824 | if( needXcommit && db->xCommitCallback ){ |
2825 | rc = db->xCommitCallback(db->pCommitArg); |
2826 | if( rc ){ |
2827 | return SQLITE_CONSTRAINT_COMMITHOOK; |
2828 | } |
2829 | } |
2830 | |
2831 | /* The simple case - no more than one database file (not counting the |
2832 | ** TEMP database) has a transaction active. There is no need for the |
2833 | ** super-journal. |
2834 | ** |
2835 | ** If the return value of sqlite3BtreeGetFilename() is a zero length |
2836 | ** string, it means the main database is :memory: or a temp file. In |
2837 | ** that case we do not support atomic multi-file commits, so use the |
2838 | ** simple case then too. |
2839 | */ |
2840 | if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt)) |
2841 | || nTrans<=1 |
2842 | ){ |
2843 | for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ |
2844 | Btree *pBt = db->aDb[i].pBt; |
2845 | if( pBt ){ |
2846 | rc = sqlite3BtreeCommitPhaseOne(pBt, 0); |
2847 | } |
2848 | } |
2849 | |
2850 | /* Do the commit only if all databases successfully complete phase 1. |
2851 | ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an |
2852 | ** IO error while deleting or truncating a journal file. It is unlikely, |
2853 | ** but could happen. In this case abandon processing and return the error. |
2854 | */ |
2855 | for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ |
2856 | Btree *pBt = db->aDb[i].pBt; |
2857 | if( pBt ){ |
2858 | rc = sqlite3BtreeCommitPhaseTwo(pBt, 0); |
2859 | } |
2860 | } |
2861 | if( rc==SQLITE_OK ){ |
2862 | sqlite3VtabCommit(db); |
2863 | } |
2864 | } |
2865 | |
2866 | /* The complex case - There is a multi-file write-transaction active. |
2867 | ** This requires a super-journal file to ensure the transaction is |
2868 | ** committed atomically. |
2869 | */ |
2870 | #ifndef SQLITE_OMIT_DISKIO |
2871 | else{ |
2872 | sqlite3_vfs *pVfs = db->pVfs; |
2873 | char *zSuper = 0; /* File-name for the super-journal */ |
2874 | char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt); |
2875 | sqlite3_file *pSuperJrnl = 0; |
2876 | i64 offset = 0; |
2877 | int res; |
2878 | int retryCount = 0; |
2879 | int nMainFile; |
2880 | |
2881 | /* Select a super-journal file name */ |
2882 | nMainFile = sqlite3Strlen30(zMainFile); |
2883 | zSuper = sqlite3MPrintf(db, "%.4c%s%.16c" , 0,zMainFile,0); |
2884 | if( zSuper==0 ) return SQLITE_NOMEM_BKPT; |
2885 | zSuper += 4; |
2886 | do { |
2887 | u32 iRandom; |
2888 | if( retryCount ){ |
2889 | if( retryCount>100 ){ |
2890 | sqlite3_log(SQLITE_FULL, "MJ delete: %s" , zSuper); |
2891 | sqlite3OsDelete(pVfs, zSuper, 0); |
2892 | break; |
2893 | }else if( retryCount==1 ){ |
2894 | sqlite3_log(SQLITE_FULL, "MJ collide: %s" , zSuper); |
2895 | } |
2896 | } |
2897 | retryCount++; |
2898 | sqlite3_randomness(sizeof(iRandom), &iRandom); |
2899 | sqlite3_snprintf(13, &zSuper[nMainFile], "-mj%06X9%02X" , |
2900 | (iRandom>>8)&0xffffff, iRandom&0xff); |
2901 | /* The antipenultimate character of the super-journal name must |
2902 | ** be "9" to avoid name collisions when using 8+3 filenames. */ |
2903 | assert( zSuper[sqlite3Strlen30(zSuper)-3]=='9' ); |
2904 | sqlite3FileSuffix3(zMainFile, zSuper); |
2905 | rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res); |
2906 | }while( rc==SQLITE_OK && res ); |
2907 | if( rc==SQLITE_OK ){ |
2908 | /* Open the super-journal. */ |
2909 | rc = sqlite3OsOpenMalloc(pVfs, zSuper, &pSuperJrnl, |
2910 | SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE| |
2911 | SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_SUPER_JOURNAL, 0 |
2912 | ); |
2913 | } |
2914 | if( rc!=SQLITE_OK ){ |
2915 | sqlite3DbFree(db, zSuper-4); |
2916 | return rc; |
2917 | } |
2918 | |
2919 | /* Write the name of each database file in the transaction into the new |
2920 | ** super-journal file. If an error occurs at this point close |
2921 | ** and delete the super-journal file. All the individual journal files |
2922 | ** still have 'null' as the super-journal pointer, so they will roll |
2923 | ** back independently if a failure occurs. |
2924 | */ |
2925 | for(i=0; i<db->nDb; i++){ |
2926 | Btree *pBt = db->aDb[i].pBt; |
2927 | if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){ |
2928 | char const *zFile = sqlite3BtreeGetJournalname(pBt); |
2929 | if( zFile==0 ){ |
2930 | continue; /* Ignore TEMP and :memory: databases */ |
2931 | } |
2932 | assert( zFile[0]!=0 ); |
2933 | rc = sqlite3OsWrite(pSuperJrnl, zFile, sqlite3Strlen30(zFile)+1,offset); |
2934 | offset += sqlite3Strlen30(zFile)+1; |
2935 | if( rc!=SQLITE_OK ){ |
2936 | sqlite3OsCloseFree(pSuperJrnl); |
2937 | sqlite3OsDelete(pVfs, zSuper, 0); |
2938 | sqlite3DbFree(db, zSuper-4); |
2939 | return rc; |
2940 | } |
2941 | } |
2942 | } |
2943 | |
2944 | /* Sync the super-journal file. If the IOCAP_SEQUENTIAL device |
2945 | ** flag is set this is not required. |
2946 | */ |
2947 | if( 0==(sqlite3OsDeviceCharacteristics(pSuperJrnl)&SQLITE_IOCAP_SEQUENTIAL) |
2948 | && SQLITE_OK!=(rc = sqlite3OsSync(pSuperJrnl, SQLITE_SYNC_NORMAL)) |
2949 | ){ |
2950 | sqlite3OsCloseFree(pSuperJrnl); |
2951 | sqlite3OsDelete(pVfs, zSuper, 0); |
2952 | sqlite3DbFree(db, zSuper-4); |
2953 | return rc; |
2954 | } |
2955 | |
2956 | /* Sync all the db files involved in the transaction. The same call |
2957 | ** sets the super-journal pointer in each individual journal. If |
2958 | ** an error occurs here, do not delete the super-journal file. |
2959 | ** |
2960 | ** If the error occurs during the first call to |
2961 | ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the |
2962 | ** super-journal file will be orphaned. But we cannot delete it, |
2963 | ** in case the super-journal file name was written into the journal |
2964 | ** file before the failure occurred. |
2965 | */ |
2966 | for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ |
2967 | Btree *pBt = db->aDb[i].pBt; |
2968 | if( pBt ){ |
2969 | rc = sqlite3BtreeCommitPhaseOne(pBt, zSuper); |
2970 | } |
2971 | } |
2972 | sqlite3OsCloseFree(pSuperJrnl); |
2973 | assert( rc!=SQLITE_BUSY ); |
2974 | if( rc!=SQLITE_OK ){ |
2975 | sqlite3DbFree(db, zSuper-4); |
2976 | return rc; |
2977 | } |
2978 | |
2979 | /* Delete the super-journal file. This commits the transaction. After |
2980 | ** doing this the directory is synced again before any individual |
2981 | ** transaction files are deleted. |
2982 | */ |
2983 | rc = sqlite3OsDelete(pVfs, zSuper, 1); |
2984 | sqlite3DbFree(db, zSuper-4); |
2985 | zSuper = 0; |
2986 | if( rc ){ |
2987 | return rc; |
2988 | } |
2989 | |
2990 | /* All files and directories have already been synced, so the following |
2991 | ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and |
2992 | ** deleting or truncating journals. If something goes wrong while |
2993 | ** this is happening we don't really care. The integrity of the |
2994 | ** transaction is already guaranteed, but some stray 'cold' journals |
2995 | ** may be lying around. Returning an error code won't help matters. |
2996 | */ |
2997 | disable_simulated_io_errors(); |
2998 | sqlite3BeginBenignMalloc(); |
2999 | for(i=0; i<db->nDb; i++){ |
3000 | Btree *pBt = db->aDb[i].pBt; |
3001 | if( pBt ){ |
3002 | sqlite3BtreeCommitPhaseTwo(pBt, 1); |
3003 | } |
3004 | } |
3005 | sqlite3EndBenignMalloc(); |
3006 | enable_simulated_io_errors(); |
3007 | |
3008 | sqlite3VtabCommit(db); |
3009 | } |
3010 | #endif |
3011 | |
3012 | return rc; |
3013 | } |
3014 | |
3015 | /* |
3016 | ** This routine checks that the sqlite3.nVdbeActive count variable |
3017 | ** matches the number of vdbe's in the list sqlite3.pVdbe that are |
3018 | ** currently active. An assertion fails if the two counts do not match. |
3019 | ** This is an internal self-check only - it is not an essential processing |
3020 | ** step. |
3021 | ** |
3022 | ** This is a no-op if NDEBUG is defined. |
3023 | */ |
3024 | #ifndef NDEBUG |
3025 | static void checkActiveVdbeCnt(sqlite3 *db){ |
3026 | Vdbe *p; |
3027 | int cnt = 0; |
3028 | int nWrite = 0; |
3029 | int nRead = 0; |
3030 | p = db->pVdbe; |
3031 | while( p ){ |
3032 | if( sqlite3_stmt_busy((sqlite3_stmt*)p) ){ |
3033 | cnt++; |
3034 | if( p->readOnly==0 ) nWrite++; |
3035 | if( p->bIsReader ) nRead++; |
3036 | } |
3037 | p = p->pVNext; |
3038 | } |
3039 | assert( cnt==db->nVdbeActive ); |
3040 | assert( nWrite==db->nVdbeWrite ); |
3041 | assert( nRead==db->nVdbeRead ); |
3042 | } |
3043 | #else |
3044 | #define checkActiveVdbeCnt(x) |
3045 | #endif |
3046 | |
3047 | /* |
3048 | ** If the Vdbe passed as the first argument opened a statement-transaction, |
3049 | ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or |
3050 | ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement |
3051 | ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the |
3052 | ** statement transaction is committed. |
3053 | ** |
3054 | ** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned. |
3055 | ** Otherwise SQLITE_OK. |
3056 | */ |
3057 | static SQLITE_NOINLINE int vdbeCloseStatement(Vdbe *p, int eOp){ |
3058 | sqlite3 *const db = p->db; |
3059 | int rc = SQLITE_OK; |
3060 | int i; |
3061 | const int iSavepoint = p->iStatement-1; |
3062 | |
3063 | assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE); |
3064 | assert( db->nStatement>0 ); |
3065 | assert( p->iStatement==(db->nStatement+db->nSavepoint) ); |
3066 | |
3067 | for(i=0; i<db->nDb; i++){ |
3068 | int rc2 = SQLITE_OK; |
3069 | Btree *pBt = db->aDb[i].pBt; |
3070 | if( pBt ){ |
3071 | if( eOp==SAVEPOINT_ROLLBACK ){ |
3072 | rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint); |
3073 | } |
3074 | if( rc2==SQLITE_OK ){ |
3075 | rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint); |
3076 | } |
3077 | if( rc==SQLITE_OK ){ |
3078 | rc = rc2; |
3079 | } |
3080 | } |
3081 | } |
3082 | db->nStatement--; |
3083 | p->iStatement = 0; |
3084 | |
3085 | if( rc==SQLITE_OK ){ |
3086 | if( eOp==SAVEPOINT_ROLLBACK ){ |
3087 | rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint); |
3088 | } |
3089 | if( rc==SQLITE_OK ){ |
3090 | rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint); |
3091 | } |
3092 | } |
3093 | |
3094 | /* If the statement transaction is being rolled back, also restore the |
3095 | ** database handles deferred constraint counter to the value it had when |
3096 | ** the statement transaction was opened. */ |
3097 | if( eOp==SAVEPOINT_ROLLBACK ){ |
3098 | db->nDeferredCons = p->nStmtDefCons; |
3099 | db->nDeferredImmCons = p->nStmtDefImmCons; |
3100 | } |
3101 | return rc; |
3102 | } |
3103 | int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){ |
3104 | if( p->db->nStatement && p->iStatement ){ |
3105 | return vdbeCloseStatement(p, eOp); |
3106 | } |
3107 | return SQLITE_OK; |
3108 | } |
3109 | |
3110 | |
3111 | /* |
3112 | ** This function is called when a transaction opened by the database |
3113 | ** handle associated with the VM passed as an argument is about to be |
3114 | ** committed. If there are outstanding deferred foreign key constraint |
3115 | ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK. |
3116 | ** |
3117 | ** If there are outstanding FK violations and this function returns |
3118 | ** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY |
3119 | ** and write an error message to it. Then return SQLITE_ERROR. |
3120 | */ |
3121 | #ifndef SQLITE_OMIT_FOREIGN_KEY |
3122 | int sqlite3VdbeCheckFk(Vdbe *p, int deferred){ |
3123 | sqlite3 *db = p->db; |
3124 | if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0) |
3125 | || (!deferred && p->nFkConstraint>0) |
3126 | ){ |
3127 | p->rc = SQLITE_CONSTRAINT_FOREIGNKEY; |
3128 | p->errorAction = OE_Abort; |
3129 | sqlite3VdbeError(p, "FOREIGN KEY constraint failed" ); |
3130 | if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ) return SQLITE_ERROR; |
3131 | return SQLITE_CONSTRAINT_FOREIGNKEY; |
3132 | } |
3133 | return SQLITE_OK; |
3134 | } |
3135 | #endif |
3136 | |
3137 | /* |
3138 | ** This routine is called the when a VDBE tries to halt. If the VDBE |
3139 | ** has made changes and is in autocommit mode, then commit those |
3140 | ** changes. If a rollback is needed, then do the rollback. |
3141 | ** |
3142 | ** This routine is the only way to move the sqlite3eOpenState of a VM from |
3143 | ** SQLITE_STATE_RUN to SQLITE_STATE_HALT. It is harmless to |
3144 | ** call this on a VM that is in the SQLITE_STATE_HALT state. |
3145 | ** |
3146 | ** Return an error code. If the commit could not complete because of |
3147 | ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it |
3148 | ** means the close did not happen and needs to be repeated. |
3149 | */ |
3150 | int sqlite3VdbeHalt(Vdbe *p){ |
3151 | int rc; /* Used to store transient return codes */ |
3152 | sqlite3 *db = p->db; |
3153 | |
3154 | /* This function contains the logic that determines if a statement or |
3155 | ** transaction will be committed or rolled back as a result of the |
3156 | ** execution of this virtual machine. |
3157 | ** |
3158 | ** If any of the following errors occur: |
3159 | ** |
3160 | ** SQLITE_NOMEM |
3161 | ** SQLITE_IOERR |
3162 | ** SQLITE_FULL |
3163 | ** SQLITE_INTERRUPT |
3164 | ** |
3165 | ** Then the internal cache might have been left in an inconsistent |
3166 | ** state. We need to rollback the statement transaction, if there is |
3167 | ** one, or the complete transaction if there is no statement transaction. |
3168 | */ |
3169 | |
3170 | assert( p->eVdbeState==VDBE_RUN_STATE ); |
3171 | if( db->mallocFailed ){ |
3172 | p->rc = SQLITE_NOMEM_BKPT; |
3173 | } |
3174 | closeAllCursors(p); |
3175 | checkActiveVdbeCnt(db); |
3176 | |
3177 | /* No commit or rollback needed if the program never started or if the |
3178 | ** SQL statement does not read or write a database file. */ |
3179 | if( p->bIsReader ){ |
3180 | int mrc; /* Primary error code from p->rc */ |
3181 | int eStatementOp = 0; |
3182 | int isSpecialError; /* Set to true if a 'special' error */ |
3183 | |
3184 | /* Lock all btrees used by the statement */ |
3185 | sqlite3VdbeEnter(p); |
3186 | |
3187 | /* Check for one of the special errors */ |
3188 | if( p->rc ){ |
3189 | mrc = p->rc & 0xff; |
3190 | isSpecialError = mrc==SQLITE_NOMEM |
3191 | || mrc==SQLITE_IOERR |
3192 | || mrc==SQLITE_INTERRUPT |
3193 | || mrc==SQLITE_FULL; |
3194 | }else{ |
3195 | mrc = isSpecialError = 0; |
3196 | } |
3197 | if( isSpecialError ){ |
3198 | /* If the query was read-only and the error code is SQLITE_INTERRUPT, |
3199 | ** no rollback is necessary. Otherwise, at least a savepoint |
3200 | ** transaction must be rolled back to restore the database to a |
3201 | ** consistent state. |
3202 | ** |
3203 | ** Even if the statement is read-only, it is important to perform |
3204 | ** a statement or transaction rollback operation. If the error |
3205 | ** occurred while writing to the journal, sub-journal or database |
3206 | ** file as part of an effort to free up cache space (see function |
3207 | ** pagerStress() in pager.c), the rollback is required to restore |
3208 | ** the pager to a consistent state. |
3209 | */ |
3210 | if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){ |
3211 | if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){ |
3212 | eStatementOp = SAVEPOINT_ROLLBACK; |
3213 | }else{ |
3214 | /* We are forced to roll back the active transaction. Before doing |
3215 | ** so, abort any other statements this handle currently has active. |
3216 | */ |
3217 | sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); |
3218 | sqlite3CloseSavepoints(db); |
3219 | db->autoCommit = 1; |
3220 | p->nChange = 0; |
3221 | } |
3222 | } |
3223 | } |
3224 | |
3225 | /* Check for immediate foreign key violations. */ |
3226 | if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ |
3227 | sqlite3VdbeCheckFk(p, 0); |
3228 | } |
3229 | |
3230 | /* If the auto-commit flag is set and this is the only active writer |
3231 | ** VM, then we do either a commit or rollback of the current transaction. |
3232 | ** |
3233 | ** Note: This block also runs if one of the special errors handled |
3234 | ** above has occurred. |
3235 | */ |
3236 | if( !sqlite3VtabInSync(db) |
3237 | && db->autoCommit |
3238 | && db->nVdbeWrite==(p->readOnly==0) |
3239 | ){ |
3240 | if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ |
3241 | rc = sqlite3VdbeCheckFk(p, 1); |
3242 | if( rc!=SQLITE_OK ){ |
3243 | if( NEVER(p->readOnly) ){ |
3244 | sqlite3VdbeLeave(p); |
3245 | return SQLITE_ERROR; |
3246 | } |
3247 | rc = SQLITE_CONSTRAINT_FOREIGNKEY; |
3248 | }else if( db->flags & SQLITE_CorruptRdOnly ){ |
3249 | rc = SQLITE_CORRUPT; |
3250 | db->flags &= ~SQLITE_CorruptRdOnly; |
3251 | }else{ |
3252 | /* The auto-commit flag is true, the vdbe program was successful |
3253 | ** or hit an 'OR FAIL' constraint and there are no deferred foreign |
3254 | ** key constraints to hold up the transaction. This means a commit |
3255 | ** is required. */ |
3256 | rc = vdbeCommit(db, p); |
3257 | } |
3258 | if( rc==SQLITE_BUSY && p->readOnly ){ |
3259 | sqlite3VdbeLeave(p); |
3260 | return SQLITE_BUSY; |
3261 | }else if( rc!=SQLITE_OK ){ |
3262 | p->rc = rc; |
3263 | sqlite3RollbackAll(db, SQLITE_OK); |
3264 | p->nChange = 0; |
3265 | }else{ |
3266 | db->nDeferredCons = 0; |
3267 | db->nDeferredImmCons = 0; |
3268 | db->flags &= ~(u64)SQLITE_DeferFKs; |
3269 | sqlite3CommitInternalChanges(db); |
3270 | } |
3271 | }else{ |
3272 | sqlite3RollbackAll(db, SQLITE_OK); |
3273 | p->nChange = 0; |
3274 | } |
3275 | db->nStatement = 0; |
3276 | }else if( eStatementOp==0 ){ |
3277 | if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){ |
3278 | eStatementOp = SAVEPOINT_RELEASE; |
3279 | }else if( p->errorAction==OE_Abort ){ |
3280 | eStatementOp = SAVEPOINT_ROLLBACK; |
3281 | }else{ |
3282 | sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); |
3283 | sqlite3CloseSavepoints(db); |
3284 | db->autoCommit = 1; |
3285 | p->nChange = 0; |
3286 | } |
3287 | } |
3288 | |
3289 | /* If eStatementOp is non-zero, then a statement transaction needs to |
3290 | ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to |
3291 | ** do so. If this operation returns an error, and the current statement |
3292 | ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the |
3293 | ** current statement error code. |
3294 | */ |
3295 | if( eStatementOp ){ |
3296 | rc = sqlite3VdbeCloseStatement(p, eStatementOp); |
3297 | if( rc ){ |
3298 | if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){ |
3299 | p->rc = rc; |
3300 | sqlite3DbFree(db, p->zErrMsg); |
3301 | p->zErrMsg = 0; |
3302 | } |
3303 | sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); |
3304 | sqlite3CloseSavepoints(db); |
3305 | db->autoCommit = 1; |
3306 | p->nChange = 0; |
3307 | } |
3308 | } |
3309 | |
3310 | /* If this was an INSERT, UPDATE or DELETE and no statement transaction |
3311 | ** has been rolled back, update the database connection change-counter. |
3312 | */ |
3313 | if( p->changeCntOn ){ |
3314 | if( eStatementOp!=SAVEPOINT_ROLLBACK ){ |
3315 | sqlite3VdbeSetChanges(db, p->nChange); |
3316 | }else{ |
3317 | sqlite3VdbeSetChanges(db, 0); |
3318 | } |
3319 | p->nChange = 0; |
3320 | } |
3321 | |
3322 | /* Release the locks */ |
3323 | sqlite3VdbeLeave(p); |
3324 | } |
3325 | |
3326 | /* We have successfully halted and closed the VM. Record this fact. */ |
3327 | db->nVdbeActive--; |
3328 | if( !p->readOnly ) db->nVdbeWrite--; |
3329 | if( p->bIsReader ) db->nVdbeRead--; |
3330 | assert( db->nVdbeActive>=db->nVdbeRead ); |
3331 | assert( db->nVdbeRead>=db->nVdbeWrite ); |
3332 | assert( db->nVdbeWrite>=0 ); |
3333 | p->eVdbeState = VDBE_HALT_STATE; |
3334 | checkActiveVdbeCnt(db); |
3335 | if( db->mallocFailed ){ |
3336 | p->rc = SQLITE_NOMEM_BKPT; |
3337 | } |
3338 | |
3339 | /* If the auto-commit flag is set to true, then any locks that were held |
3340 | ** by connection db have now been released. Call sqlite3ConnectionUnlocked() |
3341 | ** to invoke any required unlock-notify callbacks. |
3342 | */ |
3343 | if( db->autoCommit ){ |
3344 | sqlite3ConnectionUnlocked(db); |
3345 | } |
3346 | |
3347 | assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 ); |
3348 | return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK); |
3349 | } |
3350 | |
3351 | |
3352 | /* |
3353 | ** Each VDBE holds the result of the most recent sqlite3_step() call |
3354 | ** in p->rc. This routine sets that result back to SQLITE_OK. |
3355 | */ |
3356 | void sqlite3VdbeResetStepResult(Vdbe *p){ |
3357 | p->rc = SQLITE_OK; |
3358 | } |
3359 | |
3360 | /* |
3361 | ** Copy the error code and error message belonging to the VDBE passed |
3362 | ** as the first argument to its database handle (so that they will be |
3363 | ** returned by calls to sqlite3_errcode() and sqlite3_errmsg()). |
3364 | ** |
3365 | ** This function does not clear the VDBE error code or message, just |
3366 | ** copies them to the database handle. |
3367 | */ |
3368 | int sqlite3VdbeTransferError(Vdbe *p){ |
3369 | sqlite3 *db = p->db; |
3370 | int rc = p->rc; |
3371 | if( p->zErrMsg ){ |
3372 | db->bBenignMalloc++; |
3373 | sqlite3BeginBenignMalloc(); |
3374 | if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db); |
3375 | sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT); |
3376 | sqlite3EndBenignMalloc(); |
3377 | db->bBenignMalloc--; |
3378 | }else if( db->pErr ){ |
3379 | sqlite3ValueSetNull(db->pErr); |
3380 | } |
3381 | db->errCode = rc; |
3382 | db->errByteOffset = -1; |
3383 | return rc; |
3384 | } |
3385 | |
3386 | #ifdef SQLITE_ENABLE_SQLLOG |
3387 | /* |
3388 | ** If an SQLITE_CONFIG_SQLLOG hook is registered and the VM has been run, |
3389 | ** invoke it. |
3390 | */ |
3391 | static void vdbeInvokeSqllog(Vdbe *v){ |
3392 | if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){ |
3393 | char *zExpanded = sqlite3VdbeExpandSql(v, v->zSql); |
3394 | assert( v->db->init.busy==0 ); |
3395 | if( zExpanded ){ |
3396 | sqlite3GlobalConfig.xSqllog( |
3397 | sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1 |
3398 | ); |
3399 | sqlite3DbFree(v->db, zExpanded); |
3400 | } |
3401 | } |
3402 | } |
3403 | #else |
3404 | # define vdbeInvokeSqllog(x) |
3405 | #endif |
3406 | |
3407 | /* |
3408 | ** Clean up a VDBE after execution but do not delete the VDBE just yet. |
3409 | ** Write any error messages into *pzErrMsg. Return the result code. |
3410 | ** |
3411 | ** After this routine is run, the VDBE should be ready to be executed |
3412 | ** again. |
3413 | ** |
3414 | ** To look at it another way, this routine resets the state of the |
3415 | ** virtual machine from VDBE_RUN_STATE or VDBE_HALT_STATE back to |
3416 | ** VDBE_READY_STATE. |
3417 | */ |
3418 | int sqlite3VdbeReset(Vdbe *p){ |
3419 | #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) |
3420 | int i; |
3421 | #endif |
3422 | |
3423 | sqlite3 *db; |
3424 | db = p->db; |
3425 | |
3426 | /* If the VM did not run to completion or if it encountered an |
3427 | ** error, then it might not have been halted properly. So halt |
3428 | ** it now. |
3429 | */ |
3430 | if( p->eVdbeState==VDBE_RUN_STATE ) sqlite3VdbeHalt(p); |
3431 | |
3432 | /* If the VDBE has been run even partially, then transfer the error code |
3433 | ** and error message from the VDBE into the main database structure. But |
3434 | ** if the VDBE has just been set to run but has not actually executed any |
3435 | ** instructions yet, leave the main database error information unchanged. |
3436 | */ |
3437 | if( p->pc>=0 ){ |
3438 | vdbeInvokeSqllog(p); |
3439 | if( db->pErr || p->zErrMsg ){ |
3440 | sqlite3VdbeTransferError(p); |
3441 | }else{ |
3442 | db->errCode = p->rc; |
3443 | } |
3444 | } |
3445 | |
3446 | /* Reset register contents and reclaim error message memory. |
3447 | */ |
3448 | #ifdef SQLITE_DEBUG |
3449 | /* Execute assert() statements to ensure that the Vdbe.apCsr[] and |
3450 | ** Vdbe.aMem[] arrays have already been cleaned up. */ |
3451 | if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 ); |
3452 | if( p->aMem ){ |
3453 | for(i=0; i<p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined ); |
3454 | } |
3455 | #endif |
3456 | if( p->zErrMsg ){ |
3457 | sqlite3DbFree(db, p->zErrMsg); |
3458 | p->zErrMsg = 0; |
3459 | } |
3460 | p->pResultSet = 0; |
3461 | #ifdef SQLITE_DEBUG |
3462 | p->nWrite = 0; |
3463 | #endif |
3464 | |
3465 | /* Save profiling information from this VDBE run. |
3466 | */ |
3467 | #ifdef VDBE_PROFILE |
3468 | { |
3469 | FILE *out = fopen("vdbe_profile.out" , "a" ); |
3470 | if( out ){ |
3471 | fprintf(out, "---- " ); |
3472 | for(i=0; i<p->nOp; i++){ |
3473 | fprintf(out, "%02x" , p->aOp[i].opcode); |
3474 | } |
3475 | fprintf(out, "\n" ); |
3476 | if( p->zSql ){ |
3477 | char c, pc = 0; |
3478 | fprintf(out, "-- " ); |
3479 | for(i=0; (c = p->zSql[i])!=0; i++){ |
3480 | if( pc=='\n' ) fprintf(out, "-- " ); |
3481 | putc(c, out); |
3482 | pc = c; |
3483 | } |
3484 | if( pc!='\n' ) fprintf(out, "\n" ); |
3485 | } |
3486 | for(i=0; i<p->nOp; i++){ |
3487 | char zHdr[100]; |
3488 | sqlite3_snprintf(sizeof(zHdr), zHdr, "%6u %12llu %8llu " , |
3489 | p->aOp[i].cnt, |
3490 | p->aOp[i].cycles, |
3491 | p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0 |
3492 | ); |
3493 | fprintf(out, "%s" , zHdr); |
3494 | sqlite3VdbePrintOp(out, i, &p->aOp[i]); |
3495 | } |
3496 | fclose(out); |
3497 | } |
3498 | } |
3499 | #endif |
3500 | return p->rc & db->errMask; |
3501 | } |
3502 | |
3503 | /* |
3504 | ** Clean up and delete a VDBE after execution. Return an integer which is |
3505 | ** the result code. Write any error message text into *pzErrMsg. |
3506 | */ |
3507 | int sqlite3VdbeFinalize(Vdbe *p){ |
3508 | int rc = SQLITE_OK; |
3509 | assert( VDBE_RUN_STATE>VDBE_READY_STATE ); |
3510 | assert( VDBE_HALT_STATE>VDBE_READY_STATE ); |
3511 | assert( VDBE_INIT_STATE<VDBE_READY_STATE ); |
3512 | if( p->eVdbeState>=VDBE_READY_STATE ){ |
3513 | rc = sqlite3VdbeReset(p); |
3514 | assert( (rc & p->db->errMask)==rc ); |
3515 | } |
3516 | sqlite3VdbeDelete(p); |
3517 | return rc; |
3518 | } |
3519 | |
3520 | /* |
3521 | ** If parameter iOp is less than zero, then invoke the destructor for |
3522 | ** all auxiliary data pointers currently cached by the VM passed as |
3523 | ** the first argument. |
3524 | ** |
3525 | ** Or, if iOp is greater than or equal to zero, then the destructor is |
3526 | ** only invoked for those auxiliary data pointers created by the user |
3527 | ** function invoked by the OP_Function opcode at instruction iOp of |
3528 | ** VM pVdbe, and only then if: |
3529 | ** |
3530 | ** * the associated function parameter is the 32nd or later (counting |
3531 | ** from left to right), or |
3532 | ** |
3533 | ** * the corresponding bit in argument mask is clear (where the first |
3534 | ** function parameter corresponds to bit 0 etc.). |
3535 | */ |
3536 | void sqlite3VdbeDeleteAuxData(sqlite3 *db, AuxData **pp, int iOp, int mask){ |
3537 | while( *pp ){ |
3538 | AuxData *pAux = *pp; |
3539 | if( (iOp<0) |
3540 | || (pAux->iAuxOp==iOp |
3541 | && pAux->iAuxArg>=0 |
3542 | && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg)))) |
3543 | ){ |
3544 | testcase( pAux->iAuxArg==31 ); |
3545 | if( pAux->xDeleteAux ){ |
3546 | pAux->xDeleteAux(pAux->pAux); |
3547 | } |
3548 | *pp = pAux->pNextAux; |
3549 | sqlite3DbFree(db, pAux); |
3550 | }else{ |
3551 | pp= &pAux->pNextAux; |
3552 | } |
3553 | } |
3554 | } |
3555 | |
3556 | /* |
3557 | ** Free all memory associated with the Vdbe passed as the second argument, |
3558 | ** except for object itself, which is preserved. |
3559 | ** |
3560 | ** The difference between this function and sqlite3VdbeDelete() is that |
3561 | ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with |
3562 | ** the database connection and frees the object itself. |
3563 | */ |
3564 | static void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){ |
3565 | SubProgram *pSub, *pNext; |
3566 | assert( db!=0 ); |
3567 | assert( p->db==0 || p->db==db ); |
3568 | if( p->aColName ){ |
3569 | releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); |
3570 | sqlite3DbNNFreeNN(db, p->aColName); |
3571 | } |
3572 | for(pSub=p->pProgram; pSub; pSub=pNext){ |
3573 | pNext = pSub->pNext; |
3574 | vdbeFreeOpArray(db, pSub->aOp, pSub->nOp); |
3575 | sqlite3DbFree(db, pSub); |
3576 | } |
3577 | if( p->eVdbeState!=VDBE_INIT_STATE ){ |
3578 | releaseMemArray(p->aVar, p->nVar); |
3579 | if( p->pVList ) sqlite3DbNNFreeNN(db, p->pVList); |
3580 | if( p->pFree ) sqlite3DbNNFreeNN(db, p->pFree); |
3581 | } |
3582 | vdbeFreeOpArray(db, p->aOp, p->nOp); |
3583 | if( p->zSql ) sqlite3DbNNFreeNN(db, p->zSql); |
3584 | #ifdef SQLITE_ENABLE_NORMALIZE |
3585 | sqlite3DbFree(db, p->zNormSql); |
3586 | { |
3587 | DblquoteStr *pThis, *pNext; |
3588 | for(pThis=p->pDblStr; pThis; pThis=pNext){ |
3589 | pNext = pThis->pNextStr; |
3590 | sqlite3DbFree(db, pThis); |
3591 | } |
3592 | } |
3593 | #endif |
3594 | #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
3595 | { |
3596 | int i; |
3597 | for(i=0; i<p->nScan; i++){ |
3598 | sqlite3DbFree(db, p->aScan[i].zName); |
3599 | } |
3600 | sqlite3DbFree(db, p->aScan); |
3601 | } |
3602 | #endif |
3603 | } |
3604 | |
3605 | /* |
3606 | ** Delete an entire VDBE. |
3607 | */ |
3608 | void sqlite3VdbeDelete(Vdbe *p){ |
3609 | sqlite3 *db; |
3610 | |
3611 | assert( p!=0 ); |
3612 | db = p->db; |
3613 | assert( db!=0 ); |
3614 | assert( sqlite3_mutex_held(db->mutex) ); |
3615 | sqlite3VdbeClearObject(db, p); |
3616 | if( db->pnBytesFreed==0 ){ |
3617 | assert( p->ppVPrev!=0 ); |
3618 | *p->ppVPrev = p->pVNext; |
3619 | if( p->pVNext ){ |
3620 | p->pVNext->ppVPrev = p->ppVPrev; |
3621 | } |
3622 | } |
3623 | sqlite3DbNNFreeNN(db, p); |
3624 | } |
3625 | |
3626 | /* |
3627 | ** The cursor "p" has a pending seek operation that has not yet been |
3628 | ** carried out. Seek the cursor now. If an error occurs, return |
3629 | ** the appropriate error code. |
3630 | */ |
3631 | int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor *p){ |
3632 | int res, rc; |
3633 | #ifdef SQLITE_TEST |
3634 | extern int sqlite3_search_count; |
3635 | #endif |
3636 | assert( p->deferredMoveto ); |
3637 | assert( p->isTable ); |
3638 | assert( p->eCurType==CURTYPE_BTREE ); |
3639 | rc = sqlite3BtreeTableMoveto(p->uc.pCursor, p->movetoTarget, 0, &res); |
3640 | if( rc ) return rc; |
3641 | if( res!=0 ) return SQLITE_CORRUPT_BKPT; |
3642 | #ifdef SQLITE_TEST |
3643 | sqlite3_search_count++; |
3644 | #endif |
3645 | p->deferredMoveto = 0; |
3646 | p->cacheStatus = CACHE_STALE; |
3647 | return SQLITE_OK; |
3648 | } |
3649 | |
3650 | /* |
3651 | ** Something has moved cursor "p" out of place. Maybe the row it was |
3652 | ** pointed to was deleted out from under it. Or maybe the btree was |
3653 | ** rebalanced. Whatever the cause, try to restore "p" to the place it |
3654 | ** is supposed to be pointing. If the row was deleted out from under the |
3655 | ** cursor, set the cursor to point to a NULL row. |
3656 | */ |
3657 | int SQLITE_NOINLINE sqlite3VdbeHandleMovedCursor(VdbeCursor *p){ |
3658 | int isDifferentRow, rc; |
3659 | assert( p->eCurType==CURTYPE_BTREE ); |
3660 | assert( p->uc.pCursor!=0 ); |
3661 | assert( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ); |
3662 | rc = sqlite3BtreeCursorRestore(p->uc.pCursor, &isDifferentRow); |
3663 | p->cacheStatus = CACHE_STALE; |
3664 | if( isDifferentRow ) p->nullRow = 1; |
3665 | return rc; |
3666 | } |
3667 | |
3668 | /* |
3669 | ** Check to ensure that the cursor is valid. Restore the cursor |
3670 | ** if need be. Return any I/O error from the restore operation. |
3671 | */ |
3672 | int sqlite3VdbeCursorRestore(VdbeCursor *p){ |
3673 | assert( p->eCurType==CURTYPE_BTREE || IsNullCursor(p) ); |
3674 | if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){ |
3675 | return sqlite3VdbeHandleMovedCursor(p); |
3676 | } |
3677 | return SQLITE_OK; |
3678 | } |
3679 | |
3680 | /* |
3681 | ** The following functions: |
3682 | ** |
3683 | ** sqlite3VdbeSerialType() |
3684 | ** sqlite3VdbeSerialTypeLen() |
3685 | ** sqlite3VdbeSerialLen() |
3686 | ** sqlite3VdbeSerialPut() <--- in-lined into OP_MakeRecord as of 2022-04-02 |
3687 | ** sqlite3VdbeSerialGet() |
3688 | ** |
3689 | ** encapsulate the code that serializes values for storage in SQLite |
3690 | ** data and index records. Each serialized value consists of a |
3691 | ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned |
3692 | ** integer, stored as a varint. |
3693 | ** |
3694 | ** In an SQLite index record, the serial type is stored directly before |
3695 | ** the blob of data that it corresponds to. In a table record, all serial |
3696 | ** types are stored at the start of the record, and the blobs of data at |
3697 | ** the end. Hence these functions allow the caller to handle the |
3698 | ** serial-type and data blob separately. |
3699 | ** |
3700 | ** The following table describes the various storage classes for data: |
3701 | ** |
3702 | ** serial type bytes of data type |
3703 | ** -------------- --------------- --------------- |
3704 | ** 0 0 NULL |
3705 | ** 1 1 signed integer |
3706 | ** 2 2 signed integer |
3707 | ** 3 3 signed integer |
3708 | ** 4 4 signed integer |
3709 | ** 5 6 signed integer |
3710 | ** 6 8 signed integer |
3711 | ** 7 8 IEEE float |
3712 | ** 8 0 Integer constant 0 |
3713 | ** 9 0 Integer constant 1 |
3714 | ** 10,11 reserved for expansion |
3715 | ** N>=12 and even (N-12)/2 BLOB |
3716 | ** N>=13 and odd (N-13)/2 text |
3717 | ** |
3718 | ** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions |
3719 | ** of SQLite will not understand those serial types. |
3720 | */ |
3721 | |
3722 | #if 0 /* Inlined into the OP_MakeRecord opcode */ |
3723 | /* |
3724 | ** Return the serial-type for the value stored in pMem. |
3725 | ** |
3726 | ** This routine might convert a large MEM_IntReal value into MEM_Real. |
3727 | ** |
3728 | ** 2019-07-11: The primary user of this subroutine was the OP_MakeRecord |
3729 | ** opcode in the byte-code engine. But by moving this routine in-line, we |
3730 | ** can omit some redundant tests and make that opcode a lot faster. So |
3731 | ** this routine is now only used by the STAT3 logic and STAT3 support has |
3732 | ** ended. The code is kept here for historical reference only. |
3733 | */ |
3734 | u32 sqlite3VdbeSerialType(Mem *pMem, int file_format, u32 *pLen){ |
3735 | int flags = pMem->flags; |
3736 | u32 n; |
3737 | |
3738 | assert( pLen!=0 ); |
3739 | if( flags&MEM_Null ){ |
3740 | *pLen = 0; |
3741 | return 0; |
3742 | } |
3743 | if( flags&(MEM_Int|MEM_IntReal) ){ |
3744 | /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */ |
3745 | # define MAX_6BYTE ((((i64)0x00008000)<<32)-1) |
3746 | i64 i = pMem->u.i; |
3747 | u64 u; |
3748 | testcase( flags & MEM_Int ); |
3749 | testcase( flags & MEM_IntReal ); |
3750 | if( i<0 ){ |
3751 | u = ~i; |
3752 | }else{ |
3753 | u = i; |
3754 | } |
3755 | if( u<=127 ){ |
3756 | if( (i&1)==i && file_format>=4 ){ |
3757 | *pLen = 0; |
3758 | return 8+(u32)u; |
3759 | }else{ |
3760 | *pLen = 1; |
3761 | return 1; |
3762 | } |
3763 | } |
3764 | if( u<=32767 ){ *pLen = 2; return 2; } |
3765 | if( u<=8388607 ){ *pLen = 3; return 3; } |
3766 | if( u<=2147483647 ){ *pLen = 4; return 4; } |
3767 | if( u<=MAX_6BYTE ){ *pLen = 6; return 5; } |
3768 | *pLen = 8; |
3769 | if( flags&MEM_IntReal ){ |
3770 | /* If the value is IntReal and is going to take up 8 bytes to store |
3771 | ** as an integer, then we might as well make it an 8-byte floating |
3772 | ** point value */ |
3773 | pMem->u.r = (double)pMem->u.i; |
3774 | pMem->flags &= ~MEM_IntReal; |
3775 | pMem->flags |= MEM_Real; |
3776 | return 7; |
3777 | } |
3778 | return 6; |
3779 | } |
3780 | if( flags&MEM_Real ){ |
3781 | *pLen = 8; |
3782 | return 7; |
3783 | } |
3784 | assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) ); |
3785 | assert( pMem->n>=0 ); |
3786 | n = (u32)pMem->n; |
3787 | if( flags & MEM_Zero ){ |
3788 | n += pMem->u.nZero; |
3789 | } |
3790 | *pLen = n; |
3791 | return ((n*2) + 12 + ((flags&MEM_Str)!=0)); |
3792 | } |
3793 | #endif /* inlined into OP_MakeRecord */ |
3794 | |
3795 | /* |
3796 | ** The sizes for serial types less than 128 |
3797 | */ |
3798 | const u8 sqlite3SmallTypeSizes[128] = { |
3799 | /* 0 1 2 3 4 5 6 7 8 9 */ |
3800 | /* 0 */ 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, |
3801 | /* 10 */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, |
3802 | /* 20 */ 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, |
3803 | /* 30 */ 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, |
3804 | /* 40 */ 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, |
3805 | /* 50 */ 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, |
3806 | /* 60 */ 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, |
3807 | /* 70 */ 29, 29, 30, 30, 31, 31, 32, 32, 33, 33, |
3808 | /* 80 */ 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, |
3809 | /* 90 */ 39, 39, 40, 40, 41, 41, 42, 42, 43, 43, |
3810 | /* 100 */ 44, 44, 45, 45, 46, 46, 47, 47, 48, 48, |
3811 | /* 110 */ 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, |
3812 | /* 120 */ 54, 54, 55, 55, 56, 56, 57, 57 |
3813 | }; |
3814 | |
3815 | /* |
3816 | ** Return the length of the data corresponding to the supplied serial-type. |
3817 | */ |
3818 | u32 sqlite3VdbeSerialTypeLen(u32 serial_type){ |
3819 | if( serial_type>=128 ){ |
3820 | return (serial_type-12)/2; |
3821 | }else{ |
3822 | assert( serial_type<12 |
3823 | || sqlite3SmallTypeSizes[serial_type]==(serial_type - 12)/2 ); |
3824 | return sqlite3SmallTypeSizes[serial_type]; |
3825 | } |
3826 | } |
3827 | u8 sqlite3VdbeOneByteSerialTypeLen(u8 serial_type){ |
3828 | assert( serial_type<128 ); |
3829 | return sqlite3SmallTypeSizes[serial_type]; |
3830 | } |
3831 | |
3832 | /* |
3833 | ** If we are on an architecture with mixed-endian floating |
3834 | ** points (ex: ARM7) then swap the lower 4 bytes with the |
3835 | ** upper 4 bytes. Return the result. |
3836 | ** |
3837 | ** For most architectures, this is a no-op. |
3838 | ** |
3839 | ** (later): It is reported to me that the mixed-endian problem |
3840 | ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems |
3841 | ** that early versions of GCC stored the two words of a 64-bit |
3842 | ** float in the wrong order. And that error has been propagated |
3843 | ** ever since. The blame is not necessarily with GCC, though. |
3844 | ** GCC might have just copying the problem from a prior compiler. |
3845 | ** I am also told that newer versions of GCC that follow a different |
3846 | ** ABI get the byte order right. |
3847 | ** |
3848 | ** Developers using SQLite on an ARM7 should compile and run their |
3849 | ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG |
3850 | ** enabled, some asserts below will ensure that the byte order of |
3851 | ** floating point values is correct. |
3852 | ** |
3853 | ** (2007-08-30) Frank van Vugt has studied this problem closely |
3854 | ** and has send his findings to the SQLite developers. Frank |
3855 | ** writes that some Linux kernels offer floating point hardware |
3856 | ** emulation that uses only 32-bit mantissas instead of a full |
3857 | ** 48-bits as required by the IEEE standard. (This is the |
3858 | ** CONFIG_FPE_FASTFPE option.) On such systems, floating point |
3859 | ** byte swapping becomes very complicated. To avoid problems, |
3860 | ** the necessary byte swapping is carried out using a 64-bit integer |
3861 | ** rather than a 64-bit float. Frank assures us that the code here |
3862 | ** works for him. We, the developers, have no way to independently |
3863 | ** verify this, but Frank seems to know what he is talking about |
3864 | ** so we trust him. |
3865 | */ |
3866 | #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT |
3867 | u64 sqlite3FloatSwap(u64 in){ |
3868 | union { |
3869 | u64 r; |
3870 | u32 i[2]; |
3871 | } u; |
3872 | u32 t; |
3873 | |
3874 | u.r = in; |
3875 | t = u.i[0]; |
3876 | u.i[0] = u.i[1]; |
3877 | u.i[1] = t; |
3878 | return u.r; |
3879 | } |
3880 | #endif /* SQLITE_MIXED_ENDIAN_64BIT_FLOAT */ |
3881 | |
3882 | |
3883 | /* Input "x" is a sequence of unsigned characters that represent a |
3884 | ** big-endian integer. Return the equivalent native integer |
3885 | */ |
3886 | #define ONE_BYTE_INT(x) ((i8)(x)[0]) |
3887 | #define TWO_BYTE_INT(x) (256*(i8)((x)[0])|(x)[1]) |
3888 | #define THREE_BYTE_INT(x) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2]) |
3889 | #define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) |
3890 | #define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) |
3891 | |
3892 | /* |
3893 | ** Deserialize the data blob pointed to by buf as serial type serial_type |
3894 | ** and store the result in pMem. |
3895 | ** |
3896 | ** This function is implemented as two separate routines for performance. |
3897 | ** The few cases that require local variables are broken out into a separate |
3898 | ** routine so that in most cases the overhead of moving the stack pointer |
3899 | ** is avoided. |
3900 | */ |
3901 | static void serialGet( |
3902 | const unsigned char *buf, /* Buffer to deserialize from */ |
3903 | u32 serial_type, /* Serial type to deserialize */ |
3904 | Mem *pMem /* Memory cell to write value into */ |
3905 | ){ |
3906 | u64 x = FOUR_BYTE_UINT(buf); |
3907 | u32 y = FOUR_BYTE_UINT(buf+4); |
3908 | x = (x<<32) + y; |
3909 | if( serial_type==6 ){ |
3910 | /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit |
3911 | ** twos-complement integer. */ |
3912 | pMem->u.i = *(i64*)&x; |
3913 | pMem->flags = MEM_Int; |
3914 | testcase( pMem->u.i<0 ); |
3915 | }else{ |
3916 | /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit |
3917 | ** floating point number. */ |
3918 | #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT) |
3919 | /* Verify that integers and floating point values use the same |
3920 | ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is |
3921 | ** defined that 64-bit floating point values really are mixed |
3922 | ** endian. |
3923 | */ |
3924 | static const u64 t1 = ((u64)0x3ff00000)<<32; |
3925 | static const double r1 = 1.0; |
3926 | u64 t2 = t1; |
3927 | swapMixedEndianFloat(t2); |
3928 | assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 ); |
3929 | #endif |
3930 | assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 ); |
3931 | swapMixedEndianFloat(x); |
3932 | memcpy(&pMem->u.r, &x, sizeof(x)); |
3933 | pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real; |
3934 | } |
3935 | } |
3936 | void sqlite3VdbeSerialGet( |
3937 | const unsigned char *buf, /* Buffer to deserialize from */ |
3938 | u32 serial_type, /* Serial type to deserialize */ |
3939 | Mem *pMem /* Memory cell to write value into */ |
3940 | ){ |
3941 | switch( serial_type ){ |
3942 | case 10: { /* Internal use only: NULL with virtual table |
3943 | ** UPDATE no-change flag set */ |
3944 | pMem->flags = MEM_Null|MEM_Zero; |
3945 | pMem->n = 0; |
3946 | pMem->u.nZero = 0; |
3947 | return; |
3948 | } |
3949 | case 11: /* Reserved for future use */ |
3950 | case 0: { /* Null */ |
3951 | /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */ |
3952 | pMem->flags = MEM_Null; |
3953 | return; |
3954 | } |
3955 | case 1: { |
3956 | /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement |
3957 | ** integer. */ |
3958 | pMem->u.i = ONE_BYTE_INT(buf); |
3959 | pMem->flags = MEM_Int; |
3960 | testcase( pMem->u.i<0 ); |
3961 | return; |
3962 | } |
3963 | case 2: { /* 2-byte signed integer */ |
3964 | /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit |
3965 | ** twos-complement integer. */ |
3966 | pMem->u.i = TWO_BYTE_INT(buf); |
3967 | pMem->flags = MEM_Int; |
3968 | testcase( pMem->u.i<0 ); |
3969 | return; |
3970 | } |
3971 | case 3: { /* 3-byte signed integer */ |
3972 | /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit |
3973 | ** twos-complement integer. */ |
3974 | pMem->u.i = THREE_BYTE_INT(buf); |
3975 | pMem->flags = MEM_Int; |
3976 | testcase( pMem->u.i<0 ); |
3977 | return; |
3978 | } |
3979 | case 4: { /* 4-byte signed integer */ |
3980 | /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit |
3981 | ** twos-complement integer. */ |
3982 | pMem->u.i = FOUR_BYTE_INT(buf); |
3983 | #ifdef __HP_cc |
3984 | /* Work around a sign-extension bug in the HP compiler for HP/UX */ |
3985 | if( buf[0]&0x80 ) pMem->u.i |= 0xffffffff80000000LL; |
3986 | #endif |
3987 | pMem->flags = MEM_Int; |
3988 | testcase( pMem->u.i<0 ); |
3989 | return; |
3990 | } |
3991 | case 5: { /* 6-byte signed integer */ |
3992 | /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit |
3993 | ** twos-complement integer. */ |
3994 | pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf); |
3995 | pMem->flags = MEM_Int; |
3996 | testcase( pMem->u.i<0 ); |
3997 | return; |
3998 | } |
3999 | case 6: /* 8-byte signed integer */ |
4000 | case 7: { /* IEEE floating point */ |
4001 | /* These use local variables, so do them in a separate routine |
4002 | ** to avoid having to move the frame pointer in the common case */ |
4003 | serialGet(buf,serial_type,pMem); |
4004 | return; |
4005 | } |
4006 | case 8: /* Integer 0 */ |
4007 | case 9: { /* Integer 1 */ |
4008 | /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */ |
4009 | /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */ |
4010 | pMem->u.i = serial_type-8; |
4011 | pMem->flags = MEM_Int; |
4012 | return; |
4013 | } |
4014 | default: { |
4015 | /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in |
4016 | ** length. |
4017 | ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and |
4018 | ** (N-13)/2 bytes in length. */ |
4019 | static const u16 aFlag[] = { MEM_Blob|MEM_Ephem, MEM_Str|MEM_Ephem }; |
4020 | pMem->z = (char *)buf; |
4021 | pMem->n = (serial_type-12)/2; |
4022 | pMem->flags = aFlag[serial_type&1]; |
4023 | return; |
4024 | } |
4025 | } |
4026 | return; |
4027 | } |
4028 | /* |
4029 | ** This routine is used to allocate sufficient space for an UnpackedRecord |
4030 | ** structure large enough to be used with sqlite3VdbeRecordUnpack() if |
4031 | ** the first argument is a pointer to KeyInfo structure pKeyInfo. |
4032 | ** |
4033 | ** The space is either allocated using sqlite3DbMallocRaw() or from within |
4034 | ** the unaligned buffer passed via the second and third arguments (presumably |
4035 | ** stack space). If the former, then *ppFree is set to a pointer that should |
4036 | ** be eventually freed by the caller using sqlite3DbFree(). Or, if the |
4037 | ** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL |
4038 | ** before returning. |
4039 | ** |
4040 | ** If an OOM error occurs, NULL is returned. |
4041 | */ |
4042 | UnpackedRecord *sqlite3VdbeAllocUnpackedRecord( |
4043 | KeyInfo *pKeyInfo /* Description of the record */ |
4044 | ){ |
4045 | UnpackedRecord *p; /* Unpacked record to return */ |
4046 | int nByte; /* Number of bytes required for *p */ |
4047 | nByte = ROUND8P(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1); |
4048 | p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte); |
4049 | if( !p ) return 0; |
4050 | p->aMem = (Mem*)&((char*)p)[ROUND8P(sizeof(UnpackedRecord))]; |
4051 | assert( pKeyInfo->aSortFlags!=0 ); |
4052 | p->pKeyInfo = pKeyInfo; |
4053 | p->nField = pKeyInfo->nKeyField + 1; |
4054 | return p; |
4055 | } |
4056 | |
4057 | /* |
4058 | ** Given the nKey-byte encoding of a record in pKey[], populate the |
4059 | ** UnpackedRecord structure indicated by the fourth argument with the |
4060 | ** contents of the decoded record. |
4061 | */ |
4062 | void sqlite3VdbeRecordUnpack( |
4063 | KeyInfo *pKeyInfo, /* Information about the record format */ |
4064 | int nKey, /* Size of the binary record */ |
4065 | const void *pKey, /* The binary record */ |
4066 | UnpackedRecord *p /* Populate this structure before returning. */ |
4067 | ){ |
4068 | const unsigned char *aKey = (const unsigned char *)pKey; |
4069 | u32 d; |
4070 | u32 idx; /* Offset in aKey[] to read from */ |
4071 | u16 u; /* Unsigned loop counter */ |
4072 | u32 szHdr; |
4073 | Mem *pMem = p->aMem; |
4074 | |
4075 | p->default_rc = 0; |
4076 | assert( EIGHT_BYTE_ALIGNMENT(pMem) ); |
4077 | idx = getVarint32(aKey, szHdr); |
4078 | d = szHdr; |
4079 | u = 0; |
4080 | while( idx<szHdr && d<=(u32)nKey ){ |
4081 | u32 serial_type; |
4082 | |
4083 | idx += getVarint32(&aKey[idx], serial_type); |
4084 | pMem->enc = pKeyInfo->enc; |
4085 | pMem->db = pKeyInfo->db; |
4086 | /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */ |
4087 | pMem->szMalloc = 0; |
4088 | pMem->z = 0; |
4089 | sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem); |
4090 | d += sqlite3VdbeSerialTypeLen(serial_type); |
4091 | pMem++; |
4092 | if( (++u)>=p->nField ) break; |
4093 | } |
4094 | if( d>(u32)nKey && u ){ |
4095 | assert( CORRUPT_DB ); |
4096 | /* In a corrupt record entry, the last pMem might have been set up using |
4097 | ** uninitialized memory. Overwrite its value with NULL, to prevent |
4098 | ** warnings from MSAN. */ |
4099 | sqlite3VdbeMemSetNull(pMem-1); |
4100 | } |
4101 | assert( u<=pKeyInfo->nKeyField + 1 ); |
4102 | p->nField = u; |
4103 | } |
4104 | |
4105 | #ifdef SQLITE_DEBUG |
4106 | /* |
4107 | ** This function compares two index or table record keys in the same way |
4108 | ** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(), |
4109 | ** this function deserializes and compares values using the |
4110 | ** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used |
4111 | ** in assert() statements to ensure that the optimized code in |
4112 | ** sqlite3VdbeRecordCompare() returns results with these two primitives. |
4113 | ** |
4114 | ** Return true if the result of comparison is equivalent to desiredResult. |
4115 | ** Return false if there is a disagreement. |
4116 | */ |
4117 | static int vdbeRecordCompareDebug( |
4118 | int nKey1, const void *pKey1, /* Left key */ |
4119 | const UnpackedRecord *pPKey2, /* Right key */ |
4120 | int desiredResult /* Correct answer */ |
4121 | ){ |
4122 | u32 d1; /* Offset into aKey[] of next data element */ |
4123 | u32 idx1; /* Offset into aKey[] of next header element */ |
4124 | u32 szHdr1; /* Number of bytes in header */ |
4125 | int i = 0; |
4126 | int rc = 0; |
4127 | const unsigned char *aKey1 = (const unsigned char *)pKey1; |
4128 | KeyInfo *pKeyInfo; |
4129 | Mem mem1; |
4130 | |
4131 | pKeyInfo = pPKey2->pKeyInfo; |
4132 | if( pKeyInfo->db==0 ) return 1; |
4133 | mem1.enc = pKeyInfo->enc; |
4134 | mem1.db = pKeyInfo->db; |
4135 | /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */ |
4136 | VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */ |
4137 | |
4138 | /* Compilers may complain that mem1.u.i is potentially uninitialized. |
4139 | ** We could initialize it, as shown here, to silence those complaints. |
4140 | ** But in fact, mem1.u.i will never actually be used uninitialized, and doing |
4141 | ** the unnecessary initialization has a measurable negative performance |
4142 | ** impact, since this routine is a very high runner. And so, we choose |
4143 | ** to ignore the compiler warnings and leave this variable uninitialized. |
4144 | */ |
4145 | /* mem1.u.i = 0; // not needed, here to silence compiler warning */ |
4146 | |
4147 | idx1 = getVarint32(aKey1, szHdr1); |
4148 | if( szHdr1>98307 ) return SQLITE_CORRUPT; |
4149 | d1 = szHdr1; |
4150 | assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB ); |
4151 | assert( pKeyInfo->aSortFlags!=0 ); |
4152 | assert( pKeyInfo->nKeyField>0 ); |
4153 | assert( idx1<=szHdr1 || CORRUPT_DB ); |
4154 | do{ |
4155 | u32 serial_type1; |
4156 | |
4157 | /* Read the serial types for the next element in each key. */ |
4158 | idx1 += getVarint32( aKey1+idx1, serial_type1 ); |
4159 | |
4160 | /* Verify that there is enough key space remaining to avoid |
4161 | ** a buffer overread. The "d1+serial_type1+2" subexpression will |
4162 | ** always be greater than or equal to the amount of required key space. |
4163 | ** Use that approximation to avoid the more expensive call to |
4164 | ** sqlite3VdbeSerialTypeLen() in the common case. |
4165 | */ |
4166 | if( d1+(u64)serial_type1+2>(u64)nKey1 |
4167 | && d1+(u64)sqlite3VdbeSerialTypeLen(serial_type1)>(u64)nKey1 |
4168 | ){ |
4169 | break; |
4170 | } |
4171 | |
4172 | /* Extract the values to be compared. |
4173 | */ |
4174 | sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); |
4175 | d1 += sqlite3VdbeSerialTypeLen(serial_type1); |
4176 | |
4177 | /* Do the comparison |
4178 | */ |
4179 | rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], |
4180 | pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0); |
4181 | if( rc!=0 ){ |
4182 | assert( mem1.szMalloc==0 ); /* See comment below */ |
4183 | if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) |
4184 | && ((mem1.flags & MEM_Null) || (pPKey2->aMem[i].flags & MEM_Null)) |
4185 | ){ |
4186 | rc = -rc; |
4187 | } |
4188 | if( pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC ){ |
4189 | rc = -rc; /* Invert the result for DESC sort order. */ |
4190 | } |
4191 | goto debugCompareEnd; |
4192 | } |
4193 | i++; |
4194 | }while( idx1<szHdr1 && i<pPKey2->nField ); |
4195 | |
4196 | /* No memory allocation is ever used on mem1. Prove this using |
4197 | ** the following assert(). If the assert() fails, it indicates a |
4198 | ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). |
4199 | */ |
4200 | assert( mem1.szMalloc==0 ); |
4201 | |
4202 | /* rc==0 here means that one of the keys ran out of fields and |
4203 | ** all the fields up to that point were equal. Return the default_rc |
4204 | ** value. */ |
4205 | rc = pPKey2->default_rc; |
4206 | |
4207 | debugCompareEnd: |
4208 | if( desiredResult==0 && rc==0 ) return 1; |
4209 | if( desiredResult<0 && rc<0 ) return 1; |
4210 | if( desiredResult>0 && rc>0 ) return 1; |
4211 | if( CORRUPT_DB ) return 1; |
4212 | if( pKeyInfo->db->mallocFailed ) return 1; |
4213 | return 0; |
4214 | } |
4215 | #endif |
4216 | |
4217 | #ifdef SQLITE_DEBUG |
4218 | /* |
4219 | ** Count the number of fields (a.k.a. columns) in the record given by |
4220 | ** pKey,nKey. The verify that this count is less than or equal to the |
4221 | ** limit given by pKeyInfo->nAllField. |
4222 | ** |
4223 | ** If this constraint is not satisfied, it means that the high-speed |
4224 | ** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will |
4225 | ** not work correctly. If this assert() ever fires, it probably means |
4226 | ** that the KeyInfo.nKeyField or KeyInfo.nAllField values were computed |
4227 | ** incorrectly. |
4228 | */ |
4229 | static void vdbeAssertFieldCountWithinLimits( |
4230 | int nKey, const void *pKey, /* The record to verify */ |
4231 | const KeyInfo *pKeyInfo /* Compare size with this KeyInfo */ |
4232 | ){ |
4233 | int nField = 0; |
4234 | u32 szHdr; |
4235 | u32 idx; |
4236 | u32 notUsed; |
4237 | const unsigned char *aKey = (const unsigned char*)pKey; |
4238 | |
4239 | if( CORRUPT_DB ) return; |
4240 | idx = getVarint32(aKey, szHdr); |
4241 | assert( nKey>=0 ); |
4242 | assert( szHdr<=(u32)nKey ); |
4243 | while( idx<szHdr ){ |
4244 | idx += getVarint32(aKey+idx, notUsed); |
4245 | nField++; |
4246 | } |
4247 | assert( nField <= pKeyInfo->nAllField ); |
4248 | } |
4249 | #else |
4250 | # define vdbeAssertFieldCountWithinLimits(A,B,C) |
4251 | #endif |
4252 | |
4253 | /* |
4254 | ** Both *pMem1 and *pMem2 contain string values. Compare the two values |
4255 | ** using the collation sequence pColl. As usual, return a negative , zero |
4256 | ** or positive value if *pMem1 is less than, equal to or greater than |
4257 | ** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);". |
4258 | */ |
4259 | static int vdbeCompareMemString( |
4260 | const Mem *pMem1, |
4261 | const Mem *pMem2, |
4262 | const CollSeq *pColl, |
4263 | u8 *prcErr /* If an OOM occurs, set to SQLITE_NOMEM */ |
4264 | ){ |
4265 | if( pMem1->enc==pColl->enc ){ |
4266 | /* The strings are already in the correct encoding. Call the |
4267 | ** comparison function directly */ |
4268 | return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z); |
4269 | }else{ |
4270 | int rc; |
4271 | const void *v1, *v2; |
4272 | Mem c1; |
4273 | Mem c2; |
4274 | sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null); |
4275 | sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null); |
4276 | sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem); |
4277 | sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem); |
4278 | v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc); |
4279 | v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc); |
4280 | if( (v1==0 || v2==0) ){ |
4281 | if( prcErr ) *prcErr = SQLITE_NOMEM_BKPT; |
4282 | rc = 0; |
4283 | }else{ |
4284 | rc = pColl->xCmp(pColl->pUser, c1.n, v1, c2.n, v2); |
4285 | } |
4286 | sqlite3VdbeMemReleaseMalloc(&c1); |
4287 | sqlite3VdbeMemReleaseMalloc(&c2); |
4288 | return rc; |
4289 | } |
4290 | } |
4291 | |
4292 | /* |
4293 | ** The input pBlob is guaranteed to be a Blob that is not marked |
4294 | ** with MEM_Zero. Return true if it could be a zero-blob. |
4295 | */ |
4296 | static int isAllZero(const char *z, int n){ |
4297 | int i; |
4298 | for(i=0; i<n; i++){ |
4299 | if( z[i] ) return 0; |
4300 | } |
4301 | return 1; |
4302 | } |
4303 | |
4304 | /* |
4305 | ** Compare two blobs. Return negative, zero, or positive if the first |
4306 | ** is less than, equal to, or greater than the second, respectively. |
4307 | ** If one blob is a prefix of the other, then the shorter is the lessor. |
4308 | */ |
4309 | SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){ |
4310 | int c; |
4311 | int n1 = pB1->n; |
4312 | int n2 = pB2->n; |
4313 | |
4314 | /* It is possible to have a Blob value that has some non-zero content |
4315 | ** followed by zero content. But that only comes up for Blobs formed |
4316 | ** by the OP_MakeRecord opcode, and such Blobs never get passed into |
4317 | ** sqlite3MemCompare(). */ |
4318 | assert( (pB1->flags & MEM_Zero)==0 || n1==0 ); |
4319 | assert( (pB2->flags & MEM_Zero)==0 || n2==0 ); |
4320 | |
4321 | if( (pB1->flags|pB2->flags) & MEM_Zero ){ |
4322 | if( pB1->flags & pB2->flags & MEM_Zero ){ |
4323 | return pB1->u.nZero - pB2->u.nZero; |
4324 | }else if( pB1->flags & MEM_Zero ){ |
4325 | if( !isAllZero(pB2->z, pB2->n) ) return -1; |
4326 | return pB1->u.nZero - n2; |
4327 | }else{ |
4328 | if( !isAllZero(pB1->z, pB1->n) ) return +1; |
4329 | return n1 - pB2->u.nZero; |
4330 | } |
4331 | } |
4332 | c = memcmp(pB1->z, pB2->z, n1>n2 ? n2 : n1); |
4333 | if( c ) return c; |
4334 | return n1 - n2; |
4335 | } |
4336 | |
4337 | /* |
4338 | ** Do a comparison between a 64-bit signed integer and a 64-bit floating-point |
4339 | ** number. Return negative, zero, or positive if the first (i64) is less than, |
4340 | ** equal to, or greater than the second (double). |
4341 | */ |
4342 | int sqlite3IntFloatCompare(i64 i, double r){ |
4343 | if( sizeof(LONGDOUBLE_TYPE)>8 ){ |
4344 | LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i; |
4345 | testcase( x<r ); |
4346 | testcase( x>r ); |
4347 | testcase( x==r ); |
4348 | if( x<r ) return -1; |
4349 | if( x>r ) return +1; /*NO_TEST*/ /* work around bugs in gcov */ |
4350 | return 0; /*NO_TEST*/ /* work around bugs in gcov */ |
4351 | }else{ |
4352 | i64 y; |
4353 | double s; |
4354 | if( r<-9223372036854775808.0 ) return +1; |
4355 | if( r>=9223372036854775808.0 ) return -1; |
4356 | y = (i64)r; |
4357 | if( i<y ) return -1; |
4358 | if( i>y ) return +1; |
4359 | s = (double)i; |
4360 | if( s<r ) return -1; |
4361 | if( s>r ) return +1; |
4362 | return 0; |
4363 | } |
4364 | } |
4365 | |
4366 | /* |
4367 | ** Compare the values contained by the two memory cells, returning |
4368 | ** negative, zero or positive if pMem1 is less than, equal to, or greater |
4369 | ** than pMem2. Sorting order is NULL's first, followed by numbers (integers |
4370 | ** and reals) sorted numerically, followed by text ordered by the collating |
4371 | ** sequence pColl and finally blob's ordered by memcmp(). |
4372 | ** |
4373 | ** Two NULL values are considered equal by this function. |
4374 | */ |
4375 | int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){ |
4376 | int f1, f2; |
4377 | int combined_flags; |
4378 | |
4379 | f1 = pMem1->flags; |
4380 | f2 = pMem2->flags; |
4381 | combined_flags = f1|f2; |
4382 | assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) ); |
4383 | |
4384 | /* If one value is NULL, it is less than the other. If both values |
4385 | ** are NULL, return 0. |
4386 | */ |
4387 | if( combined_flags&MEM_Null ){ |
4388 | return (f2&MEM_Null) - (f1&MEM_Null); |
4389 | } |
4390 | |
4391 | /* At least one of the two values is a number |
4392 | */ |
4393 | if( combined_flags&(MEM_Int|MEM_Real|MEM_IntReal) ){ |
4394 | testcase( combined_flags & MEM_Int ); |
4395 | testcase( combined_flags & MEM_Real ); |
4396 | testcase( combined_flags & MEM_IntReal ); |
4397 | if( (f1 & f2 & (MEM_Int|MEM_IntReal))!=0 ){ |
4398 | testcase( f1 & f2 & MEM_Int ); |
4399 | testcase( f1 & f2 & MEM_IntReal ); |
4400 | if( pMem1->u.i < pMem2->u.i ) return -1; |
4401 | if( pMem1->u.i > pMem2->u.i ) return +1; |
4402 | return 0; |
4403 | } |
4404 | if( (f1 & f2 & MEM_Real)!=0 ){ |
4405 | if( pMem1->u.r < pMem2->u.r ) return -1; |
4406 | if( pMem1->u.r > pMem2->u.r ) return +1; |
4407 | return 0; |
4408 | } |
4409 | if( (f1&(MEM_Int|MEM_IntReal))!=0 ){ |
4410 | testcase( f1 & MEM_Int ); |
4411 | testcase( f1 & MEM_IntReal ); |
4412 | if( (f2&MEM_Real)!=0 ){ |
4413 | return sqlite3IntFloatCompare(pMem1->u.i, pMem2->u.r); |
4414 | }else if( (f2&(MEM_Int|MEM_IntReal))!=0 ){ |
4415 | if( pMem1->u.i < pMem2->u.i ) return -1; |
4416 | if( pMem1->u.i > pMem2->u.i ) return +1; |
4417 | return 0; |
4418 | }else{ |
4419 | return -1; |
4420 | } |
4421 | } |
4422 | if( (f1&MEM_Real)!=0 ){ |
4423 | if( (f2&(MEM_Int|MEM_IntReal))!=0 ){ |
4424 | testcase( f2 & MEM_Int ); |
4425 | testcase( f2 & MEM_IntReal ); |
4426 | return -sqlite3IntFloatCompare(pMem2->u.i, pMem1->u.r); |
4427 | }else{ |
4428 | return -1; |
4429 | } |
4430 | } |
4431 | return +1; |
4432 | } |
4433 | |
4434 | /* If one value is a string and the other is a blob, the string is less. |
4435 | ** If both are strings, compare using the collating functions. |
4436 | */ |
4437 | if( combined_flags&MEM_Str ){ |
4438 | if( (f1 & MEM_Str)==0 ){ |
4439 | return 1; |
4440 | } |
4441 | if( (f2 & MEM_Str)==0 ){ |
4442 | return -1; |
4443 | } |
4444 | |
4445 | assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed ); |
4446 | assert( pMem1->enc==SQLITE_UTF8 || |
4447 | pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE ); |
4448 | |
4449 | /* The collation sequence must be defined at this point, even if |
4450 | ** the user deletes the collation sequence after the vdbe program is |
4451 | ** compiled (this was not always the case). |
4452 | */ |
4453 | assert( !pColl || pColl->xCmp ); |
4454 | |
4455 | if( pColl ){ |
4456 | return vdbeCompareMemString(pMem1, pMem2, pColl, 0); |
4457 | } |
4458 | /* If a NULL pointer was passed as the collate function, fall through |
4459 | ** to the blob case and use memcmp(). */ |
4460 | } |
4461 | |
4462 | /* Both values must be blobs. Compare using memcmp(). */ |
4463 | return sqlite3BlobCompare(pMem1, pMem2); |
4464 | } |
4465 | |
4466 | |
4467 | /* |
4468 | ** The first argument passed to this function is a serial-type that |
4469 | ** corresponds to an integer - all values between 1 and 9 inclusive |
4470 | ** except 7. The second points to a buffer containing an integer value |
4471 | ** serialized according to serial_type. This function deserializes |
4472 | ** and returns the value. |
4473 | */ |
4474 | static i64 vdbeRecordDecodeInt(u32 serial_type, const u8 *aKey){ |
4475 | u32 y; |
4476 | assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) ); |
4477 | switch( serial_type ){ |
4478 | case 0: |
4479 | case 1: |
4480 | testcase( aKey[0]&0x80 ); |
4481 | return ONE_BYTE_INT(aKey); |
4482 | case 2: |
4483 | testcase( aKey[0]&0x80 ); |
4484 | return TWO_BYTE_INT(aKey); |
4485 | case 3: |
4486 | testcase( aKey[0]&0x80 ); |
4487 | return THREE_BYTE_INT(aKey); |
4488 | case 4: { |
4489 | testcase( aKey[0]&0x80 ); |
4490 | y = FOUR_BYTE_UINT(aKey); |
4491 | return (i64)*(int*)&y; |
4492 | } |
4493 | case 5: { |
4494 | testcase( aKey[0]&0x80 ); |
4495 | return FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey); |
4496 | } |
4497 | case 6: { |
4498 | u64 x = FOUR_BYTE_UINT(aKey); |
4499 | testcase( aKey[0]&0x80 ); |
4500 | x = (x<<32) | FOUR_BYTE_UINT(aKey+4); |
4501 | return (i64)*(i64*)&x; |
4502 | } |
4503 | } |
4504 | |
4505 | return (serial_type - 8); |
4506 | } |
4507 | |
4508 | /* |
4509 | ** This function compares the two table rows or index records |
4510 | ** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero |
4511 | ** or positive integer if key1 is less than, equal to or |
4512 | ** greater than key2. The {nKey1, pKey1} key must be a blob |
4513 | ** created by the OP_MakeRecord opcode of the VDBE. The pPKey2 |
4514 | ** key must be a parsed key such as obtained from |
4515 | ** sqlite3VdbeParseRecord. |
4516 | ** |
4517 | ** If argument bSkip is non-zero, it is assumed that the caller has already |
4518 | ** determined that the first fields of the keys are equal. |
4519 | ** |
4520 | ** Key1 and Key2 do not have to contain the same number of fields. If all |
4521 | ** fields that appear in both keys are equal, then pPKey2->default_rc is |
4522 | ** returned. |
4523 | ** |
4524 | ** If database corruption is discovered, set pPKey2->errCode to |
4525 | ** SQLITE_CORRUPT and return 0. If an OOM error is encountered, |
4526 | ** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the |
4527 | ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db). |
4528 | */ |
4529 | int sqlite3VdbeRecordCompareWithSkip( |
4530 | int nKey1, const void *pKey1, /* Left key */ |
4531 | UnpackedRecord *pPKey2, /* Right key */ |
4532 | int bSkip /* If true, skip the first field */ |
4533 | ){ |
4534 | u32 d1; /* Offset into aKey[] of next data element */ |
4535 | int i; /* Index of next field to compare */ |
4536 | u32 szHdr1; /* Size of record header in bytes */ |
4537 | u32 idx1; /* Offset of first type in header */ |
4538 | int rc = 0; /* Return value */ |
4539 | Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */ |
4540 | KeyInfo *pKeyInfo; |
4541 | const unsigned char *aKey1 = (const unsigned char *)pKey1; |
4542 | Mem mem1; |
4543 | |
4544 | /* If bSkip is true, then the caller has already determined that the first |
4545 | ** two elements in the keys are equal. Fix the various stack variables so |
4546 | ** that this routine begins comparing at the second field. */ |
4547 | if( bSkip ){ |
4548 | u32 s1 = aKey1[1]; |
4549 | if( s1<0x80 ){ |
4550 | idx1 = 2; |
4551 | }else{ |
4552 | idx1 = 1 + sqlite3GetVarint32(&aKey1[1], &s1); |
4553 | } |
4554 | szHdr1 = aKey1[0]; |
4555 | d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1); |
4556 | i = 1; |
4557 | pRhs++; |
4558 | }else{ |
4559 | if( (szHdr1 = aKey1[0])<0x80 ){ |
4560 | idx1 = 1; |
4561 | }else{ |
4562 | idx1 = sqlite3GetVarint32(aKey1, &szHdr1); |
4563 | } |
4564 | d1 = szHdr1; |
4565 | i = 0; |
4566 | } |
4567 | if( d1>(unsigned)nKey1 ){ |
4568 | pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; |
4569 | return 0; /* Corruption */ |
4570 | } |
4571 | |
4572 | VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */ |
4573 | assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField |
4574 | || CORRUPT_DB ); |
4575 | assert( pPKey2->pKeyInfo->aSortFlags!=0 ); |
4576 | assert( pPKey2->pKeyInfo->nKeyField>0 ); |
4577 | assert( idx1<=szHdr1 || CORRUPT_DB ); |
4578 | while( 1 /*exit-by-break*/ ){ |
4579 | u32 serial_type; |
4580 | |
4581 | /* RHS is an integer */ |
4582 | if( pRhs->flags & (MEM_Int|MEM_IntReal) ){ |
4583 | testcase( pRhs->flags & MEM_Int ); |
4584 | testcase( pRhs->flags & MEM_IntReal ); |
4585 | serial_type = aKey1[idx1]; |
4586 | testcase( serial_type==12 ); |
4587 | if( serial_type>=10 ){ |
4588 | rc = serial_type==10 ? -1 : +1; |
4589 | }else if( serial_type==0 ){ |
4590 | rc = -1; |
4591 | }else if( serial_type==7 ){ |
4592 | sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1); |
4593 | rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r); |
4594 | }else{ |
4595 | i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]); |
4596 | i64 rhs = pRhs->u.i; |
4597 | if( lhs<rhs ){ |
4598 | rc = -1; |
4599 | }else if( lhs>rhs ){ |
4600 | rc = +1; |
4601 | } |
4602 | } |
4603 | } |
4604 | |
4605 | /* RHS is real */ |
4606 | else if( pRhs->flags & MEM_Real ){ |
4607 | serial_type = aKey1[idx1]; |
4608 | if( serial_type>=10 ){ |
4609 | /* Serial types 12 or greater are strings and blobs (greater than |
4610 | ** numbers). Types 10 and 11 are currently "reserved for future |
4611 | ** use", so it doesn't really matter what the results of comparing |
4612 | ** them to numberic values are. */ |
4613 | rc = serial_type==10 ? -1 : +1; |
4614 | }else if( serial_type==0 ){ |
4615 | rc = -1; |
4616 | }else{ |
4617 | sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1); |
4618 | if( serial_type==7 ){ |
4619 | if( mem1.u.r<pRhs->u.r ){ |
4620 | rc = -1; |
4621 | }else if( mem1.u.r>pRhs->u.r ){ |
4622 | rc = +1; |
4623 | } |
4624 | }else{ |
4625 | rc = sqlite3IntFloatCompare(mem1.u.i, pRhs->u.r); |
4626 | } |
4627 | } |
4628 | } |
4629 | |
4630 | /* RHS is a string */ |
4631 | else if( pRhs->flags & MEM_Str ){ |
4632 | getVarint32NR(&aKey1[idx1], serial_type); |
4633 | testcase( serial_type==12 ); |
4634 | if( serial_type<12 ){ |
4635 | rc = -1; |
4636 | }else if( !(serial_type & 0x01) ){ |
4637 | rc = +1; |
4638 | }else{ |
4639 | mem1.n = (serial_type - 12) / 2; |
4640 | testcase( (d1+mem1.n)==(unsigned)nKey1 ); |
4641 | testcase( (d1+mem1.n+1)==(unsigned)nKey1 ); |
4642 | if( (d1+mem1.n) > (unsigned)nKey1 |
4643 | || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i |
4644 | ){ |
4645 | pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; |
4646 | return 0; /* Corruption */ |
4647 | }else if( pKeyInfo->aColl[i] ){ |
4648 | mem1.enc = pKeyInfo->enc; |
4649 | mem1.db = pKeyInfo->db; |
4650 | mem1.flags = MEM_Str; |
4651 | mem1.z = (char*)&aKey1[d1]; |
4652 | rc = vdbeCompareMemString( |
4653 | &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode |
4654 | ); |
4655 | }else{ |
4656 | int nCmp = MIN(mem1.n, pRhs->n); |
4657 | rc = memcmp(&aKey1[d1], pRhs->z, nCmp); |
4658 | if( rc==0 ) rc = mem1.n - pRhs->n; |
4659 | } |
4660 | } |
4661 | } |
4662 | |
4663 | /* RHS is a blob */ |
4664 | else if( pRhs->flags & MEM_Blob ){ |
4665 | assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 ); |
4666 | getVarint32NR(&aKey1[idx1], serial_type); |
4667 | testcase( serial_type==12 ); |
4668 | if( serial_type<12 || (serial_type & 0x01) ){ |
4669 | rc = -1; |
4670 | }else{ |
4671 | int nStr = (serial_type - 12) / 2; |
4672 | testcase( (d1+nStr)==(unsigned)nKey1 ); |
4673 | testcase( (d1+nStr+1)==(unsigned)nKey1 ); |
4674 | if( (d1+nStr) > (unsigned)nKey1 ){ |
4675 | pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; |
4676 | return 0; /* Corruption */ |
4677 | }else if( pRhs->flags & MEM_Zero ){ |
4678 | if( !isAllZero((const char*)&aKey1[d1],nStr) ){ |
4679 | rc = 1; |
4680 | }else{ |
4681 | rc = nStr - pRhs->u.nZero; |
4682 | } |
4683 | }else{ |
4684 | int nCmp = MIN(nStr, pRhs->n); |
4685 | rc = memcmp(&aKey1[d1], pRhs->z, nCmp); |
4686 | if( rc==0 ) rc = nStr - pRhs->n; |
4687 | } |
4688 | } |
4689 | } |
4690 | |
4691 | /* RHS is null */ |
4692 | else{ |
4693 | serial_type = aKey1[idx1]; |
4694 | rc = (serial_type!=0 && serial_type!=10); |
4695 | } |
4696 | |
4697 | if( rc!=0 ){ |
4698 | int sortFlags = pPKey2->pKeyInfo->aSortFlags[i]; |
4699 | if( sortFlags ){ |
4700 | if( (sortFlags & KEYINFO_ORDER_BIGNULL)==0 |
4701 | || ((sortFlags & KEYINFO_ORDER_DESC) |
4702 | !=(serial_type==0 || (pRhs->flags&MEM_Null))) |
4703 | ){ |
4704 | rc = -rc; |
4705 | } |
4706 | } |
4707 | assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) ); |
4708 | assert( mem1.szMalloc==0 ); /* See comment below */ |
4709 | return rc; |
4710 | } |
4711 | |
4712 | i++; |
4713 | if( i==pPKey2->nField ) break; |
4714 | pRhs++; |
4715 | d1 += sqlite3VdbeSerialTypeLen(serial_type); |
4716 | if( d1>(unsigned)nKey1 ) break; |
4717 | idx1 += sqlite3VarintLen(serial_type); |
4718 | if( idx1>=(unsigned)szHdr1 ){ |
4719 | pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; |
4720 | return 0; /* Corrupt index */ |
4721 | } |
4722 | } |
4723 | |
4724 | /* No memory allocation is ever used on mem1. Prove this using |
4725 | ** the following assert(). If the assert() fails, it indicates a |
4726 | ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */ |
4727 | assert( mem1.szMalloc==0 ); |
4728 | |
4729 | /* rc==0 here means that one or both of the keys ran out of fields and |
4730 | ** all the fields up to that point were equal. Return the default_rc |
4731 | ** value. */ |
4732 | assert( CORRUPT_DB |
4733 | || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, pPKey2->default_rc) |
4734 | || pPKey2->pKeyInfo->db->mallocFailed |
4735 | ); |
4736 | pPKey2->eqSeen = 1; |
4737 | return pPKey2->default_rc; |
4738 | } |
4739 | int sqlite3VdbeRecordCompare( |
4740 | int nKey1, const void *pKey1, /* Left key */ |
4741 | UnpackedRecord *pPKey2 /* Right key */ |
4742 | ){ |
4743 | return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 0); |
4744 | } |
4745 | |
4746 | |
4747 | /* |
4748 | ** This function is an optimized version of sqlite3VdbeRecordCompare() |
4749 | ** that (a) the first field of pPKey2 is an integer, and (b) the |
4750 | ** size-of-header varint at the start of (pKey1/nKey1) fits in a single |
4751 | ** byte (i.e. is less than 128). |
4752 | ** |
4753 | ** To avoid concerns about buffer overreads, this routine is only used |
4754 | ** on schemas where the maximum valid header size is 63 bytes or less. |
4755 | */ |
4756 | static int vdbeRecordCompareInt( |
4757 | int nKey1, const void *pKey1, /* Left key */ |
4758 | UnpackedRecord *pPKey2 /* Right key */ |
4759 | ){ |
4760 | const u8 *aKey = &((const u8*)pKey1)[*(const u8*)pKey1 & 0x3F]; |
4761 | int serial_type = ((const u8*)pKey1)[1]; |
4762 | int res; |
4763 | u32 y; |
4764 | u64 x; |
4765 | i64 v; |
4766 | i64 lhs; |
4767 | |
4768 | vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo); |
4769 | assert( (*(u8*)pKey1)<=0x3F || CORRUPT_DB ); |
4770 | switch( serial_type ){ |
4771 | case 1: { /* 1-byte signed integer */ |
4772 | lhs = ONE_BYTE_INT(aKey); |
4773 | testcase( lhs<0 ); |
4774 | break; |
4775 | } |
4776 | case 2: { /* 2-byte signed integer */ |
4777 | lhs = TWO_BYTE_INT(aKey); |
4778 | testcase( lhs<0 ); |
4779 | break; |
4780 | } |
4781 | case 3: { /* 3-byte signed integer */ |
4782 | lhs = THREE_BYTE_INT(aKey); |
4783 | testcase( lhs<0 ); |
4784 | break; |
4785 | } |
4786 | case 4: { /* 4-byte signed integer */ |
4787 | y = FOUR_BYTE_UINT(aKey); |
4788 | lhs = (i64)*(int*)&y; |
4789 | testcase( lhs<0 ); |
4790 | break; |
4791 | } |
4792 | case 5: { /* 6-byte signed integer */ |
4793 | lhs = FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey); |
4794 | testcase( lhs<0 ); |
4795 | break; |
4796 | } |
4797 | case 6: { /* 8-byte signed integer */ |
4798 | x = FOUR_BYTE_UINT(aKey); |
4799 | x = (x<<32) | FOUR_BYTE_UINT(aKey+4); |
4800 | lhs = *(i64*)&x; |
4801 | testcase( lhs<0 ); |
4802 | break; |
4803 | } |
4804 | case 8: |
4805 | lhs = 0; |
4806 | break; |
4807 | case 9: |
4808 | lhs = 1; |
4809 | break; |
4810 | |
4811 | /* This case could be removed without changing the results of running |
4812 | ** this code. Including it causes gcc to generate a faster switch |
4813 | ** statement (since the range of switch targets now starts at zero and |
4814 | ** is contiguous) but does not cause any duplicate code to be generated |
4815 | ** (as gcc is clever enough to combine the two like cases). Other |
4816 | ** compilers might be similar. */ |
4817 | case 0: case 7: |
4818 | return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2); |
4819 | |
4820 | default: |
4821 | return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2); |
4822 | } |
4823 | |
4824 | assert( pPKey2->u.i == pPKey2->aMem[0].u.i ); |
4825 | v = pPKey2->u.i; |
4826 | if( v>lhs ){ |
4827 | res = pPKey2->r1; |
4828 | }else if( v<lhs ){ |
4829 | res = pPKey2->r2; |
4830 | }else if( pPKey2->nField>1 ){ |
4831 | /* The first fields of the two keys are equal. Compare the trailing |
4832 | ** fields. */ |
4833 | res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1); |
4834 | }else{ |
4835 | /* The first fields of the two keys are equal and there are no trailing |
4836 | ** fields. Return pPKey2->default_rc in this case. */ |
4837 | res = pPKey2->default_rc; |
4838 | pPKey2->eqSeen = 1; |
4839 | } |
4840 | |
4841 | assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) ); |
4842 | return res; |
4843 | } |
4844 | |
4845 | /* |
4846 | ** This function is an optimized version of sqlite3VdbeRecordCompare() |
4847 | ** that (a) the first field of pPKey2 is a string, that (b) the first field |
4848 | ** uses the collation sequence BINARY and (c) that the size-of-header varint |
4849 | ** at the start of (pKey1/nKey1) fits in a single byte. |
4850 | */ |
4851 | static int vdbeRecordCompareString( |
4852 | int nKey1, const void *pKey1, /* Left key */ |
4853 | UnpackedRecord *pPKey2 /* Right key */ |
4854 | ){ |
4855 | const u8 *aKey1 = (const u8*)pKey1; |
4856 | int serial_type; |
4857 | int res; |
4858 | |
4859 | assert( pPKey2->aMem[0].flags & MEM_Str ); |
4860 | assert( pPKey2->aMem[0].n == pPKey2->n ); |
4861 | assert( pPKey2->aMem[0].z == pPKey2->u.z ); |
4862 | vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo); |
4863 | serial_type = (signed char)(aKey1[1]); |
4864 | |
4865 | vrcs_restart: |
4866 | if( serial_type<12 ){ |
4867 | if( serial_type<0 ){ |
4868 | sqlite3GetVarint32(&aKey1[1], (u32*)&serial_type); |
4869 | if( serial_type>=12 ) goto vrcs_restart; |
4870 | assert( CORRUPT_DB ); |
4871 | } |
4872 | res = pPKey2->r1; /* (pKey1/nKey1) is a number or a null */ |
4873 | }else if( !(serial_type & 0x01) ){ |
4874 | res = pPKey2->r2; /* (pKey1/nKey1) is a blob */ |
4875 | }else{ |
4876 | int nCmp; |
4877 | int nStr; |
4878 | int szHdr = aKey1[0]; |
4879 | |
4880 | nStr = (serial_type-12) / 2; |
4881 | if( (szHdr + nStr) > nKey1 ){ |
4882 | pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; |
4883 | return 0; /* Corruption */ |
4884 | } |
4885 | nCmp = MIN( pPKey2->n, nStr ); |
4886 | res = memcmp(&aKey1[szHdr], pPKey2->u.z, nCmp); |
4887 | |
4888 | if( res>0 ){ |
4889 | res = pPKey2->r2; |
4890 | }else if( res<0 ){ |
4891 | res = pPKey2->r1; |
4892 | }else{ |
4893 | res = nStr - pPKey2->n; |
4894 | if( res==0 ){ |
4895 | if( pPKey2->nField>1 ){ |
4896 | res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1); |
4897 | }else{ |
4898 | res = pPKey2->default_rc; |
4899 | pPKey2->eqSeen = 1; |
4900 | } |
4901 | }else if( res>0 ){ |
4902 | res = pPKey2->r2; |
4903 | }else{ |
4904 | res = pPKey2->r1; |
4905 | } |
4906 | } |
4907 | } |
4908 | |
4909 | assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) |
4910 | || CORRUPT_DB |
4911 | || pPKey2->pKeyInfo->db->mallocFailed |
4912 | ); |
4913 | return res; |
4914 | } |
4915 | |
4916 | /* |
4917 | ** Return a pointer to an sqlite3VdbeRecordCompare() compatible function |
4918 | ** suitable for comparing serialized records to the unpacked record passed |
4919 | ** as the only argument. |
4920 | */ |
4921 | RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){ |
4922 | /* varintRecordCompareInt() and varintRecordCompareString() both assume |
4923 | ** that the size-of-header varint that occurs at the start of each record |
4924 | ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt() |
4925 | ** also assumes that it is safe to overread a buffer by at least the |
4926 | ** maximum possible legal header size plus 8 bytes. Because there is |
4927 | ** guaranteed to be at least 74 (but not 136) bytes of padding following each |
4928 | ** buffer passed to varintRecordCompareInt() this makes it convenient to |
4929 | ** limit the size of the header to 64 bytes in cases where the first field |
4930 | ** is an integer. |
4931 | ** |
4932 | ** The easiest way to enforce this limit is to consider only records with |
4933 | ** 13 fields or less. If the first field is an integer, the maximum legal |
4934 | ** header size is (12*5 + 1 + 1) bytes. */ |
4935 | if( p->pKeyInfo->nAllField<=13 ){ |
4936 | int flags = p->aMem[0].flags; |
4937 | if( p->pKeyInfo->aSortFlags[0] ){ |
4938 | if( p->pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL ){ |
4939 | return sqlite3VdbeRecordCompare; |
4940 | } |
4941 | p->r1 = 1; |
4942 | p->r2 = -1; |
4943 | }else{ |
4944 | p->r1 = -1; |
4945 | p->r2 = 1; |
4946 | } |
4947 | if( (flags & MEM_Int) ){ |
4948 | p->u.i = p->aMem[0].u.i; |
4949 | return vdbeRecordCompareInt; |
4950 | } |
4951 | testcase( flags & MEM_Real ); |
4952 | testcase( flags & MEM_Null ); |
4953 | testcase( flags & MEM_Blob ); |
4954 | if( (flags & (MEM_Real|MEM_IntReal|MEM_Null|MEM_Blob))==0 |
4955 | && p->pKeyInfo->aColl[0]==0 |
4956 | ){ |
4957 | assert( flags & MEM_Str ); |
4958 | p->u.z = p->aMem[0].z; |
4959 | p->n = p->aMem[0].n; |
4960 | return vdbeRecordCompareString; |
4961 | } |
4962 | } |
4963 | |
4964 | return sqlite3VdbeRecordCompare; |
4965 | } |
4966 | |
4967 | /* |
4968 | ** pCur points at an index entry created using the OP_MakeRecord opcode. |
4969 | ** Read the rowid (the last field in the record) and store it in *rowid. |
4970 | ** Return SQLITE_OK if everything works, or an error code otherwise. |
4971 | ** |
4972 | ** pCur might be pointing to text obtained from a corrupt database file. |
4973 | ** So the content cannot be trusted. Do appropriate checks on the content. |
4974 | */ |
4975 | int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){ |
4976 | i64 nCellKey = 0; |
4977 | int rc; |
4978 | u32 szHdr; /* Size of the header */ |
4979 | u32 typeRowid; /* Serial type of the rowid */ |
4980 | u32 lenRowid; /* Size of the rowid */ |
4981 | Mem m, v; |
4982 | |
4983 | /* Get the size of the index entry. Only indices entries of less |
4984 | ** than 2GiB are support - anything large must be database corruption. |
4985 | ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so |
4986 | ** this code can safely assume that nCellKey is 32-bits |
4987 | */ |
4988 | assert( sqlite3BtreeCursorIsValid(pCur) ); |
4989 | nCellKey = sqlite3BtreePayloadSize(pCur); |
4990 | assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey ); |
4991 | |
4992 | /* Read in the complete content of the index entry */ |
4993 | sqlite3VdbeMemInit(&m, db, 0); |
4994 | rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m); |
4995 | if( rc ){ |
4996 | return rc; |
4997 | } |
4998 | |
4999 | /* The index entry must begin with a header size */ |
5000 | getVarint32NR((u8*)m.z, szHdr); |
5001 | testcase( szHdr==3 ); |
5002 | testcase( szHdr==(u32)m.n ); |
5003 | testcase( szHdr>0x7fffffff ); |
5004 | assert( m.n>=0 ); |
5005 | if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){ |
5006 | goto idx_rowid_corruption; |
5007 | } |
5008 | |
5009 | /* The last field of the index should be an integer - the ROWID. |
5010 | ** Verify that the last entry really is an integer. */ |
5011 | getVarint32NR((u8*)&m.z[szHdr-1], typeRowid); |
5012 | testcase( typeRowid==1 ); |
5013 | testcase( typeRowid==2 ); |
5014 | testcase( typeRowid==3 ); |
5015 | testcase( typeRowid==4 ); |
5016 | testcase( typeRowid==5 ); |
5017 | testcase( typeRowid==6 ); |
5018 | testcase( typeRowid==8 ); |
5019 | testcase( typeRowid==9 ); |
5020 | if( unlikely(typeRowid<1 || typeRowid>9 || typeRowid==7) ){ |
5021 | goto idx_rowid_corruption; |
5022 | } |
5023 | lenRowid = sqlite3SmallTypeSizes[typeRowid]; |
5024 | testcase( (u32)m.n==szHdr+lenRowid ); |
5025 | if( unlikely((u32)m.n<szHdr+lenRowid) ){ |
5026 | goto idx_rowid_corruption; |
5027 | } |
5028 | |
5029 | /* Fetch the integer off the end of the index record */ |
5030 | sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v); |
5031 | *rowid = v.u.i; |
5032 | sqlite3VdbeMemReleaseMalloc(&m); |
5033 | return SQLITE_OK; |
5034 | |
5035 | /* Jump here if database corruption is detected after m has been |
5036 | ** allocated. Free the m object and return SQLITE_CORRUPT. */ |
5037 | idx_rowid_corruption: |
5038 | testcase( m.szMalloc!=0 ); |
5039 | sqlite3VdbeMemReleaseMalloc(&m); |
5040 | return SQLITE_CORRUPT_BKPT; |
5041 | } |
5042 | |
5043 | /* |
5044 | ** Compare the key of the index entry that cursor pC is pointing to against |
5045 | ** the key string in pUnpacked. Write into *pRes a number |
5046 | ** that is negative, zero, or positive if pC is less than, equal to, |
5047 | ** or greater than pUnpacked. Return SQLITE_OK on success. |
5048 | ** |
5049 | ** pUnpacked is either created without a rowid or is truncated so that it |
5050 | ** omits the rowid at the end. The rowid at the end of the index entry |
5051 | ** is ignored as well. Hence, this routine only compares the prefixes |
5052 | ** of the keys prior to the final rowid, not the entire key. |
5053 | */ |
5054 | int sqlite3VdbeIdxKeyCompare( |
5055 | sqlite3 *db, /* Database connection */ |
5056 | VdbeCursor *pC, /* The cursor to compare against */ |
5057 | UnpackedRecord *pUnpacked, /* Unpacked version of key */ |
5058 | int *res /* Write the comparison result here */ |
5059 | ){ |
5060 | i64 nCellKey = 0; |
5061 | int rc; |
5062 | BtCursor *pCur; |
5063 | Mem m; |
5064 | |
5065 | assert( pC->eCurType==CURTYPE_BTREE ); |
5066 | pCur = pC->uc.pCursor; |
5067 | assert( sqlite3BtreeCursorIsValid(pCur) ); |
5068 | nCellKey = sqlite3BtreePayloadSize(pCur); |
5069 | /* nCellKey will always be between 0 and 0xffffffff because of the way |
5070 | ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */ |
5071 | if( nCellKey<=0 || nCellKey>0x7fffffff ){ |
5072 | *res = 0; |
5073 | return SQLITE_CORRUPT_BKPT; |
5074 | } |
5075 | sqlite3VdbeMemInit(&m, db, 0); |
5076 | rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m); |
5077 | if( rc ){ |
5078 | return rc; |
5079 | } |
5080 | *res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, pUnpacked, 0); |
5081 | sqlite3VdbeMemReleaseMalloc(&m); |
5082 | return SQLITE_OK; |
5083 | } |
5084 | |
5085 | /* |
5086 | ** This routine sets the value to be returned by subsequent calls to |
5087 | ** sqlite3_changes() on the database handle 'db'. |
5088 | */ |
5089 | void sqlite3VdbeSetChanges(sqlite3 *db, i64 nChange){ |
5090 | assert( sqlite3_mutex_held(db->mutex) ); |
5091 | db->nChange = nChange; |
5092 | db->nTotalChange += nChange; |
5093 | } |
5094 | |
5095 | /* |
5096 | ** Set a flag in the vdbe to update the change counter when it is finalised |
5097 | ** or reset. |
5098 | */ |
5099 | void sqlite3VdbeCountChanges(Vdbe *v){ |
5100 | v->changeCntOn = 1; |
5101 | } |
5102 | |
5103 | /* |
5104 | ** Mark every prepared statement associated with a database connection |
5105 | ** as expired. |
5106 | ** |
5107 | ** An expired statement means that recompilation of the statement is |
5108 | ** recommend. Statements expire when things happen that make their |
5109 | ** programs obsolete. Removing user-defined functions or collating |
5110 | ** sequences, or changing an authorization function are the types of |
5111 | ** things that make prepared statements obsolete. |
5112 | ** |
5113 | ** If iCode is 1, then expiration is advisory. The statement should |
5114 | ** be reprepared before being restarted, but if it is already running |
5115 | ** it is allowed to run to completion. |
5116 | ** |
5117 | ** Internally, this function just sets the Vdbe.expired flag on all |
5118 | ** prepared statements. The flag is set to 1 for an immediate expiration |
5119 | ** and set to 2 for an advisory expiration. |
5120 | */ |
5121 | void sqlite3ExpirePreparedStatements(sqlite3 *db, int iCode){ |
5122 | Vdbe *p; |
5123 | for(p = db->pVdbe; p; p=p->pVNext){ |
5124 | p->expired = iCode+1; |
5125 | } |
5126 | } |
5127 | |
5128 | /* |
5129 | ** Return the database associated with the Vdbe. |
5130 | */ |
5131 | sqlite3 *sqlite3VdbeDb(Vdbe *v){ |
5132 | return v->db; |
5133 | } |
5134 | |
5135 | /* |
5136 | ** Return the SQLITE_PREPARE flags for a Vdbe. |
5137 | */ |
5138 | u8 sqlite3VdbePrepareFlags(Vdbe *v){ |
5139 | return v->prepFlags; |
5140 | } |
5141 | |
5142 | /* |
5143 | ** Return a pointer to an sqlite3_value structure containing the value bound |
5144 | ** parameter iVar of VM v. Except, if the value is an SQL NULL, return |
5145 | ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_* |
5146 | ** constants) to the value before returning it. |
5147 | ** |
5148 | ** The returned value must be freed by the caller using sqlite3ValueFree(). |
5149 | */ |
5150 | sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){ |
5151 | assert( iVar>0 ); |
5152 | if( v ){ |
5153 | Mem *pMem = &v->aVar[iVar-1]; |
5154 | assert( (v->db->flags & SQLITE_EnableQPSG)==0 ); |
5155 | if( 0==(pMem->flags & MEM_Null) ){ |
5156 | sqlite3_value *pRet = sqlite3ValueNew(v->db); |
5157 | if( pRet ){ |
5158 | sqlite3VdbeMemCopy((Mem *)pRet, pMem); |
5159 | sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8); |
5160 | } |
5161 | return pRet; |
5162 | } |
5163 | } |
5164 | return 0; |
5165 | } |
5166 | |
5167 | /* |
5168 | ** Configure SQL variable iVar so that binding a new value to it signals |
5169 | ** to sqlite3_reoptimize() that re-preparing the statement may result |
5170 | ** in a better query plan. |
5171 | */ |
5172 | void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){ |
5173 | assert( iVar>0 ); |
5174 | assert( (v->db->flags & SQLITE_EnableQPSG)==0 ); |
5175 | if( iVar>=32 ){ |
5176 | v->expmask |= 0x80000000; |
5177 | }else{ |
5178 | v->expmask |= ((u32)1 << (iVar-1)); |
5179 | } |
5180 | } |
5181 | |
5182 | /* |
5183 | ** Cause a function to throw an error if it was call from OP_PureFunc |
5184 | ** rather than OP_Function. |
5185 | ** |
5186 | ** OP_PureFunc means that the function must be deterministic, and should |
5187 | ** throw an error if it is given inputs that would make it non-deterministic. |
5188 | ** This routine is invoked by date/time functions that use non-deterministic |
5189 | ** features such as 'now'. |
5190 | */ |
5191 | int sqlite3NotPureFunc(sqlite3_context *pCtx){ |
5192 | const VdbeOp *pOp; |
5193 | #ifdef SQLITE_ENABLE_STAT4 |
5194 | if( pCtx->pVdbe==0 ) return 1; |
5195 | #endif |
5196 | pOp = pCtx->pVdbe->aOp + pCtx->iOp; |
5197 | if( pOp->opcode==OP_PureFunc ){ |
5198 | const char *zContext; |
5199 | char *zMsg; |
5200 | if( pOp->p5 & NC_IsCheck ){ |
5201 | zContext = "a CHECK constraint" ; |
5202 | }else if( pOp->p5 & NC_GenCol ){ |
5203 | zContext = "a generated column" ; |
5204 | }else{ |
5205 | zContext = "an index" ; |
5206 | } |
5207 | zMsg = sqlite3_mprintf("non-deterministic use of %s() in %s" , |
5208 | pCtx->pFunc->zName, zContext); |
5209 | sqlite3_result_error(pCtx, zMsg, -1); |
5210 | sqlite3_free(zMsg); |
5211 | return 0; |
5212 | } |
5213 | return 1; |
5214 | } |
5215 | |
5216 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
5217 | /* |
5218 | ** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored |
5219 | ** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored |
5220 | ** in memory obtained from sqlite3DbMalloc). |
5221 | */ |
5222 | void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){ |
5223 | if( pVtab->zErrMsg ){ |
5224 | sqlite3 *db = p->db; |
5225 | sqlite3DbFree(db, p->zErrMsg); |
5226 | p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg); |
5227 | sqlite3_free(pVtab->zErrMsg); |
5228 | pVtab->zErrMsg = 0; |
5229 | } |
5230 | } |
5231 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
5232 | |
5233 | #ifdef SQLITE_ENABLE_PREUPDATE_HOOK |
5234 | |
5235 | /* |
5236 | ** If the second argument is not NULL, release any allocations associated |
5237 | ** with the memory cells in the p->aMem[] array. Also free the UnpackedRecord |
5238 | ** structure itself, using sqlite3DbFree(). |
5239 | ** |
5240 | ** This function is used to free UnpackedRecord structures allocated by |
5241 | ** the vdbeUnpackRecord() function found in vdbeapi.c. |
5242 | */ |
5243 | static void vdbeFreeUnpacked(sqlite3 *db, int nField, UnpackedRecord *p){ |
5244 | assert( db!=0 ); |
5245 | if( p ){ |
5246 | int i; |
5247 | for(i=0; i<nField; i++){ |
5248 | Mem *pMem = &p->aMem[i]; |
5249 | if( pMem->zMalloc ) sqlite3VdbeMemReleaseMalloc(pMem); |
5250 | } |
5251 | sqlite3DbNNFreeNN(db, p); |
5252 | } |
5253 | } |
5254 | #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ |
5255 | |
5256 | #ifdef SQLITE_ENABLE_PREUPDATE_HOOK |
5257 | /* |
5258 | ** Invoke the pre-update hook. If this is an UPDATE or DELETE pre-update call, |
5259 | ** then cursor passed as the second argument should point to the row about |
5260 | ** to be update or deleted. If the application calls sqlite3_preupdate_old(), |
5261 | ** the required value will be read from the row the cursor points to. |
5262 | */ |
5263 | void sqlite3VdbePreUpdateHook( |
5264 | Vdbe *v, /* Vdbe pre-update hook is invoked by */ |
5265 | VdbeCursor *pCsr, /* Cursor to grab old.* values from */ |
5266 | int op, /* SQLITE_INSERT, UPDATE or DELETE */ |
5267 | const char *zDb, /* Database name */ |
5268 | Table *pTab, /* Modified table */ |
5269 | i64 iKey1, /* Initial key value */ |
5270 | int iReg, /* Register for new.* record */ |
5271 | int iBlobWrite |
5272 | ){ |
5273 | sqlite3 *db = v->db; |
5274 | i64 iKey2; |
5275 | PreUpdate preupdate; |
5276 | const char *zTbl = pTab->zName; |
5277 | static const u8 fakeSortOrder = 0; |
5278 | |
5279 | assert( db->pPreUpdate==0 ); |
5280 | memset(&preupdate, 0, sizeof(PreUpdate)); |
5281 | if( HasRowid(pTab)==0 ){ |
5282 | iKey1 = iKey2 = 0; |
5283 | preupdate.pPk = sqlite3PrimaryKeyIndex(pTab); |
5284 | }else{ |
5285 | if( op==SQLITE_UPDATE ){ |
5286 | iKey2 = v->aMem[iReg].u.i; |
5287 | }else{ |
5288 | iKey2 = iKey1; |
5289 | } |
5290 | } |
5291 | |
5292 | assert( pCsr!=0 ); |
5293 | assert( pCsr->eCurType==CURTYPE_BTREE ); |
5294 | assert( pCsr->nField==pTab->nCol |
5295 | || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1) |
5296 | ); |
5297 | |
5298 | preupdate.v = v; |
5299 | preupdate.pCsr = pCsr; |
5300 | preupdate.op = op; |
5301 | preupdate.iNewReg = iReg; |
5302 | preupdate.keyinfo.db = db; |
5303 | preupdate.keyinfo.enc = ENC(db); |
5304 | preupdate.keyinfo.nKeyField = pTab->nCol; |
5305 | preupdate.keyinfo.aSortFlags = (u8*)&fakeSortOrder; |
5306 | preupdate.iKey1 = iKey1; |
5307 | preupdate.iKey2 = iKey2; |
5308 | preupdate.pTab = pTab; |
5309 | preupdate.iBlobWrite = iBlobWrite; |
5310 | |
5311 | db->pPreUpdate = &preupdate; |
5312 | db->xPreUpdateCallback(db->pPreUpdateArg, db, op, zDb, zTbl, iKey1, iKey2); |
5313 | db->pPreUpdate = 0; |
5314 | sqlite3DbFree(db, preupdate.aRecord); |
5315 | vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pUnpacked); |
5316 | vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pNewUnpacked); |
5317 | if( preupdate.aNew ){ |
5318 | int i; |
5319 | for(i=0; i<pCsr->nField; i++){ |
5320 | sqlite3VdbeMemRelease(&preupdate.aNew[i]); |
5321 | } |
5322 | sqlite3DbNNFreeNN(db, preupdate.aNew); |
5323 | } |
5324 | } |
5325 | #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ |
5326 | |